webpack/lib/dependencies/esm/ESMExportExpressionDependency.js

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.

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const Dependency = require("../../graph/Dependency");
const ConcatenationScope = require("../../optimize/ConcatenationScope");
const { isInlinedUsedName } = require("../../optimize/InlineExports");
const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
const InitFragment = require("../../template/InitFragment");
const makeSerializable = require("../../util/makeSerializable");
const { propertyAccess } = require("../../util/property");

const NullDependency = require("../core/NullDependency");
const ESMExportInitFragment = require("./ESMExportInitFragment");

const { ExportBindingType } = ESMExportInitFragment;

const DEFAULT_EXPORT_NAME = "default";

/** @import { ReplaceSource } from "webpack-sources" */
/** @import { ExportsSpec, LazyRole, UpdateHashContext } from "../../graph/Dependency" */
/** @import Module, { BuildInfo } from "../../module/Module" */
/** @import Hash from "../../util/Hash" */
/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
/** @import ModuleGraph from "../../graph/ModuleGraph" */
/** @import { ConnectionState } from "../../graph/ModuleGraphConnection" */
/** @import { InlinedValue } from "../../optimize/InlineExports" */
/** @import { Range } from "../../javascript/JavascriptParser" */
/** @typedef {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }} DeclarationId */
/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean, InlinedValue | undefined]>} ObjectDeserializerContext */
/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean, InlinedValue | undefined]>} ObjectSerializerContext */
/** @import { ExportMap } from "./ESMExportInitFragment" */
/**
 * @import {
 * 	JavascriptModuleBuildInfo
 * } from "../../javascript/JavascriptModule"
 */

class ESMExportExpressionDependency extends NullDependency {
	/**
	 * Creates an instance of ESMExportExpressionDependency.
	 * @param {Range} range range
	 * @param {Range} rangeStatement range statement
	 * @param {string} prefix prefix
	 * @param {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }=} declarationId declaration id
	 * @param {InlinedValue=} constValue inlined primitive when `export default <const>` is inline-eligible
	 */
	constructor(range, rangeStatement, prefix, declarationId, constValue) {
		super();
		this.range = range;
		this.rangeStatement = rangeStatement;
		/** @type {string} */
		this.prefix = prefix;
		this.declarationId = declarationId;
		this.constValue = constValue;
		/** @type {boolean} */
		this.isAnonymousDefault = false;
		/** @type {boolean} */
		this.isAnonymousDefaultClass = false;
	}

	get type() {
		return "harmony export expression";
	}

	/**
	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
	 * @returns {LazyRole | null} lazy classification, null when it must be processed eagerly
	 */
	get lazyRole() {
		return Dependency.LAZY_LOCAL_EXPORT;
	}

	/**
	 * Returns the export name for a `LAZY_LOCAL_EXPORT`/`LAZY_NAMED_REEXPORT` classification (lazy barrel optimization).
	 * @returns {string | null} export name, null when not applicable
	 */
	get lazyName() {
		return DEFAULT_EXPORT_NAME;
	}

	/**
	 * Returns the exported names
	 * @param {ModuleGraph} moduleGraph module graph
	 * @returns {ExportsSpec | undefined} export names
	 */
	getExports(moduleGraph) {
		const module = moduleGraph.getParentModule(this);
		const pureFunctions =
			module &&
			module.buildInfo &&
			/** @type {JavascriptModuleBuildInfo} */ (module.buildInfo).pureFunctions;
		const isPure = Boolean(
			pureFunctions && pureFunctions.has(DEFAULT_EXPORT_NAME)
		);

		return {
			exports: [
				{
					name: DEFAULT_EXPORT_NAME,
					isPure: isPure || undefined,
					inlined: this.constValue
				}
			],
			priority: 1,
			terminalBinding: true,
			dependencies: undefined
		};
	}

	/**
	 * Gets module evaluation side effects state.
	 * @param {ModuleGraph} moduleGraph the module graph
	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
	 */
	getModuleEvaluationSideEffectsState(moduleGraph) {
		// The expression/declaration is already covered by SideEffectsFlagPlugin
		return false;
	}

