126 lines
3.2 KiB
JavaScript
126 lines
3.2 KiB
JavaScript
// @flow
|
|
|
|
import semver from "semver";
|
|
import unreleasedLabels from "../data/unreleased-labels";
|
|
import { semverMin } from "./targets-parser";
|
|
import type { Targets } from "./types";
|
|
|
|
// Convert version to a semver value.
|
|
// 2.5 -> 2.5.0; 1 -> 1.0.0;
|
|
export const semverify = (version: string | number): string => {
|
|
if (typeof version === "string" && semver.valid(version)) {
|
|
return version;
|
|
}
|
|
|
|
const split = version.toString().split(".");
|
|
|
|
while (split.length < 3) {
|
|
split.push("0");
|
|
}
|
|
|
|
return split.join(".");
|
|
};
|
|
|
|
export const prettifyVersion = (version: string): string => {
|
|
if (typeof version !== "string") {
|
|
return version;
|
|
}
|
|
|
|
const parts = [semver.major(version)];
|
|
const minor = semver.minor(version);
|
|
const patch = semver.patch(version);
|
|
|
|
if (minor || patch) {
|
|
parts.push(minor);
|
|
}
|
|
|
|
if (patch) {
|
|
parts.push(patch);
|
|
}
|
|
|
|
return parts.join(".");
|
|
};
|
|
|
|
export const prettifyTargets = (targets: Targets): Object => {
|
|
return Object.keys(targets).reduce((results, target) => {
|
|
let value = targets[target];
|
|
|
|
const unreleasedLabel = unreleasedLabels[target];
|
|
if (typeof value === "string" && unreleasedLabel !== value) {
|
|
value = prettifyVersion(value);
|
|
}
|
|
|
|
results[target] = value;
|
|
return results;
|
|
}, {});
|
|
};
|
|
|
|
export const isUnreleasedVersion = (version: string, env: string): boolean => {
|
|
const unreleasedLabel = unreleasedLabels[env];
|
|
return (
|
|
!!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase()
|
|
);
|
|
};
|
|
|
|
export const getLowestUnreleased = (
|
|
a: string,
|
|
b: string,
|
|
env: string,
|
|
): string => {
|
|
const unreleasedLabel = unreleasedLabels[env];
|
|
const hasUnreleased = [a, b].some(item => item === unreleasedLabel);
|
|
if (hasUnreleased) {
|
|
return a === hasUnreleased ? b : a || b;
|
|
}
|
|
return semverMin(a, b);
|
|
};
|
|
|
|
export const filterStageFromList = (list: any, stageList: any) => {
|
|
return Object.keys(list).reduce((result, item) => {
|
|
if (!stageList[item]) {
|
|
result[item] = list[item];
|
|
}
|
|
|
|
return result;
|
|
}, {});
|
|
};
|
|
|
|
export const isPolyfillSource = (source: string): boolean =>
|
|
source === "@babel/polyfill";
|
|
|
|
export const isRequire = (t: Object, path: Object): boolean =>
|
|
t.isExpressionStatement(path.node) &&
|
|
t.isCallExpression(path.node.expression) &&
|
|
t.isIdentifier(path.node.expression.callee) &&
|
|
path.node.expression.callee.name === "require" &&
|
|
path.node.expression.arguments.length === 1 &&
|
|
t.isStringLiteral(path.node.expression.arguments[0]) &&
|
|
isPolyfillSource(path.node.expression.arguments[0].value);
|
|
|
|
const modulePathMap = {
|
|
"regenerator-runtime": "regenerator-runtime/runtime",
|
|
};
|
|
|
|
export const getModulePath = (mod: string) =>
|
|
modulePathMap[mod] || `core-js/modules/${mod}`;
|
|
|
|
export type RequireType = "require" | "import";
|
|
|
|
export const createImport = (
|
|
t: Object,
|
|
polyfill: string,
|
|
requireType?: RequireType = "import",
|
|
): Object => {
|
|
const modulePath = getModulePath(polyfill);
|
|
|
|
if (requireType === "import") {
|
|
const declar = t.importDeclaration([], t.stringLiteral(modulePath));
|
|
declar._blockHoist = 3;
|
|
return declar;
|
|
}
|
|
|
|
return t.expressionStatement(
|
|
t.callExpression(t.identifier("require"), [t.stringLiteral(modulePath)]),
|
|
);
|
|
};
|