Homec4science
Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/webpack/lib/ExportsInfo.js
66f34df107aaissn4frontend

Last Change
Raw File

ExportsInfo.js
View Options

/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const { equals } = require("./util/ArrayHelpers");
const SortableSet = require("./util/SortableSet");
const makeSerializable = require("./util/makeSerializable");
const { forEachRuntime } = require("./util/runtime");
/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
/** @typedef {import("./Module")} Module */
/** @typedef {import("./ModuleGraph")} ModuleGraph */
/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
/** @typedef {import("./util/Hash")} Hash */
/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
const UsageState = Object.freeze({
Unused: /** @type {0} */ (0),
OnlyPropertiesUsed: /** @type {1} */ (1),
NoInfo: /** @type {2} */ (2),
Unknown: /** @type {3} */ (3),
Used: /** @type {4} */ (4)
});
const RETURNS_TRUE = () => true;
const CIRCULAR = Symbol("circular target");
class RestoreProvidedData {
constructor(
exports,
otherProvided,
otherCanMangleProvide,
otherTerminalBinding
) {
this.exports = exports;
this.otherProvided = otherProvided;
this.otherCanMangleProvide = otherCanMangleProvide;
this.otherTerminalBinding = otherTerminalBinding;
}
serialize({ write }) {
write(this.exports);
write(this.otherProvided);
write(this.otherCanMangleProvide);
write(this.otherTerminalBinding);
}
static deserialize({ read }) {
return new RestoreProvidedData(read(), read(), read(), read());
}
}
makeSerializable(
RestoreProvidedData,
"webpack/lib/ModuleGraph",
"RestoreProvidedData"
);
class ExportsInfo {
constructor() {
/** @type {Map<string, ExportInfo>} */
this._exports = new Map();
this._otherExportsInfo = new ExportInfo(null);
this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
this._exportsAreOrdered = false;
/** @type {ExportsInfo=} */
this._redirectTo = undefined;
}
/**
* @returns {Iterable<ExportInfo>} all owned exports in any order
*/
get ownedExports() {
return this._exports.values();
}
/**
* @returns {Iterable<ExportInfo>} all owned exports in order
*/
get orderedOwnedExports() {
if (!this._exportsAreOrdered) {
this._sortExports();
}
return this._exports.values();
}
/**
* @returns {Iterable<ExportInfo>} all exports in any order
*/
get exports() {
if (this._redirectTo !== undefined) {
const map = new Map(this._redirectTo._exports);
for (const [key, value] of this._exports) {
map.set(key, value);
}
return map.values();
}
return this._exports.values();
}
/**
* @returns {Iterable<ExportInfo>} all exports in order
*/
get orderedExports() {
if (!this._exportsAreOrdered) {
this._sortExports();
}
if (this._redirectTo !== undefined) {
const map = new Map(
Array.from(this._redirectTo.orderedExports, item => [item.name, item])
);
for (const [key, value] of this._exports) {
map.set(key, value);
}
// sorting should be pretty fast as map contains
// a lot of presorted items
this._sortExportsMap(map);
return map.values();
}
return this._exports.values();
}
/**
* @returns {ExportInfo} the export info of unlisted exports
*/
get otherExportsInfo() {
if (this._redirectTo !== undefined)
return this._redirectTo.otherExportsInfo;
return this._otherExportsInfo;
}
_sortExportsMap(exports) {
if (exports.size > 1) {
const entriesInOrder = Array.from(exports.values());
if (
entriesInOrder.length !== 2 ||
entriesInOrder[0].name > entriesInOrder[1].name
) {
entriesInOrder.sort((a, b) => {
return a.name < b.name ? -1 : 1;
});
exports.clear();
for (const entry of entriesInOrder) {
exports.set(entry.name, entry);
}
}
}
}
_sortExports() {
this._sortExportsMap(this._exports);
this._exportsAreOrdered = true;
}
setRedirectNamedTo(exportsInfo) {
if (this._redirectTo === exportsInfo) return false;
this._redirectTo = exportsInfo;
return true;
}
setHasProvideInfo() {
for (const exportInfo of this._exports.values()) {
if (exportInfo.provided === undefined) {
exportInfo.provided = false;
}
if (exportInfo.canMangleProvide === undefined) {
exportInfo.canMangleProvide = true;
}
}
if (this._redirectTo !== undefined) {
this._redirectTo.setHasProvideInfo();
} else {
if (this._otherExportsInfo.provided === undefined) {
this._otherExportsInfo.provided = false;
}
if (this._otherExportsInfo.canMangleProvide === undefined) {
this._otherExportsInfo.canMangleProvide = true;
}
}
}
setHasUseInfo() {
for (const exportInfo of this._exports.values()) {
exportInfo.setHasUseInfo();
}
this._sideEffectsOnlyInfo.setHasUseInfo();
if (this._redirectTo !== undefined) {
this._redirectTo.setHasUseInfo();
} else {
this._otherExportsInfo.setHasUseInfo();
if (this._otherExportsInfo.canMangleUse === undefined) {
this._otherExportsInfo.canMangleUse = true;
}
}
}
/**
* @param {string} name export name
* @returns {ExportInfo} export info for this name
*/
getOwnExportInfo(name) {
const info = this._exports.get(name);
if (info !== undefined) return info;
const newInfo = new ExportInfo(name, this._otherExportsInfo);
this._exports.set(name, newInfo);
this._exportsAreOrdered = false;
return newInfo;
}
/**
* @param {string} name export name
* @returns {ExportInfo} export info for this name
*/
getExportInfo(name) {
const info = this._exports.get(name);
if (info !== undefined) return info;
if (this._redirectTo !== undefined)
return this._redirectTo.getExportInfo(name);
const newInfo = new ExportInfo(name, this._otherExportsInfo);
this._exports.set(name, newInfo);
this._exportsAreOrdered = false;
return newInfo;
}
/**
* @param {string} name export name
* @returns {ExportInfo} export info for this name
*/
getReadOnlyExportInfo(name) {
const info = this._exports.get(name);
if (info !== undefined) return info;
if (this._redirectTo !== undefined)
return this._redirectTo.getReadOnlyExportInfo(name);
return this._otherExportsInfo;
}
/**
* @param {string[]} name export name
* @returns {ExportInfo | undefined} export info for this name
*/
getReadOnlyExportInfoRecursive(name) {
const exportInfo = this.getReadOnlyExportInfo(name[0]);
if (name.length === 1) return exportInfo;
if (!exportInfo.exportsInfo) return undefined;
return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
}
/**
* @param {string[]=} name the export name
* @returns {ExportsInfo | undefined} the nested exports info
*/
getNestedExportsInfo(name) {
if (Array.isArray(name) && name.length > 0) {
const info = this.getReadOnlyExportInfo(name[0]);
if (!info.exportsInfo) return undefined;
return info.exportsInfo.getNestedExportsInfo(name.slice(1));
}
return this;
}
/**
* @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
* @param {Set<string>=} excludeExports list of unaffected exports
* @param {any=} targetKey use this as key for the target
* @param {ModuleGraphConnection=} targetModule set this module as target
* @returns {boolean} true, if this call changed something
*/
setUnknownExportsProvided(
canMangle,
excludeExports,
targetKey,
targetModule
) {
let changed = false;
if (excludeExports) {
for (const name of excludeExports) {
// Make sure these entries exist, so they can get different info
this.getExportInfo(name);
}
}
for (const exportInfo of this._exports.values()) {
if (excludeExports && excludeExports.has(exportInfo.name)) continue;
if (exportInfo.provided !== true && exportInfo.provided !== null) {
exportInfo.provided = null;
changed = true;
}
if (!canMangle && exportInfo.canMangleProvide !== false) {
exportInfo.canMangleProvide = false;
changed = true;
}
if (targetKey) {
exportInfo.setTarget(targetKey, targetModule, [exportInfo.name]);
}
}
if (this._redirectTo !== undefined) {
if (
this._redirectTo.setUnknownExportsProvided(
canMangle,
excludeExports,
targetKey,
targetModule
)
) {
changed = true;
}
} else {
if (
this._otherExportsInfo.provided !== true &&
this._otherExportsInfo.provided !== null
) {
this._otherExportsInfo.provided = null;
changed = true;
}
if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {
this._otherExportsInfo.canMangleProvide = false;
changed = true;
}
if (targetKey) {
this._otherExportsInfo.setTarget(targetKey, targetModule, undefined);
}
}
return changed;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when something changed
*/
setUsedInUnknownWay(runtime) {
let changed = false;
for (const exportInfo of this._exports.values()) {
if (exportInfo.setUsedInUnknownWay(runtime)) {
changed = true;
}
}
if (this._redirectTo !== undefined) {
if (this._redirectTo.setUsedInUnknownWay(runtime)) {
changed = true;
}
} else {
if (
this._otherExportsInfo.setUsedConditionally(
used => used < UsageState.Unknown,
UsageState.Unknown,
runtime
)
) {
changed = true;
}
if (this._otherExportsInfo.canMangleUse !== false) {
this._otherExportsInfo.canMangleUse = false;
changed = true;
}
}
return changed;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when something changed
*/
setUsedWithoutInfo(runtime) {
let changed = false;
for (const exportInfo of this._exports.values()) {
if (exportInfo.setUsedWithoutInfo(runtime)) {
changed = true;
}
}
if (this._redirectTo !== undefined) {
if (this._redirectTo.setUsedWithoutInfo(runtime)) {
changed = true;
}
} else {
if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {
changed = true;
}
if (this._otherExportsInfo.canMangleUse !== false) {
this._otherExportsInfo.canMangleUse = false;
changed = true;
}
}
return changed;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when something changed
*/
setAllKnownExportsUsed(runtime) {
let changed = false;
for (const exportInfo of this._exports.values()) {
if (exportInfo.setUsed(UsageState.Used, runtime)) {
changed = true;
}
}
return changed;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when something changed
*/
setUsedForSideEffectsOnly(runtime) {
return this._sideEffectsOnlyInfo.setUsedConditionally(
used => used === UsageState.Unused,
UsageState.Used,
runtime
);
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when the module exports are used in any way
*/
isUsed(runtime) {
if (this._redirectTo !== undefined) {
if (this._redirectTo.isUsed(runtime)) {
return true;
}
} else {
if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
return true;
}
}
for (const exportInfo of this._exports.values()) {
if (exportInfo.getUsed(runtime) !== UsageState.Unused) {
return true;
}
}
return false;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {boolean} true, when the module is used in any way
*/
isModuleUsed(runtime) {
if (this.isUsed(runtime)) return true;
if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
return true;
return false;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
*/
getUsedExports(runtime) {
if (!this._redirectTo !== undefined) {
switch (this._otherExportsInfo.getUsed(runtime)) {
case UsageState.NoInfo:
return null;
case UsageState.Unknown:
return true;
case UsageState.OnlyPropertiesUsed:
case UsageState.Used:
return true;
}
}
const array = [];
if (!this._exportsAreOrdered) this._sortExports();
for (const exportInfo of this._exports.values()) {
switch (exportInfo.getUsed(runtime)) {
case UsageState.NoInfo:
return null;
case UsageState.Unknown:
return true;
case UsageState.OnlyPropertiesUsed:
case UsageState.Used:
array.push(exportInfo.name);
}
}
if (this._redirectTo !== undefined) {
const inner = this._redirectTo.getUsedExports(runtime);
if (inner === null) return null;
if (inner === true) return true;
if (inner !== false) {
for (const item of inner) {
array.push(item);
}
}
}
if (array.length === 0) {
switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {
case UsageState.NoInfo:
return null;
case UsageState.Unused:
return false;
}
}
return new SortableSet(array);
}
/**
* @returns {null | true | string[]} list of exports when known
*/
getProvidedExports() {
if (!this._redirectTo !== undefined) {
switch (this._otherExportsInfo.provided) {
case undefined:
return null;
case null:
return true;
case true:
return true;
}
}
const array = [];
if (!this._exportsAreOrdered) this._sortExports();
for (const exportInfo of this._exports.values()) {
switch (exportInfo.provided) {
case undefined:
return null;
case null:
return true;
case true:
array.push(exportInfo.name);
}
}
if (this._redirectTo !== undefined) {
const inner = this._redirectTo.getProvidedExports();
if (inner === null) return null;
if (inner === true) return true;
for (const item of inner) {
if (!array.includes(item)) {
array.push(item);
}
}
}
return array;
}
/**
* @param {RuntimeSpec} runtime the runtime
* @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)
*/
getRelevantExports(runtime) {
const list = [];
for (const exportInfo of this._exports.values()) {
const used = exportInfo.getUsed(runtime);
if (used === UsageState.Unused) continue;
if (exportInfo.provided === false) continue;
list.push(exportInfo);
}
if (this._redirectTo !== undefined) {
for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {
if (!this._exports.has(exportInfo.name)) list.push(exportInfo);
}
}
if (
this._otherExportsInfo.provided !== false &&
this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused
) {
list.push(this._otherExportsInfo);
}
return list;
}
/**
* @param {string | string[]} name the name of the export
* @returns {boolean | undefined | null} if the export is provided
*/
isExportProvided(name) {
if (Array.isArray(name)) {
const info = this.getReadOnlyExportInfo(name[0]);
if (info.exportsInfo && name.length > 1) {
return info.exportsInfo.isExportProvided(name.slice(1));
}
return info.provided;
}
const info = this.getReadOnlyExportInfo(name);
return info.provided;
}
/**
* @param {RuntimeSpec} runtime runtime
* @returns {string} key representing the usage
*/
getUsageKey(runtime) {
const key = [];
if (this._redirectTo !== undefined) {
key.push(this._redirectTo.getUsageKey(runtime));
} else {
key.push(this._otherExportsInfo.getUsed(runtime));
}
key.push(this._sideEffectsOnlyInfo.getUsed(runtime));
for (const exportInfo of this.orderedOwnedExports) {
key.push(exportInfo.getUsed(runtime));
}
return key.join("|");
}
/**
* @param {RuntimeSpec} runtimeA first runtime
* @param {RuntimeSpec} runtimeB second runtime
* @returns {boolean} true, when equally used
*/
isEquallyUsed(runtimeA, runtimeB) {
if (this._redirectTo !== undefined) {
if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;
} else {
if (
this._otherExportsInfo.getUsed(runtimeA) !==
this._otherExportsInfo.getUsed(runtimeB)
) {
return false;
}
}
if (
this._sideEffectsOnlyInfo.getUsed(runtimeA) !==
this._sideEffectsOnlyInfo.getUsed(runtimeB)
) {
return false;
}
for (const exportInfo of this.ownedExports) {
if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
return false;
}
return true;
}
/**
* @param {string | string[]} name export name
* @param {RuntimeSpec} runtime check usage for this runtime only
* @returns {UsageStateType} usage status
*/
getUsed(name, runtime) {
if (Array.isArray(name)) {
if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
let info = this.getReadOnlyExportInfo(name[0]);
if (info.exportsInfo && name.length > 1) {
return info.exportsInfo.getUsed(name.slice(1), runtime);
}
return info.getUsed(runtime);
}
let info = this.getReadOnlyExportInfo(name);
return info.getUsed(runtime);
}
/**
* @param {string | string[]} name the export name
* @param {RuntimeSpec} runtime check usage for this runtime only
* @returns {string | string[] | false} the used name
*/
getUsedName(name, runtime) {
if (Array.isArray(name)) {
// TODO improve this
if (name.length === 0) {
if (!this.isUsed(runtime)) return false;
return name;
}
let info = this.getReadOnlyExportInfo(name[0]);
const x = info.getUsedName(name[0], runtime);
if (x === false) return false;
const arr = x === name[0] && name.length === 1 ? name : [x];
if (name.length === 1) {
return arr;
}
if (
info.exportsInfo &&
info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
) {
const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
if (!nested) return false;
return arr.concat(nested);
} else {
return arr.concat(name.slice(1));
}
} else {
let info = this.getReadOnlyExportInfo(name);
const usedName = info.getUsedName(name, runtime);
return usedName;
}
}
/**
* @param {Hash} hash the hash
* @param {RuntimeSpec} runtime the runtime
* @returns {void}
*/
updateHash(hash, runtime) {
for (const exportInfo of this.orderedExports) {
exportInfo.updateHash(hash, runtime);
}
this._sideEffectsOnlyInfo.updateHash(hash, runtime);
this._otherExportsInfo.updateHash(hash, runtime);
if (this._redirectTo !== undefined) {
this._redirectTo.updateHash(hash, runtime);
}
}
getRestoreProvidedData() {
const otherProvided = this._otherExportsInfo.provided;
const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
const exports = [];
for (const exportInfo of this._exports.values()) {
if (
exportInfo.provided !== otherProvided ||
exportInfo.canMangleProvide !== otherCanMangleProvide ||
exportInfo.terminalBinding !== otherTerminalBinding ||
exportInfo.exportsInfoOwned
) {
exports.push({
name: exportInfo.name,
provided: exportInfo.provided,
canMangleProvide: exportInfo.canMangleProvide,
terminalBinding: exportInfo.terminalBinding,
exportsInfo: exportInfo.exportsInfoOwned
? exportInfo.exportsInfo.getRestoreProvidedData()
: undefined
});
}
}
return new RestoreProvidedData(
exports,
otherProvided,
otherCanMangleProvide,
otherTerminalBinding
);
}
restoreProvided({
otherProvided,
otherCanMangleProvide,
otherTerminalBinding,
exports
}) {
for (const exportInfo of this._exports.values()) {
exportInfo.provided = otherProvided;
exportInfo.canMangleProvide = otherCanMangleProvide;
exportInfo.terminalBinding = otherTerminalBinding;
}
this._otherExportsInfo.provided = otherProvided;
this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;
this._otherExportsInfo.terminalBinding = otherTerminalBinding;
for (const exp of exports) {
const exportInfo = this.getExportInfo(exp.name);
exportInfo.provided = exp.provided;
exportInfo.canMangleProvide = exp.canMangleProvide;
exportInfo.terminalBinding = exp.terminalBinding;
if (exp.exportsInfo) {
const exportsInfo = exportInfo.createNestedExportsInfo();
exportsInfo.restoreProvided(exp.exportsInfo);
}
}
}
}
class ExportInfo {
/**
* @param {string} name the original name of the export
* @param {ExportInfo=} initFrom init values from this ExportInfo
*/
constructor(name, initFrom) {
/** @type {string} */
this.name = name;
/** @private @type {string | null} */
this._usedName = initFrom ? initFrom._usedName : null;
/** @private @type {UsageStateType} */
this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
/** @private @type {Map<string, RuntimeUsageStateType>} */
this._usedInRuntime =
initFrom && initFrom._usedInRuntime
? new Map(initFrom._usedInRuntime)
: undefined;
/** @private @type {boolean} */
this._hasUseInRuntimeInfo = initFrom
? initFrom._hasUseInRuntimeInfo
: false;
/**
* true: it is provided
* false: it is not provided
* null: only the runtime knows if it is provided
* undefined: it was not determined if it is provided
* @type {boolean | null | undefined}
*/
this.provided = initFrom ? initFrom.provided : undefined;
/**
* is the export a terminal binding that should be checked for export star conflicts
* @type {boolean}
*/
this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
/**
* true: it can be mangled
* false: is can not be mangled
* undefined: it was not determined if it can be mangled
* @type {boolean | undefined}
*/
this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
/**
* true: it can be mangled
* false: is can not be mangled
* undefined: it was not determined if it can be mangled
* @type {boolean | undefined}
*/
this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
/** @type {boolean} */
this.exportsInfoOwned = false;
/** @type {ExportsInfo=} */
this.exportsInfo = undefined;
/** @type {Map<any, { connection: ModuleGraphConnection, export: string[] } | null>=} */
this._target = undefined;
if (initFrom && initFrom._target) {
this._target = new Map();
for (const [key, value] of initFrom._target) {
this._target.set(
key,
value ? { connection: value.connection, export: [name] } : null
);
}
}
}
// TODO webpack 5 remove
/** @private */
get used() {
throw new Error("REMOVED");
}
/** @private */
get usedName() {
throw new Error("REMOVED");
}
/**
* @private
* @param {*} v v
*/
set used(v) {
throw new Error("REMOVED");
}
/**
* @private
* @param {*} v v
*/
set usedName(v) {
throw new Error("REMOVED");
}
get canMangle() {
switch (this.canMangleProvide) {
case undefined:
return this.canMangleUse === false ? false : undefined;
case false:
return false;
case true:
switch (this.canMangleUse) {
case undefined:
return undefined;
case false:
return false;
case true:
return true;
}
}
throw new Error(
`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`
);
}
/**
* @param {RuntimeSpec} runtime only apply to this runtime
* @returns {boolean} true, when something changed
*/
setUsedInUnknownWay(runtime) {
let changed = false;
if (
this.setUsedConditionally(
used => used < UsageState.Unknown,
UsageState.Unknown,
runtime
)
) {
changed = true;
}
if (this.canMangleUse !== false) {
this.canMangleUse = false;
changed = true;
}
return changed;
}
/**
* @param {RuntimeSpec} runtime only apply to this runtime
* @returns {boolean} true, when something changed
*/
setUsedWithoutInfo(runtime) {
let changed = false;
if (this.setUsed(UsageState.NoInfo, runtime)) {
changed = true;
}
if (this.canMangleUse !== false) {
this.canMangleUse = false;
changed = true;
}
return changed;
}
setHasUseInfo() {
if (!this._hasUseInRuntimeInfo) {
this._hasUseInRuntimeInfo = true;
}
if (this.canMangleUse === undefined) {
this.canMangleUse = true;
}
if (this.exportsInfoOwned) {
this.exportsInfo.setHasUseInfo();
}
}
/**
* @param {function(UsageStateType): boolean} condition compare with old value
* @param {UsageStateType} newValue set when condition is true
* @param {RuntimeSpec} runtime only apply to this runtime
* @returns {boolean} true when something has changed
*/
setUsedConditionally(condition, newValue, runtime) {
if (runtime === undefined) {
if (this._globalUsed === undefined) {
this._globalUsed = newValue;
return true;
} else {
if (this._globalUsed !== newValue && condition(this._globalUsed)) {
this._globalUsed = newValue;
return true;
}
}
} else if (this._usedInRuntime === undefined) {
if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
this._usedInRuntime = new Map();
forEachRuntime(runtime, runtime =>
this._usedInRuntime.set(runtime, newValue)
);
return true;
}
} else {
let changed = false;
forEachRuntime(runtime, runtime => {
/** @type {UsageStateType} */
let oldValue = this._usedInRuntime.get(runtime);
if (oldValue === undefined) oldValue = UsageState.Unused;
if (newValue !== oldValue && condition(oldValue)) {
if (newValue === UsageState.Unused) {
this._usedInRuntime.delete(runtime);
} else {
this._usedInRuntime.set(runtime, newValue);
}
changed = true;
}
});
if (changed) {
if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
return true;
}
}
return false;
}
/**
* @param {UsageStateType} newValue new value of the used state
* @param {RuntimeSpec} runtime only apply to this runtime
* @returns {boolean} true when something has changed
*/
setUsed(newValue, runtime) {
if (runtime === undefined) {
if (this._globalUsed !== newValue) {
this._globalUsed = newValue;
return true;
}
} else if (this._usedInRuntime === undefined) {
if (newValue !== UsageState.Unused) {
this._usedInRuntime = new Map();
forEachRuntime(runtime, runtime =>
this._usedInRuntime.set(runtime, newValue)
);
return true;
}
} else {
let changed = false;
forEachRuntime(runtime, runtime => {
/** @type {UsageStateType} */
let oldValue = this._usedInRuntime.get(runtime);
if (oldValue === undefined) oldValue = UsageState.Unused;
if (newValue !== oldValue) {
if (newValue === UsageState.Unused) {
this._usedInRuntime.delete(runtime);
} else {
this._usedInRuntime.set(runtime, newValue);
}
changed = true;
}
});
if (changed) {
if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
return true;
}
}
return false;
}
/**
* @param {any} key the key
* @param {ModuleGraphConnection=} connection the target module if a single one
* @param {string[]=} exportName the exported name
* @returns {boolean} true, if something has changed
*/
setTarget(key, connection, exportName) {
if (exportName) exportName = [...exportName];
if (!this._target) {
this._target = new Map();
this._target.set(
key,
connection ? { connection, export: exportName } : null
);
return true;
}
const oldTarget = this._target.get(key);
if (!oldTarget) {
if (oldTarget === null && !connection) return false;
this._target.set(
key,
connection ? { connection, export: exportName } : null
);
return true;
}
if (!connection) {
this._target.set(key, null);
return true;
}
if (
oldTarget.connection !== connection ||
(exportName
? !oldTarget.export || !equals(oldTarget.export, exportName)
: oldTarget.export)
) {
oldTarget.connection = connection;
oldTarget.export = exportName;
return true;
}
return false;
}
/**
* @param {RuntimeSpec} runtime for this runtime
* @returns {UsageStateType} usage state
*/
getUsed(runtime) {
if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
if (this._globalUsed !== undefined) return this._globalUsed;
if (this._usedInRuntime === undefined) {
return UsageState.Unused;
} else if (typeof runtime === "string") {
const value = this._usedInRuntime.get(runtime);
return value === undefined ? UsageState.Unused : value;
} else if (runtime === undefined) {
/** @type {UsageStateType} */
let max = UsageState.Unused;
for (const value of this._usedInRuntime.values()) {
if (value === UsageState.Used) {
return UsageState.Used;
}
if (max < value) max = value;
}
return max;
} else {
/** @type {UsageStateType} */
let max = UsageState.Unused;
for (const item of runtime) {
const value = this._usedInRuntime.get(item);
if (value !== undefined) {
if (value === UsageState.Used) {
return UsageState.Used;
}
if (max < value) max = value;
}
}
return max;
}
}
/**
* get used name
* @param {string | undefined} fallbackName fallback name for used exports with no name
* @param {RuntimeSpec} runtime check usage for this runtime only
* @returns {string | false} used name
*/
getUsedName(fallbackName, runtime) {
if (this._hasUseInRuntimeInfo) {
if (this._globalUsed !== undefined) {
if (this._globalUsed === UsageState.Unused) return false;
} else {
if (this._usedInRuntime === undefined) return false;
if (typeof runtime === "string") {
if (!this._usedInRuntime.has(runtime)) {
return false;
}
} else if (runtime !== undefined) {
if (
Array.from(runtime).every(
runtime => !this._usedInRuntime.has(runtime)
)
) {
return false;
}
}
}
}
if (this._usedName !== null) return this._usedName;
return this.name || fallbackName;
}
/**
* @returns {boolean} true, when a mangled name of this export is set
*/
hasUsedName() {
return this._usedName !== null;
}
/**
* Sets the mangled name of this export
* @param {string} name the new name
* @returns {void}
*/
setUsedName(name) {
this._usedName = name;
}
/**
* @param {ModuleGraph} moduleGraph the module graph
* @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
* @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
*/
getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
if (this.terminalBinding) return this;
const target = this.getTarget(moduleGraph, resolveTargetFilter);
if (!target) return undefined;
const exportsInfo = moduleGraph.getExportsInfo(target.module);
if (!target.export) return exportsInfo;
return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
}
isReexport() {
return !this.terminalBinding && this._target && this._target.size > 0;
}
/**
* @param {ModuleGraph} moduleGraph the module graph
* @param {function(Module): boolean} validTargetModuleFilter a valid target module
* @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
*/
findTarget(moduleGraph, validTargetModuleFilter) {
return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
}
/**
* @param {ModuleGraph} moduleGraph the module graph
* @param {function(Module): boolean} validTargetModuleFilter a valid target module
* @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
* @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
*/
_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
if (!this._target || this._target.size === 0) return undefined;
let rawTarget = this._target.values().next().value;
if (!rawTarget) return undefined;
/** @type {{ module: Module, export: string[] | undefined }} */
let target = {
module: rawTarget.connection.module,
export: rawTarget.export
};
for (;;) {
if (validTargetModuleFilter(target.module)) return target;
const exportsInfo = moduleGraph.getExportsInfo(target.module);
const exportInfo = exportsInfo.getExportInfo(target.export[0]);
if (alreadyVisited.has(exportInfo)) return null;
const newTarget = exportInfo._findTarget(
moduleGraph,
validTargetModuleFilter,
alreadyVisited
);
if (!newTarget) return false;
if (target.export.length === 1) {
target = newTarget;
} else {
target = {
module: newTarget.module,
export: newTarget.export
? newTarget.export.concat(target.export.slice(1))
: target.export.slice(1)
};
}
}
}
/**
* @param {ModuleGraph} moduleGraph the module graph
* @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
* @returns {{ module: Module, export: string[] | undefined } | undefined} the target
*/
getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
if (result === CIRCULAR) return undefined;
return result;
}
/**
* @param {ModuleGraph} moduleGraph the module graph
* @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
* @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
* @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
*/
_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
/**
* @param {{ connection: ModuleGraphConnection, export: string[] | undefined } | null} inputTarget unresolved target
* @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
* @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | null} resolved target
*/
const resolveTarget = (inputTarget, alreadyVisited) => {
if (!inputTarget) return null;
if (!inputTarget.export) {
return {
module: inputTarget.connection.module,
connection: inputTarget.connection,
export: undefined
};
}
/** @type {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} */
let target = {
module: inputTarget.connection.module,
connection: inputTarget.connection,
export: inputTarget.export
};
if (!resolveTargetFilter(target)) return target;
let alreadyVisitedOwned = false;
for (;;) {
const exportsInfo = moduleGraph.getExportsInfo(target.module);
const exportInfo = exportsInfo.getExportInfo(target.export[0]);
if (!exportInfo) return target;
if (alreadyVisited.has(exportInfo)) return CIRCULAR;
const newTarget = exportInfo._getTarget(
moduleGraph,
resolveTargetFilter,
alreadyVisited
);
if (newTarget === CIRCULAR) return CIRCULAR;
if (!newTarget) return target;
if (target.export.length === 1) {
target = newTarget;
if (!target.export) return target;
} else {
target = {
module: newTarget.module,
connection: newTarget.connection,
export: newTarget.export
? newTarget.export.concat(target.export.slice(1))
: target.export.slice(1)
};
}
if (!resolveTargetFilter(target)) return target;
if (!alreadyVisitedOwned) {
alreadyVisited = new Set(alreadyVisited);
alreadyVisitedOwned = true;
}
alreadyVisited.add(exportInfo);
}
};
if (!this._target || this._target.size === 0) return undefined;
if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR;
const newAlreadyVisited = new Set(alreadyVisited);
newAlreadyVisited.add(this);
const values = this._target.values();
const target = resolveTarget(values.next().value, newAlreadyVisited);
if (target === CIRCULAR) return CIRCULAR;
if (target === null) return undefined;
if (this._target.size === 1) {
return target;
}
let result = values.next();
while (!result.done) {
const t = resolveTarget(result.value, newAlreadyVisited);
if (t === CIRCULAR) return CIRCULAR;
if (t === null) return undefined;
if (t.module !== target.module) return undefined;
if (!t.export !== !target.export) return undefined;
if (target.export && !equals(t.export, target.export)) return undefined;
result = values.next();
}
return target;
}
/**
* Move the target forward as long resolveTargetFilter is fulfilled
* @param {ModuleGraph} moduleGraph the module graph
* @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
* @returns {{ module: Module, export: string[] | undefined } | undefined} the target
*/
moveTarget(moduleGraph, resolveTargetFilter) {
const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
if (target === CIRCULAR) return undefined;
if (!target) return undefined;
this._target.clear();
this._target.set(undefined, {
connection: target.connection,
export: target.export
});
return target;
}
createNestedExportsInfo() {
if (this.exportsInfoOwned) return this.exportsInfo;
this.exportsInfoOwned = true;
const oldExportsInfo = this.exportsInfo;
this.exportsInfo = new ExportsInfo();
this.exportsInfo.setHasProvideInfo();
if (oldExportsInfo) {
this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
}
return this.exportsInfo;
}
getNestedExportsInfo() {
return this.exportsInfo;
}
updateHash(hash, runtime) {
hash.update(`${this._usedName || this.name}`);
hash.update(`${this.getUsed(runtime)}`);
hash.update(`${this.provided}`);
hash.update(`${this.canMangle}`);
hash.update(`${this.terminalBinding}`);
}
getUsedInfo() {
if (this._globalUsed !== undefined) {
switch (this._globalUsed) {
case UsageState.Unused:
return "unused";
case UsageState.NoInfo:
return "no usage info";
case UsageState.Unknown:
return "maybe used (runtime-defined)";
case UsageState.Used:
return "used";
case UsageState.OnlyPropertiesUsed:
return "only properties used";
}
} else if (this._usedInRuntime !== undefined) {
/** @type {Map<RuntimeUsageStateType, string[]>} */
const map = new Map();
for (const [runtime, used] of this._usedInRuntime) {
const list = map.get(used);
if (list !== undefined) list.push(runtime);
else map.set(used, [runtime]);
}
const specificInfo = Array.from(map, ([used, runtimes]) => {
switch (used) {
case UsageState.NoInfo:
return `no usage info in ${runtimes.join(", ")}`;
case UsageState.Unknown:
return `maybe used in ${runtimes.join(", ")} (runtime-defined)`;
case UsageState.Used:
return `used in ${runtimes.join(", ")}`;
case UsageState.OnlyPropertiesUsed:
return `only properties used in ${runtimes.join(", ")}`;
}
});
if (specificInfo.length > 0) {
return specificInfo.join("; ");
}
}
return this._hasUseInRuntimeInfo ? "unused" : "no usage info";
}
getProvidedInfo() {
switch (this.provided) {
case undefined:
return "no provided info";
case null:
return "maybe provided (runtime-defined)";
case true:
return "provided";
case false:
return "not provided";
}
}
getRenameInfo() {
if (this._usedName !== null && this._usedName !== this.name) {
return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
}
switch (this.canMangleProvide) {
case undefined:
switch (this.canMangleUse) {
case undefined:
return "missing provision and use info prevents renaming";
case false:
return "usage prevents renaming (no provision info)";
case true:
return "missing provision info prevents renaming";
}
break;
case true:
switch (this.canMangleUse) {
case undefined:
return "missing usage info prevents renaming";
case false:
return "usage prevents renaming";
case true:
return "could be renamed";
}
break;
case false:
switch (this.canMangleUse) {
case undefined:
return "provision prevents renaming (no use info)";
case false:
return "usage and provision prevents renaming";
case true:
return "provision prevents renaming";
}
break;
}
throw new Error(
`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`
);
}
}
module.exports = ExportsInfo;
module.exports.ExportInfo = ExportInfo;
module.exports.UsageState = UsageState;
c4science · Help