Alex Dunmow
f597fa8b52
The v2.0.5 captchaEnabled editor toggle (fe5d117) changed web/src but never rebuilt the committed web/dist. Rebuild so the shipped bundle matches source. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
426 lines
14 KiB
JavaScript
426 lines
14 KiB
JavaScript
const buildIdentifier = "[0-9A-Za-z-]+";
|
|
const build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
|
|
const numericIdentifier = "0|[1-9]\\d*";
|
|
const numericIdentifierLoose = "[0-9]+";
|
|
const nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
|
|
const preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
|
|
const preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
|
|
const preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
|
|
const preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
|
|
const xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
|
|
const xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
|
|
const hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
|
|
const mainVersionLoose = `(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`;
|
|
const loosePlain = `[v=\\s]*${mainVersionLoose}${preReleaseLoose}?${build}?`;
|
|
const gtlt = "((?:<|>)?=?)";
|
|
const comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
|
|
const loneTilde = "(?:~>?)";
|
|
const tildeTrim = `(\\s*)${loneTilde}\\s+`;
|
|
const loneCaret = "(?:\\^)";
|
|
const caretTrim = `(\\s*)${loneCaret}\\s+`;
|
|
const star = "(<|>)?=?\\s*\\*";
|
|
const caret = `^${loneCaret}${xRangePlain}$`;
|
|
const mainVersion = `(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`;
|
|
const fullPlain = `v?${mainVersion}${preRelease}?${build}?`;
|
|
const tilde = `^${loneTilde}${xRangePlain}$`;
|
|
const xRange = `^${gtlt}\\s*${xRangePlain}$`;
|
|
const comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
|
|
const gte0 = "^\\s*>=\\s*0.0.0\\s*$";
|
|
function parseRegex(source) {
|
|
return new RegExp(source);
|
|
}
|
|
function isXVersion(version) {
|
|
return !version || version.toLowerCase() === "x" || version === "*";
|
|
}
|
|
function pipe(...fns) {
|
|
return (x) => {
|
|
return fns.reduce((v, f) => f(v), x);
|
|
};
|
|
}
|
|
function extractComparator(comparatorString) {
|
|
return comparatorString.match(parseRegex(comparator));
|
|
}
|
|
function combineVersion(major, minor, patch, preRelease2) {
|
|
const mainVersion2 = `${major}.${minor}.${patch}`;
|
|
if (preRelease2) {
|
|
return `${mainVersion2}-${preRelease2}`;
|
|
}
|
|
return mainVersion2;
|
|
}
|
|
function parseHyphen(range) {
|
|
return range.replace(
|
|
parseRegex(hyphenRange),
|
|
(_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
|
|
if (isXVersion(fromMajor)) {
|
|
from = "";
|
|
} else if (isXVersion(fromMinor)) {
|
|
from = `>=${fromMajor}.0.0`;
|
|
} else if (isXVersion(fromPatch)) {
|
|
from = `>=${fromMajor}.${fromMinor}.0`;
|
|
} else {
|
|
from = `>=${from}`;
|
|
}
|
|
if (isXVersion(toMajor)) {
|
|
to = "";
|
|
} else if (isXVersion(toMinor)) {
|
|
to = `<${+toMajor + 1}.0.0-0`;
|
|
} else if (isXVersion(toPatch)) {
|
|
to = `<${toMajor}.${+toMinor + 1}.0-0`;
|
|
} else if (toPreRelease) {
|
|
to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
|
|
} else {
|
|
to = `<=${to}`;
|
|
}
|
|
return `${from} ${to}`.trim();
|
|
}
|
|
);
|
|
}
|
|
function parseComparatorTrim(range) {
|
|
return range.replace(parseRegex(comparatorTrim), "$1$2$3");
|
|
}
|
|
function parseTildeTrim(range) {
|
|
return range.replace(parseRegex(tildeTrim), "$1~");
|
|
}
|
|
function parseCaretTrim(range) {
|
|
return range.replace(parseRegex(caretTrim), "$1^");
|
|
}
|
|
function parseCarets(range) {
|
|
return range.trim().split(/\s+/).map((rangeVersion) => {
|
|
return rangeVersion.replace(
|
|
parseRegex(caret),
|
|
(_, major, minor, patch, preRelease2) => {
|
|
if (isXVersion(major)) {
|
|
return "";
|
|
} else if (isXVersion(minor)) {
|
|
return `>=${major}.0.0 <${+major + 1}.0.0-0`;
|
|
} else if (isXVersion(patch)) {
|
|
if (major === "0") {
|
|
return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
|
|
} else {
|
|
return `>=${major}.${minor}.0 <${+major + 1}.0.0-0`;
|
|
}
|
|
} else if (preRelease2) {
|
|
if (major === "0") {
|
|
if (minor === "0") {
|
|
return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${minor}.${+patch + 1}-0`;
|
|
} else {
|
|
return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
|
|
}
|
|
} else {
|
|
return `>=${major}.${minor}.${patch}-${preRelease2} <${+major + 1}.0.0-0`;
|
|
}
|
|
} else {
|
|
if (major === "0") {
|
|
if (minor === "0") {
|
|
return `>=${major}.${minor}.${patch} <${major}.${minor}.${+patch + 1}-0`;
|
|
} else {
|
|
return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
|
|
}
|
|
}
|
|
return `>=${major}.${minor}.${patch} <${+major + 1}.0.0-0`;
|
|
}
|
|
}
|
|
);
|
|
}).join(" ");
|
|
}
|
|
function parseTildes(range) {
|
|
return range.trim().split(/\s+/).map((rangeVersion) => {
|
|
return rangeVersion.replace(
|
|
parseRegex(tilde),
|
|
(_, major, minor, patch, preRelease2) => {
|
|
if (isXVersion(major)) {
|
|
return "";
|
|
} else if (isXVersion(minor)) {
|
|
return `>=${major}.0.0 <${+major + 1}.0.0-0`;
|
|
} else if (isXVersion(patch)) {
|
|
return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
|
|
} else if (preRelease2) {
|
|
return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
|
|
}
|
|
return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
|
|
}
|
|
);
|
|
}).join(" ");
|
|
}
|
|
function parseXRanges(range) {
|
|
return range.split(/\s+/).map((rangeVersion) => {
|
|
return rangeVersion.trim().replace(
|
|
parseRegex(xRange),
|
|
(ret, gtlt2, major, minor, patch, preRelease2) => {
|
|
const isXMajor = isXVersion(major);
|
|
const isXMinor = isXMajor || isXVersion(minor);
|
|
const isXPatch = isXMinor || isXVersion(patch);
|
|
if (gtlt2 === "=" && isXPatch) {
|
|
gtlt2 = "";
|
|
}
|
|
preRelease2 = "";
|
|
if (isXMajor) {
|
|
if (gtlt2 === ">" || gtlt2 === "<") {
|
|
return "<0.0.0-0";
|
|
} else {
|
|
return "*";
|
|
}
|
|
} else if (gtlt2 && isXPatch) {
|
|
if (isXMinor) {
|
|
minor = 0;
|
|
}
|
|
patch = 0;
|
|
if (gtlt2 === ">") {
|
|
gtlt2 = ">=";
|
|
if (isXMinor) {
|
|
major = +major + 1;
|
|
minor = 0;
|
|
patch = 0;
|
|
} else {
|
|
minor = +minor + 1;
|
|
patch = 0;
|
|
}
|
|
} else if (gtlt2 === "<=") {
|
|
gtlt2 = "<";
|
|
if (isXMinor) {
|
|
major = +major + 1;
|
|
} else {
|
|
minor = +minor + 1;
|
|
}
|
|
}
|
|
if (gtlt2 === "<") {
|
|
preRelease2 = "-0";
|
|
}
|
|
return `${gtlt2 + major}.${minor}.${patch}${preRelease2}`;
|
|
} else if (isXMinor) {
|
|
return `>=${major}.0.0${preRelease2} <${+major + 1}.0.0-0`;
|
|
} else if (isXPatch) {
|
|
return `>=${major}.${minor}.0${preRelease2} <${major}.${+minor + 1}.0-0`;
|
|
}
|
|
return ret;
|
|
}
|
|
);
|
|
}).join(" ");
|
|
}
|
|
function parseStar(range) {
|
|
return range.trim().replace(parseRegex(star), "");
|
|
}
|
|
function parseGTE0(comparatorString) {
|
|
return comparatorString.trim().replace(parseRegex(gte0), "");
|
|
}
|
|
function compareAtom(rangeAtom, versionAtom) {
|
|
rangeAtom = +rangeAtom || rangeAtom;
|
|
versionAtom = +versionAtom || versionAtom;
|
|
if (rangeAtom > versionAtom) {
|
|
return 1;
|
|
}
|
|
if (rangeAtom === versionAtom) {
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
function comparePreRelease(rangeAtom, versionAtom) {
|
|
const { preRelease: rangePreRelease } = rangeAtom;
|
|
const { preRelease: versionPreRelease } = versionAtom;
|
|
if (rangePreRelease === void 0 && !!versionPreRelease) {
|
|
return 1;
|
|
}
|
|
if (!!rangePreRelease && versionPreRelease === void 0) {
|
|
return -1;
|
|
}
|
|
if (rangePreRelease === void 0 && versionPreRelease === void 0) {
|
|
return 0;
|
|
}
|
|
for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
|
|
const rangeElement = rangePreRelease[i];
|
|
const versionElement = versionPreRelease[i];
|
|
if (rangeElement === versionElement) {
|
|
continue;
|
|
}
|
|
if (rangeElement === void 0 && versionElement === void 0) {
|
|
return 0;
|
|
}
|
|
if (!rangeElement) {
|
|
return 1;
|
|
}
|
|
if (!versionElement) {
|
|
return -1;
|
|
}
|
|
return compareAtom(rangeElement, versionElement);
|
|
}
|
|
return 0;
|
|
}
|
|
function compareVersion(rangeAtom, versionAtom) {
|
|
return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
|
|
}
|
|
function eq(rangeAtom, versionAtom) {
|
|
return rangeAtom.version === versionAtom.version;
|
|
}
|
|
function compare(rangeAtom, versionAtom) {
|
|
switch (rangeAtom.operator) {
|
|
case "":
|
|
case "=":
|
|
return eq(rangeAtom, versionAtom);
|
|
case ">":
|
|
return compareVersion(rangeAtom, versionAtom) < 0;
|
|
case ">=":
|
|
return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
|
|
case "<":
|
|
return compareVersion(rangeAtom, versionAtom) > 0;
|
|
case "<=":
|
|
return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
|
|
case void 0: {
|
|
return true;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function parseComparatorString(range) {
|
|
return pipe(
|
|
parseCarets,
|
|
parseTildes,
|
|
parseXRanges,
|
|
parseStar
|
|
)(range);
|
|
}
|
|
function parseRange(range) {
|
|
return pipe(
|
|
parseHyphen,
|
|
parseComparatorTrim,
|
|
parseTildeTrim,
|
|
parseCaretTrim
|
|
)(range.trim()).split(/\s+/).join(" ");
|
|
}
|
|
function satisfy(version, range) {
|
|
if (!version) {
|
|
return false;
|
|
}
|
|
const parsedRange = parseRange(range);
|
|
const parsedComparator = parsedRange.split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ");
|
|
const comparators = parsedComparator.split(/\s+/).map((comparator2) => parseGTE0(comparator2));
|
|
const extractedVersion = extractComparator(version);
|
|
if (!extractedVersion) {
|
|
return false;
|
|
}
|
|
const [
|
|
,
|
|
versionOperator,
|
|
,
|
|
versionMajor,
|
|
versionMinor,
|
|
versionPatch,
|
|
versionPreRelease
|
|
] = extractedVersion;
|
|
const versionAtom = {
|
|
version: combineVersion(
|
|
versionMajor,
|
|
versionMinor,
|
|
versionPatch,
|
|
versionPreRelease
|
|
),
|
|
major: versionMajor,
|
|
minor: versionMinor,
|
|
patch: versionPatch,
|
|
preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split(".")
|
|
};
|
|
for (const comparator2 of comparators) {
|
|
const extractedComparator = extractComparator(comparator2);
|
|
if (!extractedComparator) {
|
|
return false;
|
|
}
|
|
const [
|
|
,
|
|
rangeOperator,
|
|
,
|
|
rangeMajor,
|
|
rangeMinor,
|
|
rangePatch,
|
|
rangePreRelease
|
|
] = extractedComparator;
|
|
const rangeAtom = {
|
|
operator: rangeOperator,
|
|
version: combineVersion(
|
|
rangeMajor,
|
|
rangeMinor,
|
|
rangePatch,
|
|
rangePreRelease
|
|
),
|
|
major: rangeMajor,
|
|
minor: rangeMinor,
|
|
patch: rangePatch,
|
|
preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split(".")
|
|
};
|
|
if (!compare(rangeAtom, versionAtom)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const currentImports = {};
|
|
|
|
// eslint-disable-next-line no-undef
|
|
const moduleMap = {'react':{get:()=>()=>__federation_import(new URL('__federation_shared_react-DoKb58Ht.js', import.meta.url).href),import:true},'react-dom':{get:()=>()=>__federation_import(new URL('__federation_shared_react-dom-DU2-P0kt.js', import.meta.url).href),import:true},'@block-ninja/ui':{get:()=>()=>__federation_import(new URL('__federation_shared_@block-ninja/ui-C3CAr7wz.js', import.meta.url).href),import:true}};
|
|
const moduleCache = Object.create(null);
|
|
async function importShared(name, shareScope = 'default') {
|
|
return moduleCache[name]
|
|
? new Promise((r) => r(moduleCache[name]))
|
|
: (await getSharedFromRuntime(name, shareScope)) || getSharedFromLocal(name)
|
|
}
|
|
// eslint-disable-next-line
|
|
async function __federation_import(name) {
|
|
currentImports[name] ??= import(name);
|
|
return currentImports[name]
|
|
}
|
|
async function getSharedFromRuntime(name, shareScope) {
|
|
let module = null;
|
|
if (globalThis?.__federation_shared__?.[shareScope]?.[name]) {
|
|
const versionObj = globalThis.__federation_shared__[shareScope][name];
|
|
const requiredVersion = moduleMap[name]?.requiredVersion;
|
|
const hasRequiredVersion = !!requiredVersion;
|
|
if (hasRequiredVersion) {
|
|
const versionKey = Object.keys(versionObj).find((version) =>
|
|
satisfy(version, requiredVersion)
|
|
);
|
|
if (versionKey) {
|
|
const versionValue = versionObj[versionKey];
|
|
module = await (await versionValue.get())();
|
|
} else {
|
|
console.log(
|
|
`provider support ${name}(${versionKey}) is not satisfied requiredVersion(\${moduleMap[name].requiredVersion})`
|
|
);
|
|
}
|
|
} else {
|
|
const versionKey = Object.keys(versionObj)[0];
|
|
const versionValue = versionObj[versionKey];
|
|
module = await (await versionValue.get())();
|
|
}
|
|
}
|
|
if (module) {
|
|
return flattenModule(module, name)
|
|
}
|
|
}
|
|
async function getSharedFromLocal(name) {
|
|
if (moduleMap[name]?.import) {
|
|
let module = await (await moduleMap[name].get())();
|
|
return flattenModule(module, name)
|
|
} else {
|
|
console.error(
|
|
`consumer config import=false,so cant use callback shared module`
|
|
);
|
|
}
|
|
}
|
|
function flattenModule(module, name) {
|
|
// use a shared module which export default a function will getting error 'TypeError: xxx is not a function'
|
|
if (typeof module.default === 'function') {
|
|
Object.keys(module).forEach((key) => {
|
|
if (key !== 'default') {
|
|
module.default[key] = module[key];
|
|
}
|
|
});
|
|
moduleCache[name] = module.default;
|
|
return module.default
|
|
}
|
|
if (module.default) module = Object.assign({}, module.default, module);
|
|
moduleCache[name] = module;
|
|
return module
|
|
}
|
|
|
|
export { importShared, getSharedFromLocal as importSharedLocal, getSharedFromRuntime as importSharedRuntime };
|