1
0
Fork 0
management/front/dkha-web-sz-main/node_modules/webpack/lib/optimize/SideEffectsFlagPlugin.js

353 lines
10 KiB
JavaScript
Raw Permalink Normal View History

2023-12-18 13:12:25 +08:00
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const mm = require("micromatch");
const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
/** @typedef {import("../Module")} Module */
/** @typedef {import("../Dependency")} Dependency */
/**
* @typedef {Object} ExportInModule
* @property {Module} module the module
* @property {string} exportName the name of the export
2024-01-16 21:26:16 +08:00
* @property {boolean} checked if the export is conditional
2023-12-18 13:12:25 +08:00
*/
2024-01-16 21:26:16 +08:00
/**
* @typedef {Object} ReexportInfo
* @property {Map<string, ExportInModule[]>} static
* @property {Map<Module, Set<string>>} dynamic
*/
/**
* @param {ReexportInfo} info info object
* @param {string} exportName name of export
* @returns {ExportInModule | undefined} static export
*/
const getMappingFromInfo = (info, exportName) => {
const staticMappings = info.static.get(exportName);
if (staticMappings !== undefined) {
if (staticMappings.length === 1) return staticMappings[0];
return undefined;
}
const dynamicMappings = Array.from(info.dynamic).filter(
([_, ignored]) => !ignored.has(exportName)
);
if (dynamicMappings.length === 1) {
return {
module: dynamicMappings[0][0],
exportName,
checked: true
};
}
return undefined;
};
/**
* @param {ReexportInfo} info info object
* @param {string} exportName name of export of source module
* @param {Module} module the target module
* @param {string} innerExportName name of export of target module
* @param {boolean} checked true, if existence of target module is checked
*/
const addStaticReexport = (
info,
exportName,
module,
innerExportName,
checked
) => {
let mappings = info.static.get(exportName);
if (mappings !== undefined) {
for (const mapping of mappings) {
if (mapping.module === module && mapping.exportName === innerExportName) {
mapping.checked = mapping.checked && checked;
return;
}
}
} else {
mappings = [];
info.static.set(exportName, mappings);
}
mappings.push({
module,
exportName: innerExportName,
checked
});
};
/**
* @param {ReexportInfo} info info object
* @param {Module} module the reexport module
* @param {Set<string>} ignored ignore list
* @returns {void}
*/
const addDynamicReexport = (info, module, ignored) => {
const existingList = info.dynamic.get(module);
if (existingList !== undefined) {
for (const key of existingList) {
if (!ignored.has(key)) existingList.delete(key);
}
} else {
info.dynamic.set(module, new Set(ignored));
}
};
2023-12-18 13:12:25 +08:00
class SideEffectsFlagPlugin {
apply(compiler) {
compiler.hooks.normalModuleFactory.tap("SideEffectsFlagPlugin", nmf => {
nmf.hooks.module.tap("SideEffectsFlagPlugin", (module, data) => {
const resolveData = data.resourceResolveData;
if (
resolveData &&
resolveData.descriptionFileData &&
resolveData.relativePath
) {
const sideEffects = resolveData.descriptionFileData.sideEffects;
const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
resolveData.relativePath,
sideEffects
);
if (!hasSideEffects) {
module.factoryMeta.sideEffectFree = true;
}
}
return module;
});
nmf.hooks.module.tap("SideEffectsFlagPlugin", (module, data) => {
if (data.settings.sideEffects === false) {
module.factoryMeta.sideEffectFree = true;
} else if (data.settings.sideEffects === true) {
module.factoryMeta.sideEffectFree = false;
}
});
});
compiler.hooks.compilation.tap("SideEffectsFlagPlugin", compilation => {
compilation.hooks.optimizeDependencies.tap(
"SideEffectsFlagPlugin",
modules => {
2024-01-16 21:26:16 +08:00
/** @type {Map<Module, ReexportInfo>} */
2023-12-18 13:12:25 +08:00
const reexportMaps = new Map();
// Capture reexports of sideEffectFree modules
for (const module of modules) {
/** @type {Dependency[]} */
const removeDependencies = [];
for (const dep of module.dependencies) {
if (dep instanceof HarmonyImportSideEffectDependency) {
if (dep.module && dep.module.factoryMeta.sideEffectFree) {
removeDependencies.push(dep);
}
} else if (
dep instanceof HarmonyExportImportedSpecifierDependency
) {
if (module.factoryMeta.sideEffectFree) {
const mode = dep.getMode(true);
2024-01-16 21:26:16 +08:00
if (
mode.type === "safe-reexport" ||
mode.type === "checked-reexport" ||
mode.type === "dynamic-reexport" ||
mode.type === "reexport-non-harmony-default" ||
mode.type === "reexport-non-harmony-default-strict" ||
mode.type === "reexport-named-default"
) {
let info = reexportMaps.get(module);
if (!info) {
reexportMaps.set(
module,
(info = {
static: new Map(),
dynamic: new Map()
})
);
2023-12-18 13:12:25 +08:00
}
2024-01-16 21:26:16 +08:00
const targetModule = dep._module;
switch (mode.type) {
case "safe-reexport":
for (const [key, id] of mode.map) {
if (id) {
addStaticReexport(
info,
key,
targetModule,
id,
false
);
}
}
break;
case "checked-reexport":
for (const [key, id] of mode.map) {
if (id) {
addStaticReexport(
info,
key,
targetModule,
id,
true
);
}
}
break;
case "dynamic-reexport":
addDynamicReexport(info, targetModule, mode.ignored);
break;
case "reexport-non-harmony-default":
case "reexport-non-harmony-default-strict":
case "reexport-named-default":
addStaticReexport(
info,
mode.name,
targetModule,
"default",
false
);
break;
2023-12-18 13:12:25 +08:00
}
}
}
}
}
}
// Flatten reexports
2024-01-16 21:26:16 +08:00
for (const info of reexportMaps.values()) {
const dynamicReexports = info.dynamic;
info.dynamic = new Map();
for (const reexport of dynamicReexports) {
let [targetModule, ignored] = reexport;
for (;;) {
const innerInfo = reexportMaps.get(targetModule);
if (!innerInfo) break;
for (const [key, reexports] of innerInfo.static) {
if (ignored.has(key)) continue;
for (const { module, exportName, checked } of reexports) {
addStaticReexport(info, key, module, exportName, checked);
}
}
// Follow dynamic reexport if there is only one
if (innerInfo.dynamic.size !== 1) {
// When there are more then one, we don't know which one
break;
}
ignored = new Set(ignored);
for (const [innerModule, innerIgnored] of innerInfo.dynamic) {
for (const key of innerIgnored) {
if (ignored.has(key)) continue;
// This reexports ends here
addStaticReexport(info, key, targetModule, key, true);
ignored.add(key);
}
targetModule = innerModule;
}
}
// Update reexport as all other cases has been handled
addDynamicReexport(info, targetModule, ignored);
}
}
for (const info of reexportMaps.values()) {
const staticReexports = info.static;
info.static = new Map();
for (const [key, reexports] of staticReexports) {
for (let mapping of reexports) {
for (;;) {
const innerInfo = reexportMaps.get(mapping.module);
if (!innerInfo) break;
const newMapping = getMappingFromInfo(
innerInfo,
mapping.exportName
);
if (!newMapping) break;
mapping = newMapping;
2023-12-18 13:12:25 +08:00
}
2024-01-16 21:26:16 +08:00
addStaticReexport(
info,
key,
mapping.module,
mapping.exportName,
mapping.checked
);
2023-12-18 13:12:25 +08:00
}
}
}
// Update imports along the reexports from sideEffectFree modules
for (const pair of reexportMaps) {
const module = pair[0];
2024-01-16 21:26:16 +08:00
const info = pair[1];
2023-12-18 13:12:25 +08:00
let newReasons = undefined;
for (let i = 0; i < module.reasons.length; i++) {
const reason = module.reasons[i];
const dep = reason.dependency;
if (
2024-01-16 21:26:16 +08:00
(dep instanceof HarmonyExportImportedSpecifierDependency ||
(dep instanceof HarmonyImportSpecifierDependency &&
!dep.namespaceObjectAsContext)) &&
dep._id
2023-12-18 13:12:25 +08:00
) {
2024-01-16 21:26:16 +08:00
const mapping = getMappingFromInfo(info, dep._id);
2023-12-18 13:12:25 +08:00
if (mapping) {
dep.redirectedModule = mapping.module;
dep.redirectedId = mapping.exportName;
mapping.module.addReason(
reason.module,
dep,
reason.explanation
? reason.explanation +
2024-01-16 21:26:16 +08:00
" (skipped side-effect-free modules)"
2023-12-18 13:12:25 +08:00
: "(skipped side-effect-free modules)"
);
// removing the currect reason, by not adding it to the newReasons array
// lazily create the newReasons array
if (newReasons === undefined) {
newReasons = i === 0 ? [] : module.reasons.slice(0, i);
}
continue;
}
}
if (newReasons !== undefined) newReasons.push(reason);
}
if (newReasons !== undefined) {
module.reasons = newReasons;
}
}
}
);
});
}
static moduleHasSideEffects(moduleName, flagValue) {
switch (typeof flagValue) {
case "undefined":
return true;
case "boolean":
return flagValue;
case "string":
if (process.platform === "win32") {
flagValue = flagValue.replace(/\\/g, "/");
}
return mm.isMatch(moduleName, flagValue, {
matchBase: true
});
case "object":
return flagValue.some(glob =>
SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob)
);
}
}
}
module.exports = SideEffectsFlagPlugin;