From fc87c009806dcc98867f6b58efe29b042aa01dee Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Mon, 18 May 2026 23:10:59 +0800 Subject: node: update --- .../webpack/lib/rules/BasicEffectRulePlugin.js | 45 --- .../webpack/lib/rules/BasicMatcherRulePlugin.js | 54 --- .../webpack/lib/rules/ObjectMatcherRulePlugin.js | 64 ---- node_modules/webpack/lib/rules/RuleSetCompiler.js | 400 --------------------- .../webpack/lib/rules/UseEffectRulePlugin.js | 200 ----------- 5 files changed, 763 deletions(-) delete mode 100644 node_modules/webpack/lib/rules/BasicEffectRulePlugin.js delete mode 100644 node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js delete mode 100644 node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js delete mode 100644 node_modules/webpack/lib/rules/RuleSetCompiler.js delete mode 100644 node_modules/webpack/lib/rules/UseEffectRulePlugin.js (limited to 'node_modules/webpack/lib/rules') diff --git a/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js b/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js deleted file mode 100644 index 935716ba..00000000 --- a/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js +++ /dev/null @@ -1,45 +0,0 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ - -"use strict"; - -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ -/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */ - -class BasicEffectRulePlugin { - /** - * @param {string} ruleProperty the rule property - * @param {string=} effectType the effect type - */ - constructor(ruleProperty, effectType) { - this.ruleProperty = ruleProperty; - this.effectType = effectType || ruleProperty; - } - - /** - * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler - * @returns {void} - */ - apply(ruleSetCompiler) { - ruleSetCompiler.hooks.rule.tap( - "BasicEffectRulePlugin", - (path, rule, unhandledProperties, result, references) => { - if (unhandledProperties.has(this.ruleProperty)) { - unhandledProperties.delete(this.ruleProperty); - - const value = - rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)]; - - result.effects.push({ - type: this.effectType, - value - }); - } - } - ); - } -} - -module.exports = BasicEffectRulePlugin; diff --git a/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js b/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js deleted file mode 100644 index 47ac214f..00000000 --- a/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js +++ /dev/null @@ -1,54 +0,0 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ - -"use strict"; - -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ -/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */ -/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */ - -class BasicMatcherRulePlugin { - /** - * @param {string} ruleProperty the rule property - * @param {string=} dataProperty the data property - * @param {boolean=} invert if true, inverts the condition - */ - constructor(ruleProperty, dataProperty, invert) { - this.ruleProperty = ruleProperty; - this.dataProperty = dataProperty || ruleProperty; - this.invert = invert || false; - } - - /** - * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler - * @returns {void} - */ - apply(ruleSetCompiler) { - ruleSetCompiler.hooks.rule.tap( - "BasicMatcherRulePlugin", - (path, rule, unhandledProperties, result) => { - if (unhandledProperties.has(this.ruleProperty)) { - unhandledProperties.delete(this.ruleProperty); - const value = - rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)]; - const condition = ruleSetCompiler.compileCondition( - `${path}.${this.ruleProperty}`, - value - ); - const fn = condition.fn; - result.conditions.push({ - property: this.dataProperty, - matchWhenEmpty: this.invert - ? !condition.matchWhenEmpty - : condition.matchWhenEmpty, - fn: this.invert ? v => !fn(v) : fn - }); - } - } - ); - } -} - -module.exports = BasicMatcherRulePlugin; diff --git a/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js b/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js deleted file mode 100644 index 984e86f8..00000000 --- a/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js +++ /dev/null @@ -1,64 +0,0 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ - -"use strict"; - -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ -/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */ -/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */ -/** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */ - -class ObjectMatcherRulePlugin { - /** - * @param {string} ruleProperty the rule property - * @param {string=} dataProperty the data property - * @param {RuleConditionFunction=} additionalConditionFunction need to check - */ - constructor(ruleProperty, dataProperty, additionalConditionFunction) { - this.ruleProperty = ruleProperty; - this.dataProperty = dataProperty || ruleProperty; - this.additionalConditionFunction = additionalConditionFunction; - } - - /** - * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler - * @returns {void} - */ - apply(ruleSetCompiler) { - const { ruleProperty, dataProperty } = this; - ruleSetCompiler.hooks.rule.tap( - "ObjectMatcherRulePlugin", - (path, rule, unhandledProperties, result) => { - if (unhandledProperties.has(ruleProperty)) { - unhandledProperties.delete(ruleProperty); - const value = - /** @type {Record} */ - (rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]); - for (const property of Object.keys(value)) { - const nestedDataProperties = property.split("."); - const condition = ruleSetCompiler.compileCondition( - `${path}.${ruleProperty}.${property}`, - value[property] - ); - if (this.additionalConditionFunction) { - result.conditions.push({ - property: [dataProperty], - matchWhenEmpty: condition.matchWhenEmpty, - fn: this.additionalConditionFunction - }); - } - result.conditions.push({ - property: [dataProperty, ...nestedDataProperties], - matchWhenEmpty: condition.matchWhenEmpty, - fn: condition.fn - }); - } - } - } - ); - } -} - -module.exports = ObjectMatcherRulePlugin; diff --git a/node_modules/webpack/lib/rules/RuleSetCompiler.js b/node_modules/webpack/lib/rules/RuleSetCompiler.js deleted file mode 100644 index 7674dd72..00000000 --- a/node_modules/webpack/lib/rules/RuleSetCompiler.js +++ /dev/null @@ -1,400 +0,0 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ - -"use strict"; - -const { SyncHook } = require("tapable"); - -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */ - -/** @typedef {function(string): boolean} RuleConditionFunction */ - -/** - * @typedef {object} RuleCondition - * @property {string | string[]} property - * @property {boolean} matchWhenEmpty - * @property {RuleConditionFunction} fn - */ - -/** - * @typedef {object} Condition - * @property {boolean} matchWhenEmpty - * @property {RuleConditionFunction} fn - */ - -/** - * @typedef {Record} EffectData - */ - -/** - * @typedef {object} CompiledRule - * @property {RuleCondition[]} conditions - * @property {(Effect|function(EffectData): Effect[])[]} effects - * @property {CompiledRule[]=} rules - * @property {CompiledRule[]=} oneOf - */ - -/** - * @typedef {object} Effect - * @property {string} type - * @property {any} value - */ - -/** - * @typedef {object} RuleSet - * @property {Map} references map of references in the rule set (may grow over time) - * @property {function(EffectData): Effect[]} exec execute the rule set - */ - -/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */ - -class RuleSetCompiler { - /** - * @param {RuleSetPlugin[]} plugins plugins - */ - constructor(plugins) { - this.hooks = Object.freeze({ - /** @type {SyncHook<[string, RuleSetRule, Set, CompiledRule, Map]>} */ - rule: new SyncHook([ - "path", - "rule", - "unhandledProperties", - "compiledRule", - "references" - ]) - }); - if (plugins) { - for (const plugin of plugins) { - plugin.apply(this); - } - } - } - - /** - * @param {TODO[]} ruleSet raw user provided rules - * @returns {RuleSet} compiled RuleSet - */ - compile(ruleSet) { - const refs = new Map(); - const rules = this.compileRules("ruleSet", ruleSet, refs); - - /** - * @param {EffectData} data data passed in - * @param {CompiledRule} rule the compiled rule - * @param {Effect[]} effects an array where effects are pushed to - * @returns {boolean} true, if the rule has matched - */ - const execRule = (data, rule, effects) => { - for (const condition of rule.conditions) { - const p = condition.property; - if (Array.isArray(p)) { - /** @type {EffectData | string | undefined} */ - let current = data; - for (const subProperty of p) { - if ( - current && - typeof current === "object" && - Object.prototype.hasOwnProperty.call(current, subProperty) - ) { - current = current[subProperty]; - } else { - current = undefined; - break; - } - } - if (current !== undefined) { - if (!condition.fn(/** @type {string} */ (current))) return false; - continue; - } - } else if (p in data) { - const value = data[p]; - if (value !== undefined) { - if (!condition.fn(value)) return false; - continue; - } - } - if (!condition.matchWhenEmpty) { - return false; - } - } - for (const effect of rule.effects) { - if (typeof effect === "function") { - const returnedEffects = effect(data); - for (const effect of returnedEffects) { - effects.push(effect); - } - } else { - effects.push(effect); - } - } - if (rule.rules) { - for (const childRule of rule.rules) { - execRule(data, childRule, effects); - } - } - if (rule.oneOf) { - for (const childRule of rule.oneOf) { - if (execRule(data, childRule, effects)) { - break; - } - } - } - return true; - }; - - return { - references: refs, - exec: data => { - /** @type {Effect[]} */ - const effects = []; - for (const rule of rules) { - execRule(data, rule, effects); - } - return effects; - } - }; - } - - /** - * @param {string} path current path - * @param {RuleSetRules} rules the raw rules provided by user - * @param {Map} refs references - * @returns {CompiledRule[]} rules - */ - compileRules(path, rules, refs) { - return rules - .filter(Boolean) - .map((rule, i) => - this.compileRule( - `${path}[${i}]`, - /** @type {RuleSetRule} */ (rule), - refs - ) - ); - } - - /** - * @param {string} path current path - * @param {RuleSetRule} rule the raw rule provided by user - * @param {Map} refs references - * @returns {CompiledRule} normalized and compiled rule for processing - */ - compileRule(path, rule, refs) { - const unhandledProperties = new Set( - Object.keys(rule).filter( - key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined - ) - ); - - /** @type {CompiledRule} */ - const compiledRule = { - conditions: [], - effects: [], - rules: undefined, - oneOf: undefined - }; - - this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs); - - if (unhandledProperties.has("rules")) { - unhandledProperties.delete("rules"); - const rules = rule.rules; - if (!Array.isArray(rules)) - throw this.error(path, rules, "Rule.rules must be an array of rules"); - compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs); - } - - if (unhandledProperties.has("oneOf")) { - unhandledProperties.delete("oneOf"); - const oneOf = rule.oneOf; - if (!Array.isArray(oneOf)) - throw this.error(path, oneOf, "Rule.oneOf must be an array of rules"); - compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs); - } - - if (unhandledProperties.size > 0) { - throw this.error( - path, - rule, - `Properties ${Array.from(unhandledProperties).join(", ")} are unknown` - ); - } - - return compiledRule; - } - - /** - * @param {string} path current path - * @param {any} condition user provided condition value - * @returns {Condition} compiled condition - */ - compileCondition(path, condition) { - if (condition === "") { - return { - matchWhenEmpty: true, - fn: str => str === "" - }; - } - if (!condition) { - throw this.error( - path, - condition, - "Expected condition but got falsy value" - ); - } - if (typeof condition === "string") { - return { - matchWhenEmpty: condition.length === 0, - fn: str => typeof str === "string" && str.startsWith(condition) - }; - } - if (typeof condition === "function") { - try { - return { - matchWhenEmpty: condition(""), - fn: condition - }; - } catch (_err) { - throw this.error( - path, - condition, - "Evaluation of condition function threw error" - ); - } - } - if (condition instanceof RegExp) { - return { - matchWhenEmpty: condition.test(""), - fn: v => typeof v === "string" && condition.test(v) - }; - } - if (Array.isArray(condition)) { - const items = condition.map((c, i) => - this.compileCondition(`${path}[${i}]`, c) - ); - return this.combineConditionsOr(items); - } - - if (typeof condition !== "object") { - throw this.error( - path, - condition, - `Unexpected ${typeof condition} when condition was expected` - ); - } - - const conditions = []; - for (const key of Object.keys(condition)) { - const value = condition[key]; - switch (key) { - case "or": - if (value) { - if (!Array.isArray(value)) { - throw this.error( - `${path}.or`, - condition.or, - "Expected array of conditions" - ); - } - conditions.push(this.compileCondition(`${path}.or`, value)); - } - break; - case "and": - if (value) { - if (!Array.isArray(value)) { - throw this.error( - `${path}.and`, - condition.and, - "Expected array of conditions" - ); - } - let i = 0; - for (const item of value) { - conditions.push(this.compileCondition(`${path}.and[${i}]`, item)); - i++; - } - } - break; - case "not": - if (value) { - const matcher = this.compileCondition(`${path}.not`, value); - const fn = matcher.fn; - conditions.push({ - matchWhenEmpty: !matcher.matchWhenEmpty, - fn: /** @type {RuleConditionFunction} */ (v => !fn(v)) - }); - } - break; - default: - throw this.error( - `${path}.${key}`, - condition[key], - `Unexpected property ${key} in condition` - ); - } - } - if (conditions.length === 0) { - throw this.error( - path, - condition, - "Expected condition, but got empty thing" - ); - } - return this.combineConditionsAnd(conditions); - } - - /** - * @param {Condition[]} conditions some conditions - * @returns {Condition} merged condition - */ - combineConditionsOr(conditions) { - if (conditions.length === 0) { - return { - matchWhenEmpty: false, - fn: () => false - }; - } else if (conditions.length === 1) { - return conditions[0]; - } - return { - matchWhenEmpty: conditions.some(c => c.matchWhenEmpty), - fn: v => conditions.some(c => c.fn(v)) - }; - } - - /** - * @param {Condition[]} conditions some conditions - * @returns {Condition} merged condition - */ - combineConditionsAnd(conditions) { - if (conditions.length === 0) { - return { - matchWhenEmpty: false, - fn: () => false - }; - } else if (conditions.length === 1) { - return conditions[0]; - } - return { - matchWhenEmpty: conditions.every(c => c.matchWhenEmpty), - fn: v => conditions.every(c => c.fn(v)) - }; - } - - /** - * @param {string} path current path - * @param {any} value value at the error location - * @param {string} message message explaining the problem - * @returns {Error} an error object - */ - error(path, value, message) { - return new Error( - `Compiling RuleSet failed: ${message} (at ${path}: ${value})` - ); - } -} - -module.exports = RuleSetCompiler; diff --git a/node_modules/webpack/lib/rules/UseEffectRulePlugin.js b/node_modules/webpack/lib/rules/UseEffectRulePlugin.js deleted file mode 100644 index 56f2423d..00000000 --- a/node_modules/webpack/lib/rules/UseEffectRulePlugin.js +++ /dev/null @@ -1,200 +0,0 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ - -"use strict"; - -const util = require("util"); - -/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */ -/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */ -/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */ -/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */ -/** @typedef {import("./RuleSetCompiler").Effect} Effect */ - -class UseEffectRulePlugin { - /** - * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler - * @returns {void} - */ - apply(ruleSetCompiler) { - ruleSetCompiler.hooks.rule.tap( - "UseEffectRulePlugin", - (path, rule, unhandledProperties, result, references) => { - /** - * @param {keyof RuleSetRule} property property - * @param {string} correctProperty correct property - */ - const conflictWith = (property, correctProperty) => { - if (unhandledProperties.has(property)) { - throw ruleSetCompiler.error( - `${path}.${property}`, - rule[property], - `A Rule must not have a '${property}' property when it has a '${correctProperty}' property` - ); - } - }; - - if (unhandledProperties.has("use")) { - unhandledProperties.delete("use"); - unhandledProperties.delete("enforce"); - - conflictWith("loader", "use"); - conflictWith("options", "use"); - - const use = rule.use; - const enforce = rule.enforce; - - const type = enforce ? `use-${enforce}` : "use"; - - /** - * @param {string} path options path - * @param {string} defaultIdent default ident when none is provided - * @param {object} item user provided use value - * @returns {Effect|function(any): Effect[]} effect - */ - const useToEffect = (path, defaultIdent, item) => { - if (typeof item === "function") { - return data => useToEffectsWithoutIdent(path, item(data)); - } - return useToEffectRaw(path, defaultIdent, item); - }; - - /** - * @param {string} path options path - * @param {string} defaultIdent default ident when none is provided - * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value - * @returns {Effect} effect - */ - const useToEffectRaw = (path, defaultIdent, item) => { - if (typeof item === "string") { - return { - type, - value: { - loader: item, - options: undefined, - ident: undefined - } - }; - } - const loader = item.loader; - const options = item.options; - let ident = item.ident; - if (options && typeof options === "object") { - if (!ident) ident = defaultIdent; - references.set(ident, options); - } - if (typeof options === "string") { - util.deprecate( - () => {}, - `Using a string as loader options is deprecated (${path}.options)`, - "DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING" - )(); - } - return { - type: enforce ? `use-${enforce}` : "use", - value: { - loader, - options, - ident - } - }; - }; - - /** - * @param {string} path options path - * @param {any} items user provided use value - * @returns {Effect[]} effects - */ - const useToEffectsWithoutIdent = (path, items) => { - if (Array.isArray(items)) { - return items - .filter(Boolean) - .map((item, idx) => - useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item) - ); - } - return [useToEffectRaw(path, "[[missing ident]]", items)]; - }; - - /** - * @param {string} path current path - * @param {any} items user provided use value - * @returns {(Effect|function(any): Effect[])[]} effects - */ - const useToEffects = (path, items) => { - if (Array.isArray(items)) { - return items.filter(Boolean).map((item, idx) => { - const subPath = `${path}[${idx}]`; - return useToEffect(subPath, subPath, item); - }); - } - return [useToEffect(path, path, items)]; - }; - - if (typeof use === "function") { - result.effects.push(data => - useToEffectsWithoutIdent( - `${path}.use`, - use(/** @type {TODO} */ (data)) - ) - ); - } else { - for (const effect of useToEffects(`${path}.use`, use)) { - result.effects.push(effect); - } - } - } - - if (unhandledProperties.has("loader")) { - unhandledProperties.delete("loader"); - unhandledProperties.delete("options"); - unhandledProperties.delete("enforce"); - - const loader = /** @type {RuleSetLoader} */ (rule.loader); - const options = rule.options; - const enforce = rule.enforce; - - if (loader.includes("!")) { - throw ruleSetCompiler.error( - `${path}.loader`, - loader, - "Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays" - ); - } - - if (loader.includes("?")) { - throw ruleSetCompiler.error( - `${path}.loader`, - loader, - "Query arguments on 'loader' has been removed in favor of the 'options' property" - ); - } - - if (typeof options === "string") { - util.deprecate( - () => {}, - `Using a string as loader options is deprecated (${path}.options)`, - "DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING" - )(); - } - - const ident = - options && typeof options === "object" ? path : undefined; - references.set(ident, options); - result.effects.push({ - type: enforce ? `use-${enforce}` : "use", - value: { - loader, - options, - ident - } - }); - } - } - ); - } -} - -module.exports = UseEffectRulePlugin; -- cgit v1.2.3