mirror of
https://github.com/webinstall/webi-installers.git
synced 2026-02-14 09:39:51 +00:00
260 lines
6.8 KiB
JavaScript
260 lines
6.8 KiB
JavaScript
'use strict';
|
|
|
|
// this may need customizations between packages
|
|
var osMap = {
|
|
macos: /(\b|_)(apple|os(\s_-)?x\b|mac|darwin|iPhone|iOS|iPad)/i,
|
|
linux: /(\b|_)(linux)/i,
|
|
freebsd: /(\b|_)(freebsd)/i,
|
|
windows: /(\b|_)(win|microsoft|msft)/i,
|
|
sunos: /(\b|_)(sun)/i,
|
|
aix: /(\b|_)(aix)/i,
|
|
};
|
|
|
|
var maps = {
|
|
oses: {},
|
|
arches: {},
|
|
libcs: {},
|
|
formats: {},
|
|
};
|
|
|
|
Object.keys(osMap).forEach(function (name) {
|
|
maps.oses[name] = true;
|
|
});
|
|
|
|
var formats = ['zip', 'xz', 'tar', 'pkg', 'msi', 'git', 'exe', 'dmg', 'git'];
|
|
formats.forEach(function (name) {
|
|
maps.formats[name] = true;
|
|
});
|
|
|
|
// evaluation order matters
|
|
// (i.e. otherwise x86 and x64 can cross match)
|
|
var arches = [
|
|
// arm64/aarch64 has very high specificity, so it comes first
|
|
'arm64',
|
|
// arm 7 is also generic aarch/arm/arm32
|
|
'armv7l',
|
|
// arm6 can run on armv7
|
|
'armv6l',
|
|
// amd64 is more likely and less often specified than arm64
|
|
'amd64',
|
|
'x86',
|
|
'ppc64le',
|
|
'ppc64',
|
|
's390x',
|
|
];
|
|
// Used for detecting system arch from package download url, for example:
|
|
//
|
|
// https://git.com/org/foo/releases/v0.7.9/foo-aarch64-linux-musl.tar.gz
|
|
// https://git.com/org/foo/releases/v0.7.9/foo-arm-linux-musleabihf.tar.gz
|
|
// https://git.com/org/foo/releases/v0.7.9/foo-armv7-linux-musleabihf.tar.gz
|
|
// https://git.com/org/foo/releases/v0.7.9/foo-x86_64-linux-musl.tar.gz
|
|
//
|
|
var archMap = {
|
|
arm64: /(\b|_)(aarch64|arm64)/i,
|
|
armv7l: /(\b|_)(arm32|arm[_\-]?v?7l?)/i,
|
|
armv6l: /(\b|_)(arm|aarch32|arm[_\-]?v?6l?)(\b|_)/i,
|
|
//amd64: /(amd.?64|x64|[_\-]64)/i,
|
|
amd64:
|
|
/(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)64([_\-]?bit)?(\b|_)/i,
|
|
//x86: /(86)(\b|_)/i,
|
|
x86: /(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)(86|32|i?386)([_\-]?bit)?(\b|_)/i,
|
|
ppc64le: /(\b|_)(ppc64le)/i,
|
|
ppc64: /(\b|_)(ppc64)(\b|_)/i,
|
|
s390x: /(\b|_)(s390x)/i,
|
|
};
|
|
arches.forEach(function (name) {
|
|
maps.arches[name] = true;
|
|
});
|
|
|
|
var libcs = ['none', 'musl', 'gnu', 'msvc', 'libc'];
|
|
libcs.forEach(function (name) {
|
|
maps.libcs[name] = true;
|
|
});
|
|
|
|
function normalize(all) {
|
|
/* jshint maxcomplexity:50 */
|
|
/* jshint maxdepth:10 */
|
|
var supported = {
|
|
oses: {},
|
|
arches: {},
|
|
libcs: {},
|
|
formats: {},
|
|
};
|
|
|
|
for (let rel of all.releases) {
|
|
rel.version = rel.version.replace(/^v/i, '');
|
|
|
|
if (!rel.name) {
|
|
rel.name = rel.download.replace(/.*\//, '');
|
|
}
|
|
|
|
if (!rel.os) {
|
|
rel.os = 'unknown';
|
|
|
|
let osNames = Object.keys(osMap);
|
|
for (let osName of osNames) {
|
|
let relName = rel.name || rel.download;
|
|
let osRegExp = osMap[osName];
|
|
let matches = osRegExp.test(relName);
|
|
if (matches) {
|
|
rel.os = osName;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
supported.oses[rel.os] = true;
|
|
|
|
if (!rel.arch) {
|
|
for (let arch of arches) {
|
|
let name = rel.name || rel.download;
|
|
let isArch = name.match(archMap[arch]);
|
|
if (isArch) {
|
|
rel.arch = arch;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!rel.arch) {
|
|
if ('macos' === rel.os) {
|
|
rel.arch = 'amd64';
|
|
}
|
|
}
|
|
supported.arches[rel.arch] = true;
|
|
|
|
// note: depends on rel.os
|
|
if (!rel.libc) {
|
|
let isMusl;
|
|
let isMsvc;
|
|
let isStatic;
|
|
let isGnu;
|
|
|
|
// extra blocks to prevent copy pasta errors
|
|
|
|
{
|
|
let muslRe = /(\b|_)(musl)(\b|_)/i;
|
|
isMusl = muslRe.test(rel.download) || muslRe.test(rel.name);
|
|
}
|
|
|
|
{
|
|
let msvcRe = /(\b|_)(msvc)(\b|_)/i;
|
|
isMsvc = msvcRe.test(rel.download) || msvcRe.test(rel.name);
|
|
}
|
|
|
|
{
|
|
let staticRe = /(\b|_)(static)(\b|_)/i;
|
|
isStatic = staticRe.test(rel.download) || staticRe.test(rel.name);
|
|
}
|
|
|
|
{
|
|
let gnuRe = /(\b|_)(gnu|glibc|libc)(\b|_)/i;
|
|
isGnu = gnuRe.test(rel.download) || gnuRe.test(rel.name);
|
|
}
|
|
|
|
if (isMusl) {
|
|
// we specifically tag things that need musl++ in their own releases
|
|
rel.libc = 'none';
|
|
} else if (isStatic) {
|
|
rel.libc = 'none';
|
|
} else if (isGnu) {
|
|
rel.libc = 'gnu';
|
|
if (rel.os === 'windows') {
|
|
// windows gnu is static
|
|
rel.libc = 'none';
|
|
} else if (rel.os === 'darwin') {
|
|
// if glibc is required on macos, it'll be static
|
|
rel.libc = 'none';
|
|
}
|
|
} else if (isMsvc) {
|
|
rel.libc = 'msvc';
|
|
} else {
|
|
// The default is no requirement for any particular libc
|
|
// (Go, Zig, POSIX Shell, JS, etc)
|
|
// and hopefully we never have to worry about mingw and friends
|
|
rel.libc = 'none';
|
|
}
|
|
}
|
|
supported.libcs[rel.libc] = true;
|
|
|
|
var tarExt;
|
|
if (!rel.ext) {
|
|
// pkg-v1.0.tar.gz => ['gz', 'tar', '0', 'pkg-v1']
|
|
// pkg-v1.0.tar => ['tar', '0' ,'pkg-v1']
|
|
// pkg-v1.0.zip => ['zip', '0', 'pkg-v1']
|
|
var exts = (rel.name || rel.download).split('.');
|
|
if (1 === exts.length) {
|
|
// for bare releases in the format of foo-linux-amd64
|
|
rel.ext = 'exe';
|
|
}
|
|
exts = exts.reverse().slice(0, 2);
|
|
if ('tar' === exts[1]) {
|
|
rel.ext = exts.reverse().join('.');
|
|
tarExt = 'tar';
|
|
} else if ('tgz' === exts[0]) {
|
|
rel.ext = 'tar.gz';
|
|
tarExt = 'tar';
|
|
} else {
|
|
rel.ext = exts[0];
|
|
}
|
|
if (/\-|linux|mac|os[_\-]?x|arm|amd|86|64|mip/i.test(rel.ext)) {
|
|
// for bare releases in the format of foo.linux-amd64
|
|
rel.ext = 'exe';
|
|
}
|
|
}
|
|
supported.formats[tarExt || rel.ext] = true;
|
|
|
|
if (!rel.channel) {
|
|
// basically like this: (+.-_)(beta|rc)(0-9)(+.-_)
|
|
// matches:
|
|
// - v1.0-beta
|
|
// - v1.0-beta1.1
|
|
// - v1.0-beta-11
|
|
// won't match:
|
|
// - v1.0beta
|
|
// - v1.0-beta1b
|
|
let isBetaRe =
|
|
/(\b|_)(alpha|beta|dev|developer|prev|preview|rc)(\d+)(\b|_)/;
|
|
let isBeta = isBetaRe.test(rel.name);
|
|
if (isBeta) {
|
|
rel.channel = 'beta';
|
|
} else {
|
|
rel.channel = 'stable';
|
|
}
|
|
}
|
|
|
|
if (all.download) {
|
|
rel.download = all.download.replace(/{{ download }}/, rel.download);
|
|
}
|
|
}
|
|
|
|
all.oses = Object.keys(supported.oses).filter(function (name) {
|
|
return maps.oses[name];
|
|
});
|
|
all.arches = Object.keys(supported.arches).filter(function (name) {
|
|
return maps.arches[name];
|
|
});
|
|
all.libcs = Object.keys(supported.libcs).filter(function (name) {
|
|
return maps.libcs[name];
|
|
});
|
|
all.formats = Object.keys(supported.formats).filter(function (name) {
|
|
return maps.formats[name];
|
|
});
|
|
|
|
return all;
|
|
}
|
|
|
|
module.exports = normalize;
|
|
module.exports._debug = function (all) {
|
|
all = normalize(all);
|
|
all.releases = all.releases
|
|
.filter(function (r) {
|
|
return ['windows', 'macos', 'linux'].includes(r.os) && 'amd64' === r.arch;
|
|
})
|
|
.slice(0, 10);
|
|
return all;
|
|
};
|
|
// NOT in order of priority (which would be tar, xz, zip, ...)
|
|
module.exports.formats = formats;
|
|
module.exports.arches = arches;
|
|
module.exports.libcs = libcs;
|
|
module.exports.formatsMap = maps.formats;
|