brianhansonxyz/rspade_system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Framework updates

Browse Source 
🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
root
2026-03-04 23:20:19 +00:00
parent a89daf3d43
commit 3ed8517b2a
891 changed files with 11126 additions and 9600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js generated vendored
View File

@@ -18,12 +18,16 @@ const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
const HarmonyExports = require("./HarmonyExports");
const { ExportPresenceModes } = require("./HarmonyImportDependency");
const {
ExportPresenceModes,
getNonOptionalPart
} = require("./HarmonyImportDependency");
const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
/** @typedef {import("estree").Expression} Expression */
/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
/** @typedef {import("estree").Identifier} Identifier */
/** @typedef {import("estree").MemberExpression} MemberExpression */
/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -63,17 +67,44 @@ const harmonySpecifierGuardTag = Symbol("harmony import guard");
const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
/** @type {(members: Members) => string} */
const getMembersKey = (members) => members.join(".");
/**
* Strip the root binding name if needed
* @param {HarmonySettings} settings settings
* @param {Ids} ids ids
* @returns {Ids} ids for presence check
* @param {JavascriptParser} parser the parser
* @param {PrivateIdentifier | Expression} left left expression
* @param {Expression} right right expression
* @returns {{ leftPart: string, members: Members, settings: HarmonySettings } | undefined} info
*/
const getIdsForPresence = (settings, ids) =>
settings.ids.length ? ids.slice(1) : ids;
const getInOperatorHarmonyImportInfo = (parser, left, right) => {
const leftPartEvaluated = parser.evaluateExpression(left);
if (leftPartEvaluated.couldHaveSideEffects()) return;
/** @type {string | undefined} */
const leftPart = leftPartEvaluated.asString();
if (!leftPart) return;
const rightPart = parser.evaluateExpression(right);
if (!rightPart.isIdentifier()) return;
const rootInfo = rightPart.rootInfo;
const root =
typeof rootInfo === "string"
? rootInfo
: rootInfo instanceof VariableInfo
? rootInfo.name
: undefined;
if (!root) return;
const settings = /** @type {HarmonySettings | undefined} */ (
parser.getTagData(root, harmonySpecifierTag)
);
if (!settings) {
return;
}
return {
leftPart,
members: /** @type {(() => Members)} */ (rightPart.getMembers)(),
settings
};
};
module.exports = class HarmonyImportDependencyParserPlugin {
/**
@@ -82,23 +113,23 @@ module.exports = class HarmonyImportDependencyParserPlugin {
constructor(options) {
this.options = options;
/** @type {ExportPresenceMode} */
this.exportPresenceMode =
options.importExportsPresence !== undefined
? ExportPresenceModes.fromUserOption(options.importExportsPresence)
: options.exportsPresence !== undefined
? ExportPresenceModes.fromUserOption(options.exportsPresence)
: options.strictExportPresence
? ExportPresenceModes.ERROR
: ExportPresenceModes.AUTO;
this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
options.importExportsPresence,
options
);
this.strictThisContextOnImports = options.strictThisContextOnImports;
}
/**
* @param {JavascriptParser} parser the parser
* @param {HarmonySettings} settings settings
* @param {Ids} ids ids
* @returns {ExportPresenceMode} exportPresenceMode
*/
getExportPresenceMode(parser, ids) {
getExportPresenceMode(parser, settings, ids) {
// Guards only apply to namespace imports
if (settings.ids.length) return this.exportPresenceMode;
const harmonySettings = /** @type {HarmonySettings=} */ (
parser.currentTagData
);
@@ -107,9 +138,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
const data = /** @type {HarmonySpecifierGuards=} */ (
parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
);
return data && data.guards && data.guards.has(getMembersKey(ids))
? ExportPresenceModes.NONE
: this.exportPresenceMode;
if (data && data.guards && data.guards.has(ids[0])) {
return ExportPresenceModes.NONE;
}
return this.exportPresenceMode;
}
/**
@@ -119,17 +153,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
apply(parser) {
const getImportPhase = createGetImportPhase(this.options.deferImport);
/**
* @param {Members} members members
* @param {MembersOptionals} membersOptionals members Optionals
* @returns {Ids} a non optional part
*/
function getNonOptionalPart(members, membersOptionals) {
let i = 0;
while (i < members.length && membersOptionals[i] === false) i++;
return i !== members.length ? members.slice(0, i) : members;
}
/**
* @param {MemberExpression} node member expression
* @param {number} count count
@@ -207,31 +230,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
);
parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
if (expression.operator !== "in") return;
const info = getInOperatorHarmonyImportInfo(
parser,
expression.left,
expression.right
);
if (!info) return;
const leftPartEvaluated = parser.evaluateExpression(expression.left);
if (leftPartEvaluated.couldHaveSideEffects()) return;
/** @type {string | undefined} */
const leftPart = leftPartEvaluated.asString();
if (!leftPart) return;
const rightPart = parser.evaluateExpression(expression.right);
if (!rightPart.isIdentifier()) return;
const rootInfo = rightPart.rootInfo;
if (
typeof rootInfo === "string" ||
!rootInfo ||
!rootInfo.tagInfo ||
rootInfo.tagInfo.tag !== harmonySpecifierTag
) {
return;
}
const settings =
/** @type {HarmonySettings} */
(rootInfo.tagInfo.data);
const members =
/** @type {(() => Members)} */
(rightPart.getMembers)();
const { leftPart, members, settings } = info;
const dep = new HarmonyEvaluatedImportSpecifierDependency(
settings.source,
settings.sourceOrder,
@@ -276,10 +282,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
settings.name,
/** @type {Range} */
(expr.range),
this.getExportPresenceMode(
parser,
getIdsForPresence(settings, settings.ids)
),
this.exportPresenceMode,
settings.phase,
settings.attributes,
[]
@@ -329,10 +332,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
settings.name,
/** @type {Range} */
(expr.range),
this.getExportPresenceMode(
parser,
getIdsForPresence(settings, ids)
),
this.getExportPresenceMode(parser, settings, ids),
settings.phase,
settings.attributes,
ranges
@@ -382,10 +382,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
ids,
settings.name,
/** @type {Range} */ (expr.range),
this.getExportPresenceMode(
parser,
getIdsForPresence(settings, ids)
),
this.getExportPresenceMode(parser, settings, ids),
settings.phase,
settings.attributes,
ranges
@@ -453,160 +450,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
}
});
/**
* @param {Expression} expression expression
* @returns {{ root: string, members: Members } | undefined} info
*/
const getHarmonyImportInfo = (expression) => {
const nameInfo = parser.getNameForExpression(expression);
if (!nameInfo) return;
const rootInfo = nameInfo.rootInfo;
const root =
typeof rootInfo === "string"
? rootInfo
: rootInfo instanceof VariableInfo
? rootInfo.name
: undefined;
if (!root) return;
if (!parser.getTagData(root, harmonySpecifierTag)) return;
return { root, members: nameInfo.getMembers() };
};
/**
* @param {Guards} guards guards
* @param {string} root root name
* @param {Members} members members
*/
const addToGuards = (guards, root, members) => {
const membersKey = getMembersKey(members);
const guardedMembers = guards.get(root);
if (guardedMembers) {
guardedMembers.add(membersKey);
return;
}
guards.set(
root,
// Adding `foo.bar` implies guarding `foo` as well
membersKey === "" ? new Set([""]) : new Set([membersKey, ""])
);
};
/**
* @param {Expression} expression expression
* @param {Guards} guards guards
* @param {boolean} needTruthy need to be truthy
*/
const collect = (expression, guards, needTruthy) => {
// !foo
if (
expression.type === "UnaryExpression" &&
expression.operator === "!"
) {
collect(expression.argument, guards, !needTruthy);
return;
} else if (expression.type === "LogicalExpression" && needTruthy) {
// foo && bar
if (expression.operator === "&&") {
collect(expression.left, guards, true);
collect(expression.right, guards, true);
}
// falsy || foo
else if (expression.operator === "||") {
const leftEvaluation = parser.evaluateExpression(expression.left);
const leftBool = leftEvaluation.asBool();
if (leftBool === false) {
collect(expression.right, guards, true);
}
}
// nullish ?? foo
else if (expression.operator === "??") {
const leftEvaluation = parser.evaluateExpression(expression.left);
const leftNullish = leftEvaluation.asNullish();
if (leftNullish === true) {
collect(expression.right, guards, true);
}
}
return;
}
if (!needTruthy) return;
/**
* @param {Expression} targetExpression expression
* @returns {boolean} is added
*/
const addGuardForExpression = (targetExpression) => {
const info = getHarmonyImportInfo(targetExpression);
if (!info) return false;
addToGuards(guards, info.root, info.members);
return true;
};
/**
* @param {Expression} left left expression
* @param {Expression} right right expression
* @param {(evaluation: ReturnType<JavascriptParser["evaluateExpression"]>) => boolean} matcher matcher
* @returns {boolean} is added
*/
const addGuardForNullishCompare = (left, right, matcher) => {
const leftEval = parser.evaluateExpression(left);
if (leftEval && matcher(leftEval)) {
return addGuardForExpression(right);
}
const rightEval = parser.evaluateExpression(right);
if (rightEval && matcher(rightEval)) {
return addGuardForExpression(/** @type {Expression} */ (left));
}
return false;
};
if (expression.type === "BinaryExpression") {
// "bar" in foo
if (expression.operator === "in") {
const leftEvaluation = parser.evaluateExpression(expression.left);
if (leftEvaluation.couldHaveSideEffects()) return;
const propertyName = leftEvaluation.asString();
if (!propertyName) return;
parser.evaluateExpression(expression.right);
const info = getHarmonyImportInfo(expression.right);
if (!info) return;
if (info.members.length) {
for (const member of info.members) {
addToGuards(guards, info.root, [member]);
}
}
addToGuards(guards, info.root, [...info.members, propertyName]);
return;
}
// foo !== undefined
else if (
expression.operator === "!==" &&
addGuardForNullishCompare(
/** @type {Expression} */ (expression.left),
expression.right,
(evaluation) => evaluation.isUndefined()
)
) {
return;
}
// foo != undefined
// foo != null
else if (
expression.operator === "!=" &&
addGuardForNullishCompare(
/** @type {Expression} */ (expression.left),
expression.right,
(evaluation) => Boolean(evaluation.asNullish())
)
) {
return;
}
}
addGuardForExpression(expression);
};
/**
* @param {Guards} guards guards
* @param {() => void} walk walk callback
@@ -657,7 +500,68 @@ module.exports = class HarmonyImportDependencyParserPlugin {
if (parser.scope.isAsmJs) return;
/** @type {Guards} */
const guards = new Map();
collect(expression, guards, true);
/**
* @param {Expression} expression expression
* @param {boolean} needTruthy need to be truthy
*/
const collect = (expression, needTruthy) => {
if (
expression.type === "UnaryExpression" &&
expression.operator === "!"
) {
collect(expression.argument, !needTruthy);
return;
} else if (expression.type === "LogicalExpression" && needTruthy) {
if (expression.operator === "&&") {
collect(expression.left, true);
collect(expression.right, true);
} else if (expression.operator === "||") {
const leftEvaluation = parser.evaluateExpression(expression.left);
const leftBool = leftEvaluation.asBool();
if (leftBool === false) {
collect(expression.right, true);
}
} else if (expression.operator === "??") {
const leftEvaluation = parser.evaluateExpression(expression.left);
const leftNullish = leftEvaluation.asNullish();
if (leftNullish === true) {
collect(expression.right, true);
}
}
return;
}
if (!needTruthy) return;
// Direct `"x" in ns` guards
if (
expression.type === "BinaryExpression" &&
expression.operator === "in"
) {
if (expression.right.type !== "Identifier") {
return;
}
const info = getInOperatorHarmonyImportInfo(
parser,
expression.left,
expression.right
);
if (!info) return;
const { settings, leftPart, members } = info;
// Only direct namespace guards
if (members.length > 0) return;
const guarded = guards.get(settings.name);
if (guarded) {
guarded.add(leftPart);
return;
}
guards.set(settings.name, new Set([leftPart]));
}
};
collect(expression, true);
if (guards.size === 0) return;
return (walk) => {