	/**
	 * Updates the hash with the data contributed by this instance.
	 * @param {Hash} hash hash to be updated
	 * @param {UpdateHashContext} context context
	 * @returns {void}
	 */
	updateHash(hash, context) {
		// the module's cycles, known only after it is built, pick value or getter
		const module = /** @type {Module} */ (
			context.chunkGraph.moduleGraph.getParentModule(this)
		);
		hash.update(
			/** @type {BuildInfo} */ (module.buildInfo).isCircular === false
				? "value"
				: "getter"
		);
	}

	/**
	 * Serializes this instance into the provided serializer context.
	 * @param {ObjectSerializerContext} context context
	 */
	serialize(context) {
		context
			.write(this.range)
			.write(this.rangeStatement)
			.write(this.prefix)
			.write(this.declarationId)
			.write(this.isAnonymousDefault)
			.write(this.isAnonymousDefaultClass)
			.write(this.constValue);
		super.serialize(context);
	}

	/**
	 * Restores this instance from the provided deserializer context.
	 * @param {ObjectDeserializerContext} context context
	 */
	deserialize(context) {
		this.range = context.read();
		const c1 = context.rest;
		this.rangeStatement = c1.read();
		const c2 = c1.rest;
		this.prefix = c2.read();
		const c3 = c2.rest;
		this.declarationId = c3.read();
		const c4 = c3.rest;
		this.isAnonymousDefault = c4.read();
		const c5 = c4.rest;
		this.isAnonymousDefaultClass = c5.read();
		const c6 = c5.rest;
		this.constValue = c6.read();
		super.deserialize(c6.rest);
	}
}

makeSerializable(ESMExportExpressionDependency, [
	"webpack/lib/dependencies/esm/ESMExportExpressionDependency",
	// TODO in the next major release: remove, it restores the packs written
	// under the name the file had before the ESM rename
	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
]);

