652 lines
17 KiB
JavaScript
652 lines
17 KiB
JavaScript
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
const DependenciesBlock = require("./DependenciesBlock");
|
|
const Template = require("./Template");
|
|
const SortableSet = require("./util/SortableSet");
|
|
|
|
/** @typedef {import("webpack-sources").Source} Source */
|
|
/** @typedef {import("./Chunk")} Chunk */
|
|
/** @typedef {import("./ChunkGroup")} ChunkGroup */
|
|
/** @typedef {import("./Compilation")} Compilation */
|
|
/** @typedef {import("./Dependency")} Dependency */
|
|
/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
|
|
/** @typedef {import("./ModuleGraph")} ModuleGraph */
|
|
/** @typedef {import("./RequestShortener")} RequestShortener */
|
|
/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
|
|
/** @typedef {import("./WebpackError")} WebpackError */
|
|
/** @typedef {import("./util/createHash").Hash} Hash */
|
|
|
|
/**
|
|
* @typedef {Object} SourceContext
|
|
* @property {DependencyTemplates} dependencyTemplates the dependency templates
|
|
* @property {RuntimeTemplate} runtimeTemplate the runtime template
|
|
* @property {ModuleGraph} moduleGraph the module graph
|
|
* @property {string=} type the type of source that should be generated
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} LibIdentOptions
|
|
* @property {string} context absolute context path to which lib ident is relative to
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} KnownBuildMeta
|
|
* @property {(boolean | string[])=} providedExports
|
|
* @property {("named" | "namespace")=} exportsType
|
|
*/
|
|
|
|
/** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
|
|
|
|
const EMPTY_RESOLVE_OPTIONS = {};
|
|
const optimizationBailoutSymbol = Symbol("optimization bailout");
|
|
const usedExportsSymbol = Symbol("used exports");
|
|
const issuerSymbol = Symbol("issuer");
|
|
|
|
let debugId = 1000;
|
|
|
|
const sortById = (a, b) => {
|
|
return a.id - b.id;
|
|
};
|
|
|
|
const sortByDebugId = (a, b) => {
|
|
return a.debugId - b.debugId;
|
|
};
|
|
|
|
const getIndexMap = set => {
|
|
set.sort();
|
|
const map = new Map();
|
|
let idx = 0;
|
|
for (const item of set) {
|
|
map.set(item, idx++);
|
|
}
|
|
return map;
|
|
};
|
|
|
|
const getJoinedString = set => {
|
|
set.sort();
|
|
return Array.from(set).join(",");
|
|
};
|
|
|
|
/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */
|
|
|
|
class Module extends DependenciesBlock {
|
|
constructor(type, context = null) {
|
|
super();
|
|
/** @type {string} */
|
|
this.type = type;
|
|
/** @type {string} */
|
|
this.context = context;
|
|
|
|
// Unique Id
|
|
/** @type {number} */
|
|
this.debugId = debugId++;
|
|
|
|
// Hash
|
|
/** @type {string} */
|
|
this.hash = undefined;
|
|
/** @type {string} */
|
|
this.renderedHash = undefined;
|
|
|
|
// Info from Factory
|
|
/** @type {TODO} */
|
|
this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
|
|
/** @type {object} */
|
|
this.factoryMeta = {};
|
|
|
|
// Info from Build
|
|
/** @type {WebpackError[]} */
|
|
this.warnings = [];
|
|
/** @type {WebpackError[]} */
|
|
this.errors = [];
|
|
/** @type {BuildMeta} */
|
|
this.buildMeta = undefined;
|
|
/** @type {object} */
|
|
this.buildInfo = undefined;
|
|
|
|
// Graph (per Compilation)
|
|
/** @type {SortableSet<Chunk>} */
|
|
this._chunks = new SortableSet(undefined, sortById);
|
|
|
|
// Info from Compilation (per Compilation)
|
|
/** @type {number|string} */
|
|
this.id = null;
|
|
/** @type {number} */
|
|
this.index = null;
|
|
/** @type {number} */
|
|
this.index2 = null;
|
|
/** @type {number} */
|
|
this.depth = null;
|
|
/** @type {undefined | object} */
|
|
this.profile = undefined;
|
|
/** @type {boolean} */
|
|
this.prefetched = false;
|
|
/** @type {boolean} */
|
|
this.built = false;
|
|
|
|
/** @type {boolean} */
|
|
this.useSourceMap = false;
|
|
}
|
|
|
|
/**
|
|
* @deprecated moved to .buildInfo.exportsArgument
|
|
* @returns {string} name of the exports argument
|
|
*/
|
|
get exportsArgument() {
|
|
return (this.buildInfo && this.buildInfo.exportsArgument) || "exports";
|
|
}
|
|
|
|
/**
|
|
* @deprecated moved to .buildInfo.moduleArgument
|
|
* @returns {string} name of the module argument
|
|
*/
|
|
get moduleArgument() {
|
|
return (this.buildInfo && this.buildInfo.moduleArgument) || "module";
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {Module | null} the issuer module
|
|
*/
|
|
getIssuer(moduleGraph) {
|
|
const meta = moduleGraph.getMeta(this);
|
|
return meta[issuerSymbol];
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @param {Module | null} issuer the issuer module
|
|
* @returns {void}
|
|
*/
|
|
setIssuer(moduleGraph, issuer) {
|
|
const meta = moduleGraph.getMeta(this);
|
|
meta[issuerSymbol] = issuer;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
|
|
*/
|
|
getOptimizationBailout(moduleGraph) {
|
|
const meta = moduleGraph.getMeta(this);
|
|
const list = meta[optimizationBailoutSymbol];
|
|
if (list === undefined) {
|
|
return (meta[optimizationBailoutSymbol] = []);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {false | true | SortableSet<string> | null} the used exports
|
|
* false: module is not used at all.
|
|
* true: the module namespace/object export is used.
|
|
* SortableSet<string>: these export names are used.
|
|
* empty SortableSet<string>: module is used but no export.
|
|
* null: unknown, worst case should be assumed.
|
|
*/
|
|
getUsedExports(moduleGraph) {
|
|
const value = moduleGraph.getMeta(this)[usedExportsSymbol];
|
|
return value === undefined ? null : value;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @param {false | true | SortableSet<string>} usedExports the used exports
|
|
* @returns {void}
|
|
*/
|
|
setUsedExports(moduleGraph, usedExports) {
|
|
moduleGraph.getMeta(this)[usedExportsSymbol] = usedExports;
|
|
}
|
|
|
|
/**
|
|
* disconnect the module from the graph
|
|
* @returns {void}
|
|
*/
|
|
disconnect() {
|
|
this.hash = undefined;
|
|
this.renderedHash = undefined;
|
|
|
|
this._chunks.clear();
|
|
|
|
this.id = null;
|
|
this.index = null;
|
|
this.index2 = null;
|
|
this.depth = null;
|
|
this.profile = undefined;
|
|
this.prefetched = false;
|
|
this.built = false;
|
|
|
|
super.disconnect();
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
unseal() {
|
|
this.id = null;
|
|
this.index = null;
|
|
this.index2 = null;
|
|
this.depth = null;
|
|
this._chunks.clear();
|
|
super.unseal();
|
|
}
|
|
|
|
/**
|
|
* Sets the chunks to a new value
|
|
* @protected
|
|
* @param {Iterable<Chunk>} chunks the new chunks
|
|
* @returns {void}
|
|
*/
|
|
setChunks(chunks) {
|
|
this._chunks = new SortableSet(chunks, sortById);
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk added chunk
|
|
* @returns {boolean} true, if the chunk could be added
|
|
*/
|
|
addChunk(chunk) {
|
|
if (this._chunks.has(chunk)) return false;
|
|
this._chunks.add(chunk);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk removed chunk
|
|
* @returns {boolean} true, if the chunk could be removed
|
|
*/
|
|
removeChunk(chunk) {
|
|
if (this._chunks.delete(chunk)) {
|
|
chunk.removeModule(this);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk chunk to be tested
|
|
* @returns {boolean} true, if the module is in a chunk
|
|
*/
|
|
isInChunk(chunk) {
|
|
return this._chunks.has(chunk);
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean} true, if the module is entry of any chunk
|
|
*/
|
|
isEntryModule() {
|
|
for (const chunk of this._chunks) {
|
|
if (chunk.entryModule === this) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {boolean} true, if the module is optional
|
|
*/
|
|
isOptional(moduleGraph) {
|
|
const connections = moduleGraph.getIncomingConnections(this);
|
|
return (
|
|
connections.length > 0 &&
|
|
connections.every(r => r.dependency && r.dependency.optional)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @returns {Chunk[]} all chunks which contain the module
|
|
*/
|
|
getChunks() {
|
|
return Array.from(this._chunks);
|
|
}
|
|
|
|
/**
|
|
* @returns {number} the number of chunk which contain the module
|
|
*/
|
|
getNumberOfChunks() {
|
|
return this._chunks.size;
|
|
}
|
|
|
|
/**
|
|
* @returns {Iterable<Chunk>} chunks that contain the module
|
|
*/
|
|
get chunksIterable() {
|
|
return this._chunks;
|
|
}
|
|
|
|
/**
|
|
* @param {Module} otherModule some other module
|
|
* @returns {boolean} true, if modules are in the same chunks
|
|
*/
|
|
hasEqualChunks(otherModule) {
|
|
if (this._chunks.size !== otherModule._chunks.size) return false;
|
|
this._chunks.sortWith(sortByDebugId);
|
|
otherModule._chunks.sortWith(sortByDebugId);
|
|
const a = this._chunks[Symbol.iterator]();
|
|
const b = otherModule._chunks[Symbol.iterator]();
|
|
// eslint-disable-next-line no-constant-condition
|
|
while (true) {
|
|
const aItem = a.next();
|
|
const bItem = b.next();
|
|
if (aItem.done) return true;
|
|
if (aItem.value !== bItem.value) return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk a chunk
|
|
* @param {Chunk=} ignoreChunk chunk to be ignored
|
|
* @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
|
|
*/
|
|
isAccessibleInChunk(chunk, ignoreChunk) {
|
|
// Check if module is accessible in ALL chunk groups
|
|
for (const chunkGroup of chunk.groupsIterable) {
|
|
if (!this.isAccessibleInChunkGroup(chunkGroup)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {ChunkGroup} chunkGroup a chunk group
|
|
* @param {Chunk=} ignoreChunk chunk to be ignored
|
|
* @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
|
|
*/
|
|
isAccessibleInChunkGroup(chunkGroup, ignoreChunk) {
|
|
const queue = new Set([chunkGroup]);
|
|
|
|
// Check if module is accessible from all items of the queue
|
|
queueFor: for (const cg of queue) {
|
|
// 1. If module is in one of the chunks of the group we can continue checking the next items
|
|
// because it's accessible.
|
|
for (const chunk of cg.chunks) {
|
|
if (chunk !== ignoreChunk && chunk.containsModule(this))
|
|
continue queueFor;
|
|
}
|
|
// 2. If the chunk group is initial, we can break here because it's not accessible.
|
|
if (chunkGroup.isInitial()) return false;
|
|
// 3. Enqueue all parents because it must be accessible from ALL parents
|
|
for (const parent of chunkGroup.parentsIterable) queue.add(parent);
|
|
}
|
|
// When we processed through the whole list and we didn't bailout, the module is accessible
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk a chunk
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {boolean} true, if the module has any reason why "chunk" should be included
|
|
*/
|
|
hasReasonForChunk(chunk, moduleGraph) {
|
|
// check for each reason if we need the chunk
|
|
for (const connection of moduleGraph.getIncomingConnections(this)) {
|
|
const fromModule = connection.originModule;
|
|
for (const originChunk of fromModule.chunksIterable) {
|
|
// return true if module this is not reachable from originChunk when ignoring cunk
|
|
if (!this.isAccessibleInChunk(originChunk, chunk)) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {boolean} true if at least one other module depends on this module
|
|
*/
|
|
hasReasons(moduleGraph) {
|
|
return moduleGraph.getIncomingConnections(this).length > 0;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @returns {boolean} true, if the module is used
|
|
*/
|
|
isModuleUsed(moduleGraph) {
|
|
return this.getUsedExports(moduleGraph) !== false;
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @param {string} exportName a name of an export
|
|
* @returns {boolean} true, if the export is used
|
|
*/
|
|
isExportUsed(moduleGraph, exportName) {
|
|
const usedExports = this.getUsedExports(moduleGraph);
|
|
if (usedExports === null || usedExports === true) return true;
|
|
if (usedExports === false) return false;
|
|
return usedExports.has(exportName);
|
|
}
|
|
|
|
/**
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
* @param {string} exportName a name of an export
|
|
* @returns {string | false} false, when module or referenced export is unused.
|
|
* string, the mangled export name when used.
|
|
*/
|
|
getUsedName(moduleGraph, exportName) {
|
|
const usedExports = this.getUsedExports(moduleGraph);
|
|
if (usedExports === null || usedExports === true) return exportName;
|
|
if (usedExports === false) return false;
|
|
if (!usedExports.has(exportName)) return false;
|
|
|
|
// Mangle export name if possible
|
|
if (this.isProvided(exportName)) {
|
|
if (this.buildMeta.exportsType === "namespace") {
|
|
const idx = usedExports
|
|
.getFromUnorderedCache(getIndexMap)
|
|
.get(exportName);
|
|
return Template.numberToIdentifer(idx);
|
|
}
|
|
if (
|
|
this.buildMeta.exportsType === "named" &&
|
|
!usedExports.has("default")
|
|
) {
|
|
const idx = usedExports
|
|
.getFromUnorderedCache(getIndexMap)
|
|
.get(exportName);
|
|
return Template.numberToIdentifer(idx);
|
|
}
|
|
}
|
|
return exportName;
|
|
}
|
|
|
|
/**
|
|
* @param {string} exportName a name of an export
|
|
* @returns {boolean | null} true, if the export is provided why the module.
|
|
* null, if it's unknown.
|
|
* false, if it's not provided.
|
|
*/
|
|
isProvided(exportName) {
|
|
if (!Array.isArray(this.buildMeta.providedExports)) return null;
|
|
return this.buildMeta.providedExports.includes(exportName);
|
|
}
|
|
|
|
/**
|
|
* @returns {string} for debugging
|
|
*/
|
|
toString() {
|
|
return `Module[${this.id || this.debugId}]`;
|
|
}
|
|
|
|
/**
|
|
* @param {TODO} fileTimestamps timestamps of files
|
|
* @param {TODO} contextTimestamps timestamps of directories
|
|
* @returns {boolean} true, if the module needs a rebuild
|
|
*/
|
|
needRebuild(fileTimestamps, contextTimestamps) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {Hash} hash the hash used to track dependencies
|
|
* @param {Compilation} compilation the compilation
|
|
* @returns {void}
|
|
*/
|
|
updateHash(hash, compilation) {
|
|
hash.update(`${this.id}`);
|
|
const usedExports = this.getUsedExports(compilation.moduleGraph);
|
|
if (typeof usedExports === "boolean") {
|
|
hash.update(JSON.stringify(usedExports));
|
|
} else if (!usedExports) {
|
|
hash.update("null");
|
|
} else {
|
|
hash.update(usedExports.getFromUnorderedCache(getJoinedString));
|
|
}
|
|
super.updateHash(hash, compilation);
|
|
}
|
|
|
|
/**
|
|
* Sorts items in this module
|
|
* @param {boolean=} sortChunks sort the chunks too
|
|
* @returns {void}
|
|
*/
|
|
sortItems(sortChunks) {
|
|
super.sortItems();
|
|
if (sortChunks) this._chunks.sort();
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
unbuild() {
|
|
this.dependencies.length = 0;
|
|
this.blocks.length = 0;
|
|
this.buildMeta = undefined;
|
|
this.buildInfo = undefined;
|
|
this.disconnect();
|
|
}
|
|
|
|
/**
|
|
* @abstract
|
|
* @returns {string} a unique identifier of the module
|
|
*/
|
|
identifier() {
|
|
throw new Error("Module.identifier: Must be overriden");
|
|
}
|
|
|
|
/**
|
|
* @abstract
|
|
* @param {RequestShortener} requestShortener the request shortener
|
|
* @returns {string} a user readable identifier of the module
|
|
*/
|
|
readableIdentifier(requestShortener) {
|
|
throw new Error("Module.readableIdentifier: Must be overriden");
|
|
}
|
|
|
|
/**
|
|
* @abstract
|
|
* @param {TODO} options TODO
|
|
* @param {Compilation} compilation the compilation
|
|
* @param {TODO} resolver TODO
|
|
* @param {TODO} fs the file system
|
|
* @param {function(Error=): void} callback callback function
|
|
* @returns {void}
|
|
*/
|
|
build(options, compilation, resolver, fs, callback) {
|
|
throw new Error("Module.build: Must be overriden");
|
|
}
|
|
|
|
/**
|
|
* @abstract
|
|
* @param {SourceContext} sourceContext source context
|
|
* @returns {Source} generated source
|
|
*/
|
|
source(sourceContext) {
|
|
throw new Error("Module.source: Must be overriden");
|
|
}
|
|
|
|
/**
|
|
* @abstract
|
|
* @returns {number} the estimated size of the module
|
|
*/
|
|
size() {
|
|
throw new Error("Module.size: Must be overriden");
|
|
}
|
|
|
|
/**
|
|
* @param {LibIdentOptions} options options
|
|
* @returns {string | null} an identifier for library inclusion
|
|
*/
|
|
libIdent(options) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
|
|
*/
|
|
nameForCondition() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} chunk the chunk which condition should be checked
|
|
* @returns {boolean} true, if the chunk is ok for the module
|
|
*/
|
|
chunkCondition(chunk) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Assuming this module is in the cache. Update the (cached) module with
|
|
* the fresh module from the factory. Usually updates internal references
|
|
* and properties.
|
|
* @param {Module} module fresh module
|
|
* @returns {void}
|
|
*/
|
|
updateCacheModule(module) {
|
|
// do nothing
|
|
// this method can be overriden
|
|
}
|
|
|
|
/**
|
|
* @returns {Source | null} the original source for the module before webpack transformation
|
|
*/
|
|
originalSource() {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(Module.prototype, "hasEqualsChunks", {
|
|
get() {
|
|
throw new Error(
|
|
"Module.hasEqualsChunks was renamed (use hasEqualChunks instead)"
|
|
);
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(Module.prototype, "isUsed", {
|
|
get() {
|
|
throw new Error(
|
|
"Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)"
|
|
);
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(Module.prototype, "used", {
|
|
get() {
|
|
throw new Error("Module.used was refactored (use getUsedExports instead)");
|
|
},
|
|
set(value) {
|
|
throw new Error("Module.used was refactored (use setUsedExports instead)");
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(Module.prototype, "usedExports", {
|
|
get() {
|
|
throw new Error(
|
|
"Module.usedExports was refactored (use getUsedExports instead)"
|
|
);
|
|
},
|
|
set(value) {
|
|
throw new Error(
|
|
"Module.usedExports was refactored (use setUsedExports instead)"
|
|
);
|
|
}
|
|
});
|
|
|
|
module.exports = Module;
|