webpack
Version:
Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
352 lines (325 loc) • 11.3 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
;
const { ConcatSource } = require("webpack-sources");
const { UsageState } = require("../ExportsInfo");
const Template = require("../Template");
const propertyAccess = require("../util/propertyAccess");
const { getEntryRuntime } = require("../util/runtime");
const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
/** @typedef {import("webpack-sources").Source} Source */
/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
/** @typedef {import("../Chunk")} Chunk */
/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
/** @typedef {import("../Compiler")} Compiler */
/** @typedef {import("../Module")} Module */
/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
/** @typedef {import("../util/Hash")} Hash */
/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
const KEYWORD_REGEX =
/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
const IDENTIFIER_REGEX =
/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
/**
* Validates the library name by checking for keywords and valid characters
* @param {string} name name to be validated
* @returns {boolean} true, when valid
*/
const isNameValid = name => {
return !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
};
/**
* @param {string[]} accessor variable plus properties
* @param {number} existingLength items of accessor that are existing already
* @param {boolean=} initLast if the last property should also be initialized to an object
* @returns {string} code to access the accessor while initializing
*/
const accessWithInit = (accessor, existingLength, initLast = false) => {
// This generates for [a, b, c, d]:
// (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
const base = accessor[0];
if (accessor.length === 1 && !initLast) return base;
let current =
existingLength > 0
? base
: `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
// i is the current position in accessor that has been printed
let i = 1;
// all properties printed so far (excluding base)
let propsSoFar;
// if there is existingLength, print all properties until this position as property access
if (existingLength > i) {
propsSoFar = accessor.slice(1, existingLength);
i = existingLength;
current += propertyAccess(propsSoFar);
} else {
propsSoFar = [];
}
// all remaining properties (except the last one when initLast is not set)
// should be printed as initializer
const initUntil = initLast ? accessor.length : accessor.length - 1;
for (; i < initUntil; i++) {
const prop = accessor[i];
propsSoFar.push(prop);
current = `(${current}${propertyAccess([prop])} = ${base}${propertyAccess(
propsSoFar
)} || {})`;
}
// print the last property as property access if not yet printed
if (i < accessor.length)
current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
return current;
};
/**
* @typedef {Object} AssignLibraryPluginOptions
* @property {LibraryType} type
* @property {string[] | "global"} prefix name prefix
* @property {string | false} declare declare name as variable
* @property {"error"|"copy"|"assign"} unnamed behavior for unnamed library name
* @property {"copy"|"assign"=} named behavior for named library name
*/
/**
* @typedef {Object} AssignLibraryPluginParsed
* @property {string | string[]} name
* @property {string | string[] | undefined} export
*/
/**
* @typedef {AssignLibraryPluginParsed} T
* @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
*/
class AssignLibraryPlugin extends AbstractLibraryPlugin {
/**
* @param {AssignLibraryPluginOptions} options the plugin options
*/
constructor(options) {
super({
pluginName: "AssignLibraryPlugin",
type: options.type
});
this.prefix = options.prefix;
this.declare = options.declare;
this.unnamed = options.unnamed;
this.named = options.named || "assign";
}
/**
* @param {LibraryOptions} library normalized library option
* @returns {T | false} preprocess as needed by overriding
*/
parseOptions(library) {
const { name } = library;
if (this.unnamed === "error") {
if (typeof name !== "string" && !Array.isArray(name)) {
throw new Error(
`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
);
}
} else {
if (name && typeof name !== "string" && !Array.isArray(name)) {
throw new Error(
`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
);
}
}
return {
name: /** @type {string|string[]=} */ (name),
export: library.export
};
}
/**
* @param {Module} module the exporting entry module
* @param {string} entryName the name of the entrypoint
* @param {LibraryContext<T>} libraryContext context
* @returns {void}
*/
finishEntryModule(
module,
entryName,
{ options, compilation, compilation: { moduleGraph } }
) {
const runtime = getEntryRuntime(compilation, entryName);
if (options.export) {
const exportsInfo = moduleGraph.getExportInfo(
module,
Array.isArray(options.export) ? options.export[0] : options.export
);
exportsInfo.setUsed(UsageState.Used, runtime);
exportsInfo.canMangleUse = false;
} else {
const exportsInfo = moduleGraph.getExportsInfo(module);
exportsInfo.setUsedInUnknownWay(runtime);
}
moduleGraph.addExtraReason(module, "used as library export");
}
_getPrefix(compilation) {
return this.prefix === "global"
? [compilation.outputOptions.globalObject]
: this.prefix;
}
_getResolvedFullName(options, chunk, compilation) {
const prefix = this._getPrefix(compilation);
const fullName = options.name ? prefix.concat(options.name) : prefix;
return fullName.map(n =>
compilation.getPath(n, {
chunk
})
);
}
/**
* @param {Source} source source
* @param {RenderContext} renderContext render context
* @param {LibraryContext<T>} libraryContext context
* @returns {Source} source with library export
*/
render(source, { chunk }, { options, compilation }) {
const fullNameResolved = this._getResolvedFullName(
options,
chunk,
compilation
);
if (this.declare) {
const base = fullNameResolved[0];
if (!isNameValid(base)) {
throw new Error(
`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
base
)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
}`
);
}
source = new ConcatSource(`${this.declare} ${base};\n`, source);
}
return source;
}
/**
* @param {Module} module the exporting entry module
* @param {RenderContext} renderContext render context
* @param {LibraryContext<T>} libraryContext context
* @returns {string | undefined} bailout reason
*/
embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
const topLevelDeclarations =
module.buildInfo && module.buildInfo.topLevelDeclarations;
if (!topLevelDeclarations)
return "it doesn't tell about top level declarations.";
const fullNameResolved = this._getResolvedFullName(
options,
chunk,
compilation
);
const base = fullNameResolved[0];
if (topLevelDeclarations.has(base))
return `it declares '${base}' on top-level, which conflicts with the current library output.`;
}
/**
* @param {RenderContext} renderContext render context
* @param {LibraryContext<T>} libraryContext context
* @returns {string | undefined} bailout reason
*/
strictRuntimeBailout({ chunk }, { options, compilation }) {
if (
this.declare ||
this.prefix === "global" ||
this.prefix.length > 0 ||
!options.name
) {
return;
}
return "a global variable is assign and maybe created";
}
/**
* @param {Source} source source
* @param {Module} module module
* @param {StartupRenderContext} renderContext render context
* @param {LibraryContext<T>} libraryContext context
* @returns {Source} source with library export
*/
renderStartup(source, module, { chunk }, { options, compilation }) {
const fullNameResolved = this._getResolvedFullName(
options,
chunk,
compilation
);
const exportAccess = options.export
? propertyAccess(
Array.isArray(options.export) ? options.export : [options.export]
)
: "";
const result = new ConcatSource(source);
if (options.name ? this.named === "copy" : this.unnamed === "copy") {
result.add(
`var __webpack_export_target__ = ${accessWithInit(
fullNameResolved,
this._getPrefix(compilation).length,
true
)};\n`
);
let exports = "__webpack_exports__";
if (exportAccess) {
result.add(
`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
);
exports = "__webpack_exports_export__";
}
result.add(
`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
);
result.add(
`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
);
} else {
result.add(
`${accessWithInit(
fullNameResolved,
this._getPrefix(compilation).length,
false
)} = __webpack_exports__${exportAccess};\n`
);
}
return result;
}
/**
* @param {Chunk} chunk the chunk
* @param {Set<string>} set runtime requirements
* @param {LibraryContext<T>} libraryContext context
* @returns {void}
*/
runtimeRequirements(chunk, set, libraryContext) {
// we don't need to return exports from runtime
}
/**
* @param {Chunk} chunk the chunk
* @param {Hash} hash hash
* @param {ChunkHashContext} chunkHashContext chunk hash context
* @param {LibraryContext<T>} libraryContext context
* @returns {void}
*/
chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
hash.update("AssignLibraryPlugin");
const prefix =
this.prefix === "global"
? [compilation.outputOptions.globalObject]
: this.prefix;
const fullName = options.name ? prefix.concat(options.name) : prefix;
const fullNameResolved = fullName.map(n =>
compilation.getPath(n, {
chunk
})
);
if (options.name ? this.named === "copy" : this.unnamed === "copy") {
hash.update("copy");
}
if (this.declare) {
hash.update(this.declare);
}
hash.update(fullNameResolved.join("."));
if (options.export) {
hash.update(`${options.export}`);
}
}
}
module.exports = AssignLibraryPlugin;