ESMExportExpressionDependency.Template = class ESMExportDependencyTemplate extends (
	NullDependency.Template
) {
	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 * @param {Dependency} dependency the dependency for which the template should be applied
	 * @param {ReplaceSource} source the current replace source which can be modified
	 * @param {DependencyTemplateContext} templateContext the context object
	 * @returns {void}
	 */
	apply(dependency, source, templateContext) {
		const {
			module,
			moduleGraph,
			runtimeTemplate,
			runtimeRequirements,
			initFragments,
			runtime
		} = templateContext;
		// a wrapped module's default binding is unreachable from the shared scope
		const concatenationScope =
			templateContext.concatenationScope &&
			!templateContext.concatenationScope.isWrapped()
				? templateContext.concatenationScope
				: undefined;
		const dep = /** @type {ESMExportExpressionDependency} */ (dependency);
		const { declarationId } = dep;
		const exportsName = module.exportsArgument;
		const meta = moduleGraph.getMetaIfExisting(module);

		const onDemand =
			!concatenationScope &&
			meta !== undefined &&
			meta.onDemandExports === true;

		if (declarationId) {
			/** @type {string} */
			let name;
			if (typeof declarationId === "string") {
				name = declarationId;
			} else {
				name = ConcatenationScope.DEFAULT_EXPORT;
				source.replace(
					declarationId.range[0],
					declarationId.range[1] - 1,
					`${declarationId.prefix}${name}${declarationId.suffix}`
				);
			}

			const used = concatenationScope
				? undefined
				: moduleGraph
						.getExportsInfo(module)
						.getUsedName(DEFAULT_EXPORT_NAME, runtime);

			if (concatenationScope) {
				concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
			} else if (used) {
				/** @type {ExportMap} */
				const map = new Map();
				map.set(used, {
					value: `/* export default binding */ ${name}`,
					type: ExportBindingType.Getter,
					finalName: name
				});
				initFragments.push(
					new ESMExportInitFragment(exportsName, map, undefined, onDemand)
				);
			}

			source.replace(
				dep.rangeStatement[0],
				dep.range[0] - 1,
				`/* harmony default export */ ${dep.prefix}`
			);

			if (
				typeof declarationId !== "string" &&
				dep.isAnonymousDefault &&
				(concatenationScope || used)
			) {
				// Fix .name for anonymous default export function declarations
				// see test/external/test262-cases/test/language/module-code/instn-named-bndng-dflt-fun-anon.js cspell:disable-line
				runtimeRequirements.add(RuntimeGlobals.setAnonymousDefaultName);
				initFragments.push(
					new InitFragment(
						`${RuntimeGlobals.setAnonymousDefaultName}(${name});\n`,
						InitFragment.STAGE_ESM_EXPORTS,
						2
					)
				);
			}
		} else {
			/** @type {string} */
			let content;
			let name = ConcatenationScope.DEFAULT_EXPORT;
			let defaultIsUsed = Boolean(concatenationScope);
			if (runtimeTemplate.supportsConst()) {
				content = `/* harmony default export */ const ${name} = `;
				if (concatenationScope) {
					concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
				} else {
					const used = moduleGraph
						.getExportsInfo(module)
						.getUsedName(DEFAULT_EXPORT_NAME, runtime);
					if (isInlinedUsedName(used)) {
						content = `/* inlined harmony default export */ const ${name} = `;
					} else if (used) {
						defaultIsUsed = true;
						runtimeRequirements.add(RuntimeGlobals.exports);
						// `export default <expr>` binds an immutable const declaration
						const valueFormat =
							/** @type {import("../../module/Module").BuildInfo} */ (
								module.buildInfo
							).isCircular === false;

						/** @type {ExportMap} */
						const map = new Map();
						map.set(used, {
							value: name,
							type: valueFormat
								? ExportBindingType.Value
								: ExportBindingType.Getter,
							finalName: name
						});
						initFragments.push(
							new ESMExportInitFragment(exportsName, map, undefined, onDemand)
						);
					} else {
						content = `/* unused harmony default export */ var ${name} = `;
					}
				}
			} else if (concatenationScope) {
				content = `/* harmony default export */ var ${name} = `;
				concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
			} else {
				const used = moduleGraph
					.getExportsInfo(module)
					.getUsedName(DEFAULT_EXPORT_NAME, runtime);
				if (isInlinedUsedName(used)) {
					content = `/* inlined harmony default export */ var ${name} = `;
				} else if (used) {
					defaultIsUsed = true;
					runtimeRequirements.add(RuntimeGlobals.exports);
					// The TDZ is not reproduced here, `const` being unavailable. No local
					// binding is created either, so the anonymous-default `.name` fix-up
					// below names the assignment target instead. See issue #20793.
					name = `${exportsName}${propertyAccess(
						typeof used === "string" ? [used] : used
					)}`;
					content = `/* harmony default export */ ${name} = `;
				} else {
					content = `/* unused harmony default export */ var ${name} = `;
				}
			}

			if (dep.range) {
				// `export default class {}` names the class "default", and a static
				// initializer reads that name before any later fix-up could run, so
				// the class is created as a property of that name instead.
				if (dep.isAnonymousDefaultClass) {
					source.replace(
						dep.rangeStatement[0],
						dep.range[0] - 1,
						`${content}{ ${DEFAULT_EXPORT_NAME}: (${dep.prefix}`
					);
					source.replace(
						dep.range[1],
						dep.rangeStatement[1] - 0.5,
						`) }.${DEFAULT_EXPORT_NAME};`
					);
					return;
				}
				source.replace(
					dep.rangeStatement[0],
					dep.range[0] - 1,
					`${content}(${dep.prefix}`
				);
				if (dep.isAnonymousDefault && defaultIsUsed) {
					// Fix .name for anonymous default export expressions
					// see test/external/test262-cases/test/language/module-code/eval-export-dflt-cls-anon.js cspell:disable-line
					runtimeRequirements.add(RuntimeGlobals.setAnonymousDefaultName);
					source.replace(
						dep.range[1],
						dep.rangeStatement[1] - 0.5,
						`);\n${RuntimeGlobals.setAnonymousDefaultName}(${name});`
					);
				} else {
					source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
				}
				return;
			}

			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
		}
	}
};

module.exports = ESMExportExpressionDependency;