mirror of
https://github.com/Tria-plc/emaui.git
synced 2026-08-28 11:21:21 +00:00
938 lines
30 KiB
JavaScript
938 lines
30 KiB
JavaScript
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Sergey Melyukov @smelukov
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
const {
|
|
ConcatSource,
|
|
OriginalSource,
|
|
RawSource,
|
|
ReplaceSource,
|
|
SourceMapSource
|
|
} = require("webpack-sources");
|
|
const { UsageState } = require("../ExportsInfo");
|
|
const Generator = require("../Generator");
|
|
const InitFragment = require("../InitFragment");
|
|
const {
|
|
CSS_TEXT_TYPE,
|
|
CSS_TEXT_TYPES,
|
|
CSS_TYPE,
|
|
CSS_TYPES,
|
|
JAVASCRIPT_AND_CSS_TEXT_TYPES,
|
|
JAVASCRIPT_AND_CSS_TYPES,
|
|
JAVASCRIPT_TYPE,
|
|
JAVASCRIPT_TYPES
|
|
} = require("../ModuleSourceTypeConstants");
|
|
const RuntimeGlobals = require("../RuntimeGlobals");
|
|
const Template = require("../Template");
|
|
const CssImportDependency = require("../dependencies/CssImportDependency");
|
|
const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
|
|
|
|
const { encodeMappings } = require("../util/createMappings");
|
|
const memoize = require("../util/memoize");
|
|
|
|
/** @typedef {import("webpack-sources").Source} Source */
|
|
/** @typedef {import("../../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
|
|
/** @typedef {import("../Compilation").DependencyConstructor} DependencyConstructor */
|
|
/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
|
|
/** @typedef {import("../Dependency")} Dependency */
|
|
/** @typedef {import("../DependencyTemplate").CssData} CssData */
|
|
/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
|
|
/** @typedef {import("../Generator").GenerateContext} GenerateContext */
|
|
/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
|
|
/** @typedef {import("../Module").BuildInfo} BuildInfo */
|
|
/** @typedef {import("../Module").BuildMeta} BuildMeta */
|
|
/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
|
|
/** @typedef {import("../Module").SourceType} SourceType */
|
|
/** @typedef {import("../Module").SourceTypes} SourceTypes */
|
|
/** @typedef {import("../ModuleGraph")} ModuleGraph */
|
|
/** @typedef {import("../NormalModule")} NormalModule */
|
|
/** @typedef {import("../util/Hash")} Hash */
|
|
/** @typedef {import("./CssModulesPlugin").ModuleFactoryCacheEntry} ModuleFactoryCacheEntry */
|
|
/** @typedef {import("./CssModule")} CssModule */
|
|
/** @typedef {import("../Compilation")} Compilation */
|
|
/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
|
|
/** @typedef {import("../../declarations/WebpackOptions").CssParserExportType} CssParserExportType */
|
|
|
|
/** @typedef {{ line: number, column: number }} SourcePosition */
|
|
/** @typedef {Map<string, SourcePosition>} ExportLocsMap */
|
|
|
|
const getPropertyName = memoize(() => require("../util/property"));
|
|
const getCssModulesPlugin = memoize(() => require("./CssModulesPlugin"));
|
|
|
|
/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
|
|
|
|
/**
|
|
* Build a v3 source map that maps each line in `generatedJs` containing a
|
|
* known CSS-class export entry back to the corresponding selector position
|
|
* in the original CSS. Lines without an associated export are left
|
|
* unmapped — devtools simply shows them as part of the bundled JS.
|
|
* @param {string} generatedJs the generated JS string
|
|
* @param {ExportLocsMap} exportLocs map of export names to CSS source location
|
|
* @param {string} cssContent original CSS source content
|
|
* @param {string} sourceName source identifier to use in the map
|
|
* @returns {RawSourceMap} a v3 RawSourceMap
|
|
*/
|
|
const buildExportsSourceMap = (
|
|
generatedJs,
|
|
exportLocs,
|
|
cssContent,
|
|
sourceName
|
|
) => {
|
|
const lines = generatedJs.split("\n");
|
|
|
|
const lineByExport = new Map();
|
|
for (const [exportName] of exportLocs) {
|
|
const needle = `${JSON.stringify(exportName)}:`;
|
|
for (let i = 0; i < lines.length; i++) {
|
|
if (lines[i].includes(needle)) {
|
|
lineByExport.set(exportName, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @type {(import("../util/createMappings").LineMappings)[]} */
|
|
const perLine = lines.map(() => null);
|
|
for (const [exportName, genLine] of lineByExport) {
|
|
const pos = /** @type {SourcePosition} */ (exportLocs.get(exportName));
|
|
// Source-map V3 uses 0-based lines and 0-based columns. webpack's
|
|
// dependency `loc` uses 1-based lines and 0-based columns, so subtract
|
|
// one from the line.
|
|
perLine[genLine] = {
|
|
generatedColumn: 0,
|
|
sourceIndex: 0,
|
|
originalLine: pos.line - 1,
|
|
originalColumn: pos.column
|
|
};
|
|
}
|
|
|
|
return {
|
|
version: 3,
|
|
file: "",
|
|
sources: [sourceName],
|
|
sourcesContent: [cssContent],
|
|
names: [],
|
|
mappings: encodeMappings(perLine)
|
|
};
|
|
};
|
|
|
|
class CssGenerator extends Generator {
|
|
/**
|
|
* Creates an instance of CssGenerator.
|
|
* @param {CssModuleGeneratorOptions} options options
|
|
* @param {ModuleGraph} moduleGraph the module graph
|
|
*/
|
|
constructor(options, moduleGraph) {
|
|
super();
|
|
this.options = options;
|
|
this._exportsOnly = options.exportsOnly;
|
|
this._esModule = options.esModule;
|
|
this._moduleGraph = moduleGraph;
|
|
/** @type {WeakMap<Source, ModuleFactoryCacheEntry>} */
|
|
this._moduleFactoryCache = new WeakMap();
|
|
}
|
|
|
|
/**
|
|
* Returns the reason this module cannot be concatenated, when one exists.
|
|
* @param {NormalModule} module module for which the bailout reason should be determined
|
|
* @param {ConcatenationBailoutReasonContext} context context
|
|
* @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
|
|
*/
|
|
getConcatenationBailoutReason(module, context) {
|
|
if (!this._esModule) {
|
|
return "Module is not an ECMAScript module";
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Returns the `@charset` that will appear at the start of this module's
|
|
* default export, walking through text imports when the module has no
|
|
* local `@charset` of its own.
|
|
* @param {NormalModule} module the module
|
|
* @param {ModuleGraph} moduleGraph module graph
|
|
* @param {WeakSet<NormalModule>=} visited cycle guard
|
|
* @returns {string | undefined} the effective charset
|
|
*/
|
|
_getEffectiveCharset(module, moduleGraph, visited = new WeakSet()) {
|
|
if (!module || visited.has(module)) return undefined;
|
|
const exportType = /** @type {CssModule} */ (module).exportType;
|
|
if (exportType !== "text" && exportType !== "css-style-sheet") {
|
|
return undefined;
|
|
}
|
|
visited.add(module);
|
|
const own =
|
|
module.buildInfo && /** @type {BuildInfo} */ (module.buildInfo).charset;
|
|
if (own !== undefined) return own;
|
|
if (exportType !== "text") return undefined;
|
|
for (const dep of module.dependencies) {
|
|
if (dep instanceof CssImportDependency) {
|
|
const depModule = /** @type {NormalModule} */ (
|
|
moduleGraph.getModule(dep)
|
|
);
|
|
const inherited = this._getEffectiveCharset(
|
|
depModule,
|
|
moduleGraph,
|
|
visited
|
|
);
|
|
if (inherited !== undefined) return inherited;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Generate JavaScript expressions that evaluate each `@import`'d module
|
|
* for side effects. Only used by `style` exportType, where each imported
|
|
* style module injects its own `<style>` element independently — no
|
|
* content merging happens at the parent. `text` and `css-style-sheet`
|
|
* instead inline their imports at build time via
|
|
* {@link CssGenerator#_generateMergedContentSource}.
|
|
* @param {NormalModule} module the module to generate CSS text for
|
|
* @param {GenerateContext} generateContext the generate context
|
|
* @returns {string[]} JS expressions, one per `@import` dependency
|
|
*/
|
|
_generateImportSideEffects(module, generateContext) {
|
|
const { moduleGraph, concatenationScope } = generateContext;
|
|
const parts = [];
|
|
|
|
for (const dep of module.dependencies) {
|
|
if (!(dep instanceof CssImportDependency)) continue;
|
|
const depModule = /** @type {CssModule} */ (moduleGraph.getModule(dep));
|
|
// Concat-scoped deps are inlined into the same module; their side
|
|
// effect (own `<style>` injection) is emitted at the dep's own
|
|
// site, so no explicit reference is needed here.
|
|
if (concatenationScope && concatenationScope.isModuleInScope(depModule)) {
|
|
continue;
|
|
}
|
|
parts.push(
|
|
generateContext.runtimeTemplate.moduleExports({
|
|
module: depModule,
|
|
chunkGraph: generateContext.chunkGraph,
|
|
request: depModule.userRequest,
|
|
weak: false,
|
|
runtimeRequirements: generateContext.runtimeRequirements
|
|
})
|
|
);
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
/**
|
|
* Build a single CSS `Source` that contains, in source order, the rendered
|
|
* CSS text of every transitively `@import`'d module followed by the
|
|
* current module's own CSS text. Imports are inlined at build time so
|
|
* the resulting `Source` carries a single, accurate source map covering
|
|
* every contributing file — no runtime merge helper required.
|
|
*
|
|
* Only `text` / `css-style-sheet` imports contribute CSS text; `link` and
|
|
* `style` imports are emitted separately (own `.css` file or own
|
|
* `<style>` injection) and are skipped here.
|
|
*
|
|
* `ancestors` tracks the path from the top-level caller down to the
|
|
* current module — not every module ever visited. A module reappearing
|
|
* along a sibling branch (a "diamond import" like two different files
|
|
* each `@import`'ing the same shared module) must be inlined every time,
|
|
* matching the prior runtime behavior where each `default` getter was
|
|
* invoked at every import site.
|
|
* @param {NormalModule} module the module to render
|
|
* @param {GenerateContext} generateContext the generate context
|
|
* @param {Set<NormalModule>} ancestors modules on the current path
|
|
* @returns {Source | null} merged CSS source, or null when the module has no content
|
|
*/
|
|
_generateMergedContentSource(module, generateContext, ancestors) {
|
|
if (ancestors.has(module)) return null;
|
|
ancestors.add(module);
|
|
try {
|
|
const { moduleGraph } = generateContext;
|
|
/** @type {Source[]} */
|
|
const parts = [];
|
|
|
|
for (const dep of module.dependencies) {
|
|
if (!(dep instanceof CssImportDependency)) continue;
|
|
const depModule = /** @type {CssModule} */ (moduleGraph.getModule(dep));
|
|
if (!depModule) continue;
|
|
const depExportType = depModule.exportType;
|
|
if (depExportType !== "text" && depExportType !== "css-style-sheet") {
|
|
continue;
|
|
}
|
|
const depMerged = this._generateMergedContentSource(
|
|
depModule,
|
|
generateContext,
|
|
ancestors
|
|
);
|
|
if (depMerged) parts.push(depMerged);
|
|
}
|
|
|
|
const own = this._generateContentSource(module, generateContext);
|
|
if (own) parts.push(own);
|
|
|
|
if (parts.length === 0) return null;
|
|
if (parts.length === 1) return parts[0];
|
|
return new ConcatSource(...parts);
|
|
} finally {
|
|
ancestors.delete(module);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate CSS source for the current module
|
|
* @param {NormalModule} module the module to generate CSS source for
|
|
* @param {GenerateContext} generateContext the generate context
|
|
* @returns {Source | null} the CSS source
|
|
*/
|
|
_generateContentSource(module, generateContext) {
|
|
const moduleSourceContent = /** @type {Source} */ (
|
|
this.generate(module, {
|
|
...generateContext,
|
|
type: CSS_TYPE
|
|
})
|
|
);
|
|
|
|
if (!moduleSourceContent) {
|
|
return null;
|
|
}
|
|
|
|
const compilation = generateContext.runtimeTemplate.compilation;
|
|
// For non-link exportTypes (style, text, css-style-sheet), url() in the CSS
|
|
// is resolved relative to the document URL (for <style> tags and CSSStyleSheet),
|
|
// not relative to any output file. Use empty undoPath so urls are relative to
|
|
// the output root.
|
|
const undoPath = "";
|
|
|
|
const CssModulesPlugin = getCssModulesPlugin();
|
|
const hooks = CssModulesPlugin.getCompilationHooks(compilation);
|
|
return CssModulesPlugin.renderModule(
|
|
/** @type {CssModule} */ (module),
|
|
{
|
|
undoPath,
|
|
moduleSourceContent,
|
|
moduleFactoryCache: this._moduleFactoryCache,
|
|
runtimeTemplate: generateContext.runtimeTemplate
|
|
},
|
|
hooks
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Serialize a CSS Source into a JS string literal with an optional
|
|
* inline `sourceMappingURL` data URI so DevTools can resolve the
|
|
* original sources at runtime.
|
|
* @param {Source} cssSource the CSS source
|
|
* @param {import("../../declarations/WebpackOptions").DevTool | undefined} devtool the devtool option
|
|
* @returns {Source} a Source representing a JS string literal
|
|
*/
|
|
_cssToJsLiteral(cssSource, devtool) {
|
|
const { source, map } = cssSource.sourceAndMap();
|
|
let content = /** @type {string} */ (source);
|
|
if (map) {
|
|
const inlineMap =
|
|
typeof devtool === "string" && devtool.includes("nosources")
|
|
? { ...map, sourcesContent: undefined }
|
|
: map;
|
|
const base64Map = Buffer.from(JSON.stringify(inlineMap), "utf8").toString(
|
|
"base64"
|
|
);
|
|
const trailingNewline = content.endsWith("\n") ? "" : "\n";
|
|
content += `${trailingNewline}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64Map}*/`;
|
|
}
|
|
return new RawSource(JSON.stringify(content));
|
|
}
|
|
|
|
/**
|
|
* Processes the provided module.
|
|
* @param {NormalModule} module the current module
|
|
* @param {Dependency} dependency the dependency to generate
|
|
* @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments
|
|
* @param {ReplaceSource} source the current replace source which can be modified
|
|
* @param {GenerateContext & { cssData: CssData }} generateContext the render context
|
|
* @returns {void}
|
|
*/
|
|
sourceDependency(module, dependency, initFragments, source, generateContext) {
|
|
const constructor =
|
|
/** @type {DependencyConstructor} */
|
|
(dependency.constructor);
|
|
const template = generateContext.dependencyTemplates.get(constructor);
|
|
if (!template) {
|
|
throw new Error(
|
|
`No template for dependency: ${dependency.constructor.name}`
|
|
);
|
|
}
|
|
|
|
/** @type {DependencyTemplateContext} */
|
|
/** @type {InitFragment<GenerateContext>[] | undefined} */
|
|
let chunkInitFragments;
|
|
/** @type {DependencyTemplateContext} */
|
|
const templateContext = {
|
|
runtimeTemplate: generateContext.runtimeTemplate,
|
|
dependencyTemplates: generateContext.dependencyTemplates,
|
|
moduleGraph: generateContext.moduleGraph,
|
|
chunkGraph: generateContext.chunkGraph,
|
|
module,
|
|
runtime: generateContext.runtime,
|
|
runtimeRequirements: generateContext.runtimeRequirements,
|
|
concatenationScope: generateContext.concatenationScope,
|
|
codeGenerationResults:
|
|
/** @type {CodeGenerationResults} */
|
|
(generateContext.codeGenerationResults),
|
|
initFragments,
|
|
cssData: generateContext.cssData,
|
|
type: generateContext.type,
|
|
get chunkInitFragments() {
|
|
if (!chunkInitFragments) {
|
|
const data =
|
|
/** @type {NonNullable<GenerateContext["getData"]>} */
|
|
(generateContext.getData)();
|
|
chunkInitFragments = data.get("chunkInitFragments");
|
|
if (!chunkInitFragments) {
|
|
chunkInitFragments = [];
|
|
data.set("chunkInitFragments", chunkInitFragments);
|
|
}
|
|
}
|
|
|
|
return chunkInitFragments;
|
|
}
|
|
};
|
|
|
|
template.apply(dependency, source, templateContext);
|
|
}
|
|
|
|
/**
|
|
* Processes the provided module.
|
|
* @param {NormalModule} module the module to generate
|
|
* @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments
|
|
* @param {ReplaceSource} source the current replace source which can be modified
|
|
* @param {GenerateContext & { cssData: CssData }} generateContext the generateContext
|
|
* @returns {void}
|
|
*/
|
|
sourceModule(module, initFragments, source, generateContext) {
|
|
for (const dependency of module.dependencies) {
|
|
this.sourceDependency(
|
|
module,
|
|
dependency,
|
|
initFragments,
|
|
source,
|
|
generateContext
|
|
);
|
|
}
|
|
|
|
if (module.presentationalDependencies !== undefined) {
|
|
for (const dependency of module.presentationalDependencies) {
|
|
this.sourceDependency(
|
|
module,
|
|
dependency,
|
|
initFragments,
|
|
source,
|
|
generateContext
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates generated code for this runtime module.
|
|
* @param {NormalModule} module module for which the code should be generated
|
|
* @param {GenerateContext} generateContext context for generate
|
|
* @returns {Source | null} generated code
|
|
*/
|
|
generate(module, generateContext) {
|
|
const exportType = /** @type {CssModule} */ (module).exportType || "link";
|
|
const source =
|
|
generateContext.type === JAVASCRIPT_TYPE && exportType === "link"
|
|
? new ReplaceSource(new RawSource(""))
|
|
: new ReplaceSource(/** @type {Source} */ (module.originalSource()));
|
|
/** @type {InitFragment<GenerateContext>[]} */
|
|
const initFragments = [];
|
|
/** @type {CssData} */
|
|
const cssData = {
|
|
esModule: /** @type {boolean} */ (this._esModule),
|
|
exports: new Map(),
|
|
exportLocs: new Map()
|
|
};
|
|
|
|
this.sourceModule(module, initFragments, source, {
|
|
...generateContext,
|
|
cssData
|
|
});
|
|
|
|
switch (generateContext.type) {
|
|
case JAVASCRIPT_TYPE: {
|
|
const compilation = generateContext.runtimeTemplate.compilation;
|
|
const devtool = compilation.options.devtool;
|
|
const isCssModule = /** @type {BuildMeta} */ (module.buildMeta)
|
|
.isCssModule;
|
|
|
|
const generateContentCode = () => {
|
|
switch (exportType) {
|
|
case "style": {
|
|
const cssSource = this._generateContentSource(
|
|
module,
|
|
generateContext
|
|
);
|
|
if (!cssSource) return "";
|
|
|
|
generateContext.runtimeRequirements.add(
|
|
RuntimeGlobals.cssInjectStyle
|
|
);
|
|
|
|
const moduleId = generateContext.chunkGraph.getModuleId(module);
|
|
|
|
if (generateContext.concatenationScope) {
|
|
return new ConcatSource(
|
|
`__webpack_css_styles__.push([${JSON.stringify(moduleId)}, `,
|
|
this._cssToJsLiteral(cssSource, devtool),
|
|
"]);"
|
|
);
|
|
}
|
|
|
|
return new ConcatSource(
|
|
`${RuntimeGlobals.cssInjectStyle}(${JSON.stringify(moduleId)}, `,
|
|
this._cssToJsLiteral(cssSource, devtool),
|
|
");"
|
|
);
|
|
}
|
|
|
|
default:
|
|
return "";
|
|
}
|
|
};
|
|
const generateImportCode = () => {
|
|
switch (exportType) {
|
|
case "style": {
|
|
return this._generateImportSideEffects(module, generateContext)
|
|
.map((expr) => `${expr};`)
|
|
.join("\n");
|
|
}
|
|
default:
|
|
return "";
|
|
}
|
|
};
|
|
const generateExportCode = () => {
|
|
/** @returns {Source} generated CSS text as JS expression */
|
|
const generateCssText = () => {
|
|
const cssSource = this._generateMergedContentSource(
|
|
module,
|
|
generateContext,
|
|
new Set()
|
|
);
|
|
|
|
let jsLiteral = cssSource
|
|
? this._cssToJsLiteral(cssSource, devtool)
|
|
: new RawSource('""');
|
|
|
|
const effectiveCharset =
|
|
exportType === "css-style-sheet" || exportType === "text"
|
|
? this._getEffectiveCharset(module, generateContext.moduleGraph)
|
|
: undefined;
|
|
if (effectiveCharset !== undefined) {
|
|
jsLiteral = new ConcatSource(
|
|
`'@charset "${effectiveCharset}";\\n' + `,
|
|
jsLiteral
|
|
);
|
|
}
|
|
|
|
return jsLiteral;
|
|
};
|
|
/**
|
|
* Generates js default export.
|
|
* @returns {Source | null} the default export
|
|
*/
|
|
const generateJSDefaultExport = () => {
|
|
switch (exportType) {
|
|
case "text": {
|
|
return generateCssText();
|
|
}
|
|
case "css-style-sheet": {
|
|
// Build a constructable stylesheet from the statically
|
|
// merged CSS text. The merged literal carries a single
|
|
// inline source map covering every contributing module.
|
|
const fnPrefix =
|
|
generateContext.runtimeTemplate.supportsArrowFunction()
|
|
? "() => {\n"
|
|
: "function() {\n";
|
|
const constOrVar =
|
|
generateContext.runtimeTemplate.renderConst();
|
|
return new ConcatSource(
|
|
`(${fnPrefix}${constOrVar} sheet = new CSSStyleSheet();\nsheet.replaceSync(`,
|
|
generateCssText(),
|
|
");\nreturn sheet;\n})()"
|
|
);
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
};
|
|
|
|
/** @type {Source | null} */
|
|
const defaultExport = generateJSDefaultExport();
|
|
|
|
/** @type {BuildInfo} */
|
|
(module.buildInfo).cssData = cssData;
|
|
|
|
// Required for HMR
|
|
if (module.hot) {
|
|
generateContext.runtimeRequirements.add(RuntimeGlobals.module);
|
|
}
|
|
|
|
if (!defaultExport && cssData.exports.size === 0 && !isCssModule) {
|
|
return new RawSource("");
|
|
}
|
|
|
|
if (generateContext.concatenationScope) {
|
|
const source = new ConcatSource();
|
|
/** @type {Set<string>} */
|
|
const usedIdentifiers = new Set();
|
|
const { RESERVED_IDENTIFIER } = getPropertyName();
|
|
|
|
if (defaultExport) {
|
|
const usedName = generateContext.moduleGraph
|
|
.getExportInfo(module, "default")
|
|
.getUsedName("default", generateContext.runtime);
|
|
if (usedName) {
|
|
let identifier = Template.toIdentifier(usedName);
|
|
if (RESERVED_IDENTIFIER.has(identifier)) {
|
|
identifier = `_${identifier}`;
|
|
}
|
|
usedIdentifiers.add(identifier);
|
|
generateContext.concatenationScope.registerExport(
|
|
"default",
|
|
identifier
|
|
);
|
|
source.add(
|
|
`${generateContext.runtimeTemplate.renderConst()} ${identifier} = `
|
|
);
|
|
source.add(defaultExport);
|
|
source.add(";\n");
|
|
}
|
|
}
|
|
|
|
for (const [name, v] of cssData.exports) {
|
|
const usedName = generateContext.moduleGraph
|
|
.getExportInfo(module, name)
|
|
.getUsedName(name, generateContext.runtime);
|
|
if (!usedName) {
|
|
continue;
|
|
}
|
|
|
|
let identifier = Template.toIdentifier(usedName);
|
|
if (RESERVED_IDENTIFIER.has(identifier)) {
|
|
identifier = `_${identifier}`;
|
|
}
|
|
let i = 0;
|
|
while (usedIdentifiers.has(identifier)) {
|
|
identifier = Template.toIdentifier(name + i);
|
|
i += 1;
|
|
}
|
|
usedIdentifiers.add(identifier);
|
|
generateContext.concatenationScope.registerExport(
|
|
name,
|
|
identifier
|
|
);
|
|
source.add(
|
|
`${generateContext.runtimeTemplate.renderConst()} ${identifier} = ${JSON.stringify(v)};\n`
|
|
);
|
|
}
|
|
return source;
|
|
}
|
|
|
|
const needNsObj =
|
|
this._esModule &&
|
|
generateContext.moduleGraph
|
|
.getExportsInfo(module)
|
|
.otherExportsInfo.getUsed(generateContext.runtime) !==
|
|
UsageState.Unused;
|
|
|
|
if (needNsObj) {
|
|
generateContext.runtimeRequirements.add(
|
|
RuntimeGlobals.makeNamespaceObject
|
|
);
|
|
}
|
|
|
|
// Should be after `concatenationScope` to allow module inlining
|
|
generateContext.runtimeRequirements.add(RuntimeGlobals.module);
|
|
|
|
if (!isCssModule && !needNsObj) {
|
|
return new ConcatSource(
|
|
`${module.moduleArgument}.exports = `,
|
|
/** @type {Source} */ (defaultExport)
|
|
);
|
|
}
|
|
|
|
const result = new ConcatSource();
|
|
result.add(
|
|
`${needNsObj ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
|
|
module.moduleArgument
|
|
}.exports = {\n`
|
|
);
|
|
|
|
if (defaultExport) {
|
|
result.add('\t"default": ');
|
|
result.add(defaultExport);
|
|
if (cssData.exports.size > 0) {
|
|
result.add(",\n");
|
|
}
|
|
}
|
|
|
|
/** @type {string[]} */
|
|
const exportEntries = [];
|
|
for (const [name, v] of cssData.exports) {
|
|
exportEntries.push(
|
|
`\t${JSON.stringify(name)}: ${JSON.stringify(v)}`
|
|
);
|
|
}
|
|
if (exportEntries.length > 0) {
|
|
result.add(exportEntries.join(",\n"));
|
|
}
|
|
|
|
result.add(`\n}${needNsObj ? ")" : ""};`);
|
|
return result;
|
|
};
|
|
|
|
const codeParts = this._exportsOnly
|
|
? [generateExportCode()]
|
|
: [generateImportCode(), generateContentCode(), generateExportCode()];
|
|
|
|
const source = new ConcatSource();
|
|
for (const part of codeParts) {
|
|
if (part) {
|
|
source.add(part);
|
|
source.add("\n");
|
|
}
|
|
}
|
|
// For link-type modules without any JS emit, skip source wrapping
|
|
if (
|
|
exportType === "link" &&
|
|
!isCssModule &&
|
|
cssData.exports.size === 0
|
|
) {
|
|
return source;
|
|
}
|
|
|
|
const generatedJs = /** @type {string} */ (source.source());
|
|
const sourceName = module.readableIdentifier(
|
|
compilation.requestShortener
|
|
);
|
|
|
|
// When per-export source positions are available, emit a
|
|
// SourceMapSource mapping each export line back to its CSS
|
|
// selector; otherwise fall back to OriginalSource.
|
|
if (
|
|
/** @type {ExportLocsMap} */
|
|
(cssData.exportLocs).size > 0
|
|
) {
|
|
const cssOriginal = module.originalSource();
|
|
if (cssOriginal) {
|
|
const sourceMap = buildExportsSourceMap(
|
|
generatedJs,
|
|
/** @type {ExportLocsMap} */
|
|
(cssData.exportLocs),
|
|
/** @type {string} */ (cssOriginal.source()),
|
|
sourceName
|
|
);
|
|
return new SourceMapSource(generatedJs, sourceName, sourceMap);
|
|
}
|
|
}
|
|
return new OriginalSource(generatedJs, sourceName);
|
|
}
|
|
case CSS_TYPE: {
|
|
if (!(this._exportsOnly || (exportType && exportType !== "link"))) {
|
|
generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
|
|
}
|
|
|
|
return InitFragment.addToSource(source, initFragments, generateContext);
|
|
}
|
|
case CSS_TEXT_TYPE: {
|
|
// The merged CSS text — what consumers like
|
|
// `HtmlInlineStyleDependency.Template` need when they want to
|
|
// drop the processed CSS straight into an inline `<style>`
|
|
// tag. Mirrors the JS-side `generateCssText()` (charset
|
|
// prefix included), without the JS string-literal wrapper.
|
|
const cssSource = this._generateMergedContentSource(
|
|
module,
|
|
generateContext,
|
|
new Set()
|
|
);
|
|
|
|
const effectiveCharset = this._getEffectiveCharset(
|
|
module,
|
|
generateContext.moduleGraph
|
|
);
|
|
const charsetPrefix =
|
|
effectiveCharset !== undefined
|
|
? `@charset "${effectiveCharset}";\n`
|
|
: "";
|
|
|
|
if (!cssSource) {
|
|
return charsetPrefix
|
|
? new RawSource(charsetPrefix)
|
|
: new RawSource("");
|
|
}
|
|
return charsetPrefix
|
|
? new ConcatSource(charsetPrefix, cssSource)
|
|
: cssSource;
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates fallback output for the provided error condition.
|
|
* @param {Error} error the error
|
|
* @param {NormalModule} module module for which the code should be generated
|
|
* @param {GenerateContext} generateContext context for generate
|
|
* @returns {Source | null} generated code
|
|
*/
|
|
generateError(error, module, generateContext) {
|
|
switch (generateContext.type) {
|
|
case JAVASCRIPT_TYPE: {
|
|
return new RawSource(
|
|
`throw new Error(${JSON.stringify(error.message)});`
|
|
);
|
|
}
|
|
case CSS_TYPE: {
|
|
return new RawSource(`/**\n ${error.message} \n**/`);
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the source types available for this module.
|
|
* @param {NormalModule} module fresh module
|
|
* @returns {SourceTypes} available types (do not mutate)
|
|
*/
|
|
getTypes(module) {
|
|
const exportType = /** @type {CssModule} */ (module).exportType || "link";
|
|
if (exportType === "style") {
|
|
return JAVASCRIPT_TYPES;
|
|
}
|
|
|
|
const sourceTypes = new Set();
|
|
const connections = this._moduleGraph.getIncomingConnections(module);
|
|
|
|
for (const connection of connections) {
|
|
if (
|
|
exportType === "link" &&
|
|
connection.dependency instanceof CssImportDependency
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
// when no hmr required, css module js output contains no sideEffects at all
|
|
// js sideeffect connection doesn't require js type output
|
|
if (connection.dependency instanceof HarmonyImportSideEffectDependency) {
|
|
continue;
|
|
}
|
|
|
|
// Inline `<style>` blocks in HTML modules read the merged CSS
|
|
// text directly via the `css-text` source type — they don't go
|
|
// through the JS-string wrapper that other consumers use.
|
|
// Matched by dependency category so the CSS package doesn't
|
|
// have to import HtmlInlineStyleDependency.
|
|
if (
|
|
connection.dependency &&
|
|
connection.dependency.category === "html-style"
|
|
) {
|
|
sourceTypes.add(CSS_TEXT_TYPE);
|
|
continue;
|
|
}
|
|
|
|
if (!connection.originModule) {
|
|
continue;
|
|
}
|
|
|
|
if (connection.originModule.type.split("/")[0] !== CSS_TYPE) {
|
|
sourceTypes.add(JAVASCRIPT_TYPE);
|
|
} else {
|
|
const originModule = /** @type {CssModule} */ connection.originModule;
|
|
const originExportType = /** @type {CssModule} */ (originModule)
|
|
.exportType;
|
|
if (
|
|
/** @type {boolean} */ (
|
|
originExportType && originExportType !== "link"
|
|
)
|
|
) {
|
|
sourceTypes.add(JAVASCRIPT_TYPE);
|
|
}
|
|
}
|
|
}
|
|
if (
|
|
this._exportsOnly ||
|
|
/** @type {boolean} */ (exportType && exportType !== "link")
|
|
) {
|
|
const hasJs = sourceTypes.has(JAVASCRIPT_TYPE);
|
|
const hasCssText = sourceTypes.has(CSS_TEXT_TYPE);
|
|
if (hasJs && hasCssText) return JAVASCRIPT_AND_CSS_TEXT_TYPES;
|
|
if (hasJs) return JAVASCRIPT_TYPES;
|
|
if (hasCssText) return CSS_TEXT_TYPES;
|
|
return new Set();
|
|
}
|
|
if (sourceTypes.has(JAVASCRIPT_TYPE)) {
|
|
return JAVASCRIPT_AND_CSS_TYPES;
|
|
}
|
|
return CSS_TYPES;
|
|
}
|
|
|
|
/**
|
|
* Returns the estimated size for the requested source type.
|
|
* @param {NormalModule} module the module
|
|
* @param {SourceType=} type source type
|
|
* @returns {number} estimate size of the module
|
|
*/
|
|
getSize(module, type) {
|
|
switch (type) {
|
|
case JAVASCRIPT_TYPE: {
|
|
const cssData = /** @type {BuildInfo} */ (module.buildInfo).cssData;
|
|
if (!cssData) {
|
|
return 42;
|
|
}
|
|
if (cssData.exports.size === 0) {
|
|
if (/** @type {BuildMeta} */ (module.buildMeta).isCssModule) {
|
|
return 42;
|
|
}
|
|
return 0;
|
|
}
|
|
const exports = cssData.exports;
|
|
/** @type {Record<string, string>} */
|
|
const exportsObj = {};
|
|
for (const [key, value] of exports) {
|
|
exportsObj[key] = value;
|
|
}
|
|
const stringifiedExports = JSON.stringify(exportsObj);
|
|
|
|
return stringifiedExports.length + 42;
|
|
}
|
|
case CSS_TYPE: {
|
|
const originalSource = module.originalSource();
|
|
|
|
if (!originalSource) {
|
|
return 0;
|
|
}
|
|
|
|
return originalSource.size();
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the hash with the data contributed by this instance.
|
|
* @param {Hash} hash hash that will be modified
|
|
* @param {UpdateHashContext} updateHashContext context for updating hash
|
|
*/
|
|
updateHash(hash, { module }) {
|
|
hash.update(/** @type {boolean} */ (this._esModule).toString());
|
|
hash.update(/** @type {boolean} */ (this._exportsOnly).toString());
|
|
}
|
|
}
|
|
|
|
module.exports = CssGenerator;
|