webpack
Version:
Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
345 lines (332 loc) • 11.7 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
;
const WebpackError = require("../../errors/WebpackError");
const CompatibilityPlugin = require("../../javascript/CompatibilityPlugin");
const { getImportAttributes } = require("../../javascript/JavascriptParser");
const { CONST_BINDING_TAG } = require("../../optimize/ConstExportsPlugin");
const { toInlinedValue } = require("../../optimize/InlineExports");
const { getInnerGraphUtils } = require("../../optimize/InnerGraph");
const ConstDependency = require("../core/ConstDependency");
const {
ImportPhaseUtils,
createGetImportPhase
} = require("../core/ImportPhase");
const ESMExportExpressionDependency = require("./ESMExportExpressionDependency");
const ESMExportHeaderDependency = require("./ESMExportHeaderDependency");
const ESMExportImportedSideEffectDependency = require("./ESMExportImportedSideEffectDependency");
const ESMExportImportedSpecifierDependency = require("./ESMExportImportedSpecifierDependency");
const ESMExportSpecifierDependency = require("./ESMExportSpecifierDependency");
const { ExportPresenceModes } = require("./ESMImportDependency");
const { harmonySpecifierTag } = require("./ESMImportDependencyParserPlugin");
/**
* @import {
* Expression,
* ClassDeclaration,
* FunctionDeclaration
* } from "estree"
*/
/**
* @import {
* JavascriptParserOptions
* } from "../../../declarations/WebpackOptions"
*/
/** @import JavascriptParser, { Range } from "../../javascript/JavascriptParser" */
/** @import { ESMSettings } from "./ESMImportDependencyParserPlugin" */
/** @import { CompatibilitySettings } from "../../javascript/CompatibilityPlugin" */
const { ESMStarExportsList } = ESMExportImportedSpecifierDependency;
const PLUGIN_NAME = "ESMExportDependencyParserPlugin";
module.exports = class ESMExportDependencyParserPlugin {
/**
* Creates an instance of ESMExportDependencyParserPlugin.
* @param {JavascriptParserOptions} options options
*/
constructor(options) {
/** @type {JavascriptParserOptions} */
this.options = options;
this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
options.reexportExportsPresence,
options
);
}
/**
* Applies the plugin by registering its hooks on the compiler.
* @param {JavascriptParser} parser the parser
* @returns {void}
*/
apply(parser) {
const { exportPresenceMode } = this;
const getImportPhase = createGetImportPhase(
this.options.deferImport,
false
);
parser.hooks.export.tap(PLUGIN_NAME, (statement) => {
const dep = new ESMExportHeaderDependency(
statement.declaration && statement.declaration.range,
/** @type {Range} */ (statement.range)
);
dep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.module.addPresentationalDependency(dep);
return true;
});
parser.hooks.exportImport.tap(PLUGIN_NAME, (statement, source) => {
parser.state.lastESMImportOrder =
(parser.state.lastESMImportOrder || 0) + 1;
const clearDep = new ConstDependency(
"",
/** @type {Range} */ (statement.range)
);
clearDep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.module.addPresentationalDependency(clearDep);
const phase = getImportPhase(parser, statement);
if (phase && ImportPhaseUtils.isDefer(phase)) {
const error = new WebpackError(
"Deferred re-export (`export defer * as namespace from '...'`) is not a part of the Import Defer proposal.\nUse the following code instead:\n import defer * as namespace from '...';\n export { namespace };"
);
error.loc = parser.getLocation(statement) || undefined;
parser.state.current.addError(error);
}
const sideEffectDep = new ESMExportImportedSideEffectDependency(
/** @type {string} */ (source),
parser.state.lastESMImportOrder,
phase,
getImportAttributes(statement)
);
sideEffectDep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.current.addDependency(sideEffectDep);
return true;
});
// `export default <namespace binding>` is the same export as
// `export { ns as default }`, so it becomes the same re-export. Stage -10
// beats the inner-graph tap, whose guard would outlive the removed statement.
parser.hooks.statement.tap(
{ name: PLUGIN_NAME, stage: -10 },
(statement) => {
if (
statement.type !== "ExportDefaultDeclaration" ||
statement.declaration.type !== "Identifier"
) {
return;
}
const name = statement.declaration.name;
const settings =
/** @type {ESMSettings | undefined} */
(parser.getTagData(name, harmonySpecifierTag));
if (!settings || settings.ids.length !== 0) return;
settings.used = true;
if (ImportPhaseUtils.isDefer(settings.phase)) return;
const esmNamedExports = (parser.state.esmNamedExports =
parser.state.esmNamedExports || new Set());
esmNamedExports.add("default");
getInnerGraphUtils(parser.state.compilation).addVariableUsage(
parser,
name,
"default"
);
const dep = new ESMExportImportedSpecifierDependency(
settings.source,
settings.sourceOrder,
settings.ids,
"default",
esmNamedExports,
null,
exportPresenceMode,
null,
settings.phase,
settings.attributes
);
dep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.current.addDependency(dep);
// no range erases the whole statement, as for `export { ns as default }`
const headerDep = new ESMExportHeaderDependency(
undefined,
/** @type {Range} */ (statement.range)
);
headerDep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.module.addPresentationalDependency(headerDep);
return true;
}
);
parser.hooks.exportExpression.tap(PLUGIN_NAME, (statement, node) => {
const isFunctionDeclaration = node.type === "FunctionDeclaration";
const exprRange = /** @type {Range} */ (node.range);
const statementRange = /** @type {Range} */ (statement.range);
const comments = parser.getComments([statementRange[0], exprRange[0]]);
const constValue = node.type.endsWith("Declaration")
? undefined
: toInlinedValue(
parser.evaluateExpression(/** @type {Expression} */ (node))
);
const dep = new ESMExportExpressionDependency(
exprRange,
statementRange,
comments
.map((c) => {
switch (c.type) {
case "Block":
return `/*${c.value}*/`;
case "Line":
return `//${c.value}\n`;
}
return "";
})
.join(""),
node.type.endsWith("Declaration") &&
/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
? /** @type {FunctionDeclaration | ClassDeclaration} */
(node).id.name
: isFunctionDeclaration
? {
range: [
exprRange[0],
node.params.length > 0
? /** @type {Range} */ (node.params[0].range)[0]
: /** @type {Range} */ (node.body.range)[0]
],
prefix: `${node.async ? "async " : ""}function${
node.generator ? "*" : ""
} `,
suffix: `(${node.params.length > 0 ? "" : ") "}`
}
: undefined,
constValue
);
const isAnonymousClass =
(node.type === "ClassDeclaration" || node.type === "ClassExpression") &&
!node.id;
dep.isAnonymousDefault =
this.options.anonymousDefaultExportName !== false &&
(node.type === "ArrowFunctionExpression" ||
isAnonymousClass ||
((node.type === "FunctionDeclaration" ||
node.type === "FunctionExpression") &&
!node.id));
// A class observes its own name from a static initializer, which runs
// before the name could be patched afterwards, so it is named in place.
dep.isAnonymousDefaultClass = dep.isAnonymousDefault && isAnonymousClass;
dep.setLocWithIndex(parser.getLocation(statement), -1);
parser.state.current.addDependency(dep);
getInnerGraphUtils(parser.state.compilation).addVariableUsage(
parser,
node.type.endsWith("Declaration") &&
/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
? /** @type {FunctionDeclaration | ClassDeclaration} */ (node).id.name
: "*default*",
"default"
);
return true;
});
parser.hooks.exportSpecifier.tap(
PLUGIN_NAME,
(statement, id, name, idx) => {
// CompatibilityPlugin may change exports name
// not handle re-export or import then export situation as current CompatibilityPlugin only
// rename symbol in declaration module, not change exported symbol
const variable = parser.getTagData(
id,
CompatibilityPlugin.nestedWebpackIdentifierTag
);
if (variable && /** @type {CompatibilitySettings} */ (variable).name) {
// CompatibilityPlugin changes exports to a new name, should updates exports name
id = /** @type {CompatibilitySettings} */ (variable).name;
}
const settings =
/** @type {ESMSettings} */
(parser.getTagData(id, harmonySpecifierTag));
if (settings) settings.used = true;
const esmNamedExports = (parser.state.esmNamedExports =
parser.state.esmNamedExports || new Set());
esmNamedExports.add(name);
getInnerGraphUtils(parser.state.compilation).addVariableUsage(
parser,
id,
name
);
const tagData = settings
? undefined
: /** @type {{ value?: import("../../optimize/InlineExports").InlinedValue } | undefined} */
(parser.getTagData(id, CONST_BINDING_TAG));
const dep = settings
? new ESMExportImportedSpecifierDependency(
settings.source,
settings.sourceOrder,
settings.ids,
name,
esmNamedExports,
null,
exportPresenceMode,
null,
settings.phase,
settings.attributes
)
: new ESMExportSpecifierDependency(
id,
name,
tagData ? tagData.value || null : undefined
);
dep.setLocWithIndex(
parser.getLocation(statement),
/** @type {number} */ (idx)
);
const isAsiSafe = !parser.isAsiPosition(
/** @type {Range} */
(statement.range)[0]
);
if (!isAsiSafe) {
parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
}
parser.state.current.addDependency(dep);
return true;
}
);
parser.hooks.exportImportSpecifier.tap(
PLUGIN_NAME,
(statement, source, id, name, idx) => {
const esmNamedExports = (parser.state.esmNamedExports =
parser.state.esmNamedExports || new Set());
/** @type {InstanceType<ESMStarExportsList> | null} */
let esmStarExports = null;
if (name) {
esmNamedExports.add(name);
} else {
esmStarExports = parser.state.esmStarExports =
parser.state.esmStarExports || new ESMStarExportsList();
}
const attributes = getImportAttributes(statement);
const dep = new ESMExportImportedSpecifierDependency(
/** @type {string} */
(source),
/** @type {number} */
(parser.state.lastESMImportOrder),
id ? [id] : [],
name,
esmNamedExports,
// eslint-disable-next-line unicorn/prefer-spread
esmStarExports && esmStarExports.slice(),
exportPresenceMode,
esmStarExports,
getImportPhase(parser, statement),
attributes
);
if (esmStarExports) {
esmStarExports.push(dep);
}
dep.setLocWithIndex(
parser.getLocation(statement),
/** @type {number} */ (idx)
);
const isAsiSafe = !parser.isAsiPosition(
/** @type {Range} */
(statement.range)[0]
);
if (!isAsiSafe) {
parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
}
parser.state.current.addDependency(dep);
return true;
}
);
}
};