CssModulesPlugin.js 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894
  1. /*
  2. MIT License http://www.opensource.org/licenses/mit-license.php
  3. Author Tobias Koppers @sokra
  4. */
  5. "use strict";
  6. const { SyncWaterfallHook, SyncHook } = require("tapable");
  7. const {
  8. ConcatSource,
  9. PrefixSource,
  10. ReplaceSource,
  11. CachedSource,
  12. RawSource
  13. } = require("webpack-sources");
  14. const Compilation = require("../Compilation");
  15. const CssModule = require("../CssModule");
  16. const { tryRunOrWebpackError } = require("../HookWebpackError");
  17. const HotUpdateChunk = require("../HotUpdateChunk");
  18. const {
  19. CSS_MODULE_TYPE,
  20. CSS_MODULE_TYPE_GLOBAL,
  21. CSS_MODULE_TYPE_MODULE,
  22. CSS_MODULE_TYPE_AUTO
  23. } = require("../ModuleTypeConstants");
  24. const RuntimeGlobals = require("../RuntimeGlobals");
  25. const SelfModuleFactory = require("../SelfModuleFactory");
  26. const Template = require("../Template");
  27. const WebpackError = require("../WebpackError");
  28. const CssIcssExportDependency = require("../dependencies/CssIcssExportDependency");
  29. const CssIcssImportDependency = require("../dependencies/CssIcssImportDependency");
  30. const CssIcssSymbolDependency = require("../dependencies/CssIcssSymbolDependency");
  31. const CssImportDependency = require("../dependencies/CssImportDependency");
  32. const CssLocalIdentifierDependency = require("../dependencies/CssLocalIdentifierDependency");
  33. const CssSelfLocalIdentifierDependency = require("../dependencies/CssSelfLocalIdentifierDependency");
  34. const CssUrlDependency = require("../dependencies/CssUrlDependency");
  35. const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
  36. const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
  37. const { compareModulesByIdOrIdentifier } = require("../util/comparators");
  38. const createSchemaValidation = require("../util/create-schema-validation");
  39. const createHash = require("../util/createHash");
  40. const { getUndoPath } = require("../util/identifier");
  41. const memoize = require("../util/memoize");
  42. const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
  43. const CssGenerator = require("./CssGenerator");
  44. const CssParser = require("./CssParser");
  45. /** @typedef {import("webpack-sources").Source} Source */
  46. /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
  47. /** @typedef {import("../Chunk")} Chunk */
  48. /** @typedef {import("../ChunkGraph")} ChunkGraph */
  49. /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
  50. /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
  51. /** @typedef {import("../Compiler")} Compiler */
  52. /** @typedef {import("../CssModule").Inheritance} Inheritance */
  53. /** @typedef {import("../Module")} Module */
  54. /** @typedef {import("../Template").RuntimeTemplate} RuntimeTemplate */
  55. /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
  56. /** @typedef {import("../util/Hash")} Hash */
  57. /** @typedef {import("../util/createHash").Algorithm} Algorithm */
  58. /** @typedef {import("../util/memoize")} Memoize */
  59. /**
  60. * @typedef {object} RenderContext
  61. * @property {Chunk} chunk the chunk
  62. * @property {ChunkGraph} chunkGraph the chunk graph
  63. * @property {CodeGenerationResults} codeGenerationResults results of code generation
  64. * @property {RuntimeTemplate} runtimeTemplate the runtime template
  65. * @property {string} uniqueName the unique name
  66. * @property {string} undoPath undo path to css file
  67. * @property {CssModule[]} modules modules
  68. */
  69. /**
  70. * @typedef {object} ChunkRenderContext
  71. * @property {Chunk} chunk the chunk
  72. * @property {ChunkGraph} chunkGraph the chunk graph
  73. * @property {CodeGenerationResults} codeGenerationResults results of code generation
  74. * @property {RuntimeTemplate} runtimeTemplate the runtime template
  75. * @property {string} undoPath undo path to css file
  76. */
  77. /**
  78. * @typedef {object} CompilationHooks
  79. * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
  80. * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
  81. */
  82. const getCssLoadingRuntimeModule = memoize(() =>
  83. require("./CssLoadingRuntimeModule")
  84. );
  85. /**
  86. * @param {string} name name
  87. * @returns {{oneOf: [{$ref: string}], definitions: *}} schema
  88. */
  89. const getSchema = name => {
  90. const { definitions } = require("../../schemas/WebpackOptions.json");
  91. return {
  92. definitions,
  93. oneOf: [{ $ref: `#/definitions/${name}` }]
  94. };
  95. };
  96. const generatorValidationOptions = {
  97. name: "Css Modules Plugin",
  98. baseDataPath: "generator"
  99. };
  100. const validateGeneratorOptions = {
  101. css: createSchemaValidation(
  102. require("../../schemas/plugins/css/CssGeneratorOptions.check.js"),
  103. () => getSchema("CssGeneratorOptions"),
  104. generatorValidationOptions
  105. ),
  106. "css/auto": createSchemaValidation(
  107. require("../../schemas/plugins/css/CssAutoGeneratorOptions.check.js"),
  108. () => getSchema("CssAutoGeneratorOptions"),
  109. generatorValidationOptions
  110. ),
  111. "css/module": createSchemaValidation(
  112. require("../../schemas/plugins/css/CssModuleGeneratorOptions.check.js"),
  113. () => getSchema("CssModuleGeneratorOptions"),
  114. generatorValidationOptions
  115. ),
  116. "css/global": createSchemaValidation(
  117. require("../../schemas/plugins/css/CssGlobalGeneratorOptions.check.js"),
  118. () => getSchema("CssGlobalGeneratorOptions"),
  119. generatorValidationOptions
  120. )
  121. };
  122. const parserValidationOptions = {
  123. name: "Css Modules Plugin",
  124. baseDataPath: "parser"
  125. };
  126. const validateParserOptions = {
  127. css: createSchemaValidation(
  128. require("../../schemas/plugins/css/CssParserOptions.check.js"),
  129. () => getSchema("CssParserOptions"),
  130. parserValidationOptions
  131. ),
  132. "css/auto": createSchemaValidation(
  133. require("../../schemas/plugins/css/CssAutoParserOptions.check.js"),
  134. () => getSchema("CssAutoParserOptions"),
  135. parserValidationOptions
  136. ),
  137. "css/module": createSchemaValidation(
  138. require("../../schemas/plugins/css/CssModuleParserOptions.check.js"),
  139. () => getSchema("CssModuleParserOptions"),
  140. parserValidationOptions
  141. ),
  142. "css/global": createSchemaValidation(
  143. require("../../schemas/plugins/css/CssGlobalParserOptions.check.js"),
  144. () => getSchema("CssGlobalParserOptions"),
  145. parserValidationOptions
  146. )
  147. };
  148. /** @type {WeakMap<Compilation, CompilationHooks>} */
  149. const compilationHooksMap = new WeakMap();
  150. const PLUGIN_NAME = "CssModulesPlugin";
  151. class CssModulesPlugin {
  152. /**
  153. * @param {Compilation} compilation the compilation
  154. * @returns {CompilationHooks} the attached hooks
  155. */
  156. static getCompilationHooks(compilation) {
  157. if (!(compilation instanceof Compilation)) {
  158. throw new TypeError(
  159. "The 'compilation' argument must be an instance of Compilation"
  160. );
  161. }
  162. let hooks = compilationHooksMap.get(compilation);
  163. if (hooks === undefined) {
  164. hooks = {
  165. renderModulePackage: new SyncWaterfallHook([
  166. "source",
  167. "module",
  168. "renderContext"
  169. ]),
  170. chunkHash: new SyncHook(["chunk", "hash", "context"])
  171. };
  172. compilationHooksMap.set(compilation, hooks);
  173. }
  174. return hooks;
  175. }
  176. constructor() {
  177. /** @type {WeakMap<Source, { undoPath: string, inheritance: Inheritance, source: CachedSource }>} */
  178. this._moduleFactoryCache = new WeakMap();
  179. }
  180. /**
  181. * Apply the plugin
  182. * @param {Compiler} compiler the compiler instance
  183. * @returns {void}
  184. */
  185. apply(compiler) {
  186. compiler.hooks.compilation.tap(
  187. PLUGIN_NAME,
  188. (compilation, { normalModuleFactory }) => {
  189. const hooks = CssModulesPlugin.getCompilationHooks(compilation);
  190. const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
  191. compilation.dependencyFactories.set(
  192. CssImportDependency,
  193. normalModuleFactory
  194. );
  195. compilation.dependencyTemplates.set(
  196. CssImportDependency,
  197. new CssImportDependency.Template()
  198. );
  199. compilation.dependencyFactories.set(
  200. CssUrlDependency,
  201. normalModuleFactory
  202. );
  203. compilation.dependencyTemplates.set(
  204. CssUrlDependency,
  205. new CssUrlDependency.Template()
  206. );
  207. compilation.dependencyTemplates.set(
  208. CssLocalIdentifierDependency,
  209. new CssLocalIdentifierDependency.Template()
  210. );
  211. compilation.dependencyFactories.set(
  212. CssSelfLocalIdentifierDependency,
  213. selfFactory
  214. );
  215. compilation.dependencyTemplates.set(
  216. CssSelfLocalIdentifierDependency,
  217. new CssSelfLocalIdentifierDependency.Template()
  218. );
  219. compilation.dependencyFactories.set(
  220. CssIcssImportDependency,
  221. normalModuleFactory
  222. );
  223. compilation.dependencyTemplates.set(
  224. CssIcssImportDependency,
  225. new CssIcssImportDependency.Template()
  226. );
  227. compilation.dependencyTemplates.set(
  228. CssIcssExportDependency,
  229. new CssIcssExportDependency.Template()
  230. );
  231. compilation.dependencyTemplates.set(
  232. CssIcssSymbolDependency,
  233. new CssIcssSymbolDependency.Template()
  234. );
  235. compilation.dependencyTemplates.set(
  236. StaticExportsDependency,
  237. new StaticExportsDependency.Template()
  238. );
  239. for (const type of [
  240. CSS_MODULE_TYPE,
  241. CSS_MODULE_TYPE_GLOBAL,
  242. CSS_MODULE_TYPE_MODULE,
  243. CSS_MODULE_TYPE_AUTO
  244. ]) {
  245. normalModuleFactory.hooks.createParser
  246. .for(type)
  247. .tap(PLUGIN_NAME, parserOptions => {
  248. validateParserOptions[type](parserOptions);
  249. const { url, import: importOption, namedExports } = parserOptions;
  250. switch (type) {
  251. case CSS_MODULE_TYPE:
  252. return new CssParser({
  253. importOption,
  254. url,
  255. namedExports
  256. });
  257. case CSS_MODULE_TYPE_GLOBAL:
  258. return new CssParser({
  259. defaultMode: "global",
  260. importOption,
  261. url,
  262. namedExports
  263. });
  264. case CSS_MODULE_TYPE_MODULE:
  265. return new CssParser({
  266. defaultMode: "local",
  267. importOption,
  268. url,
  269. namedExports
  270. });
  271. case CSS_MODULE_TYPE_AUTO:
  272. return new CssParser({
  273. defaultMode: "auto",
  274. importOption,
  275. url,
  276. namedExports
  277. });
  278. }
  279. });
  280. normalModuleFactory.hooks.createGenerator
  281. .for(type)
  282. .tap(PLUGIN_NAME, generatorOptions => {
  283. validateGeneratorOptions[type](generatorOptions);
  284. return new CssGenerator(generatorOptions);
  285. });
  286. normalModuleFactory.hooks.createModuleClass
  287. .for(type)
  288. .tap(PLUGIN_NAME, (createData, resolveData) => {
  289. if (resolveData.dependencies.length > 0) {
  290. // When CSS is imported from CSS there is only one dependency
  291. const dependency = resolveData.dependencies[0];
  292. if (dependency instanceof CssImportDependency) {
  293. const parent =
  294. /** @type {CssModule} */
  295. (compilation.moduleGraph.getParentModule(dependency));
  296. if (parent instanceof CssModule) {
  297. /** @type {import("../CssModule").Inheritance | undefined} */
  298. let inheritance;
  299. if (
  300. parent.cssLayer !== undefined ||
  301. parent.supports ||
  302. parent.media
  303. ) {
  304. if (!inheritance) {
  305. inheritance = [];
  306. }
  307. inheritance.push([
  308. parent.cssLayer,
  309. parent.supports,
  310. parent.media
  311. ]);
  312. }
  313. if (parent.inheritance) {
  314. if (!inheritance) {
  315. inheritance = [];
  316. }
  317. inheritance.push(...parent.inheritance);
  318. }
  319. return new CssModule({
  320. ...createData,
  321. cssLayer: dependency.layer,
  322. supports: dependency.supports,
  323. media: dependency.media,
  324. inheritance
  325. });
  326. }
  327. return new CssModule({
  328. ...createData,
  329. cssLayer: dependency.layer,
  330. supports: dependency.supports,
  331. media: dependency.media
  332. });
  333. }
  334. }
  335. return new CssModule(createData);
  336. });
  337. }
  338. JavascriptModulesPlugin.getCompilationHooks(
  339. compilation
  340. ).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
  341. if (module instanceof CssModule && module.hot) {
  342. const exports = module.buildInfo.cssData.exports;
  343. const stringifiedExports = JSON.stringify(
  344. JSON.stringify(
  345. Array.from(exports).reduce((obj, [key, value]) => {
  346. obj[key] = value;
  347. return obj;
  348. }, {})
  349. )
  350. );
  351. const hmrCode = Template.asString([
  352. "",
  353. `var __webpack_css_exports__ = ${stringifiedExports};`,
  354. "// only invalidate when locals change",
  355. "if (module.hot.data && module.hot.data.__webpack_css_exports__ && module.hot.data.__webpack_css_exports__ != __webpack_css_exports__) {",
  356. Template.indent("module.hot.invalidate();"),
  357. "} else {",
  358. Template.indent("module.hot.accept();"),
  359. "}",
  360. "module.hot.dispose(function(data) { data.__webpack_css_exports__ = __webpack_css_exports__; });"
  361. ]);
  362. return new ConcatSource(source, "\n", new RawSource(hmrCode));
  363. }
  364. });
  365. const orderedCssModulesPerChunk = new WeakMap();
  366. compilation.hooks.afterCodeGeneration.tap(PLUGIN_NAME, () => {
  367. const { chunkGraph } = compilation;
  368. for (const chunk of compilation.chunks) {
  369. if (CssModulesPlugin.chunkHasCss(chunk, chunkGraph)) {
  370. orderedCssModulesPerChunk.set(
  371. chunk,
  372. this.getOrderedChunkCssModules(chunk, chunkGraph, compilation)
  373. );
  374. }
  375. }
  376. });
  377. compilation.hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, context) => {
  378. hooks.chunkHash.call(chunk, hash, context);
  379. });
  380. compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
  381. const {
  382. chunkGraph,
  383. codeGenerationResults,
  384. moduleGraph,
  385. runtimeTemplate,
  386. outputOptions: {
  387. hashSalt,
  388. hashDigest,
  389. hashDigestLength,
  390. hashFunction
  391. }
  392. } = compilation;
  393. const hash = createHash(/** @type {Algorithm} */ (hashFunction));
  394. if (hashSalt) hash.update(hashSalt);
  395. hooks.chunkHash.call(chunk, hash, {
  396. chunkGraph,
  397. codeGenerationResults,
  398. moduleGraph,
  399. runtimeTemplate
  400. });
  401. const modules = orderedCssModulesPerChunk.get(chunk);
  402. if (modules) {
  403. for (const module of modules) {
  404. hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
  405. }
  406. }
  407. const digest = /** @type {string} */ (hash.digest(hashDigest));
  408. chunk.contentHash.css = nonNumericOnlyHash(
  409. digest,
  410. /** @type {number} */
  411. (hashDigestLength)
  412. );
  413. });
  414. compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
  415. const { chunkGraph } = compilation;
  416. const { hash, chunk, codeGenerationResults, runtimeTemplate } =
  417. options;
  418. if (chunk instanceof HotUpdateChunk) return result;
  419. /** @type {CssModule[] | undefined} */
  420. const modules = orderedCssModulesPerChunk.get(chunk);
  421. if (modules !== undefined) {
  422. const { path: filename, info } = compilation.getPathWithInfo(
  423. CssModulesPlugin.getChunkFilenameTemplate(
  424. chunk,
  425. compilation.outputOptions
  426. ),
  427. {
  428. hash,
  429. runtime: chunk.runtime,
  430. chunk,
  431. contentHashType: "css"
  432. }
  433. );
  434. const undoPath = getUndoPath(
  435. filename,
  436. /** @type {string} */
  437. (compilation.outputOptions.path),
  438. false
  439. );
  440. result.push({
  441. render: () =>
  442. this.renderChunk(
  443. {
  444. chunk,
  445. chunkGraph,
  446. codeGenerationResults,
  447. uniqueName: compilation.outputOptions.uniqueName,
  448. undoPath,
  449. modules,
  450. runtimeTemplate
  451. },
  452. hooks
  453. ),
  454. filename,
  455. info,
  456. identifier: `css${chunk.id}`,
  457. hash: chunk.contentHash.css
  458. });
  459. }
  460. return result;
  461. });
  462. const globalChunkLoading = compilation.outputOptions.chunkLoading;
  463. /**
  464. * @param {Chunk} chunk the chunk
  465. * @returns {boolean} true, when enabled
  466. */
  467. const isEnabledForChunk = chunk => {
  468. const options = chunk.getEntryOptions();
  469. const chunkLoading =
  470. options && options.chunkLoading !== undefined
  471. ? options.chunkLoading
  472. : globalChunkLoading;
  473. return chunkLoading === "jsonp" || chunkLoading === "import";
  474. };
  475. const onceForChunkSet = new WeakSet();
  476. /**
  477. * @param {Chunk} chunk chunk to check
  478. * @param {Set<string>} set runtime requirements
  479. */
  480. const handler = (chunk, set) => {
  481. if (onceForChunkSet.has(chunk)) return;
  482. onceForChunkSet.add(chunk);
  483. if (!isEnabledForChunk(chunk)) return;
  484. set.add(RuntimeGlobals.makeNamespaceObject);
  485. const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
  486. compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
  487. };
  488. compilation.hooks.runtimeRequirementInTree
  489. .for(RuntimeGlobals.hasCssModules)
  490. .tap(PLUGIN_NAME, handler);
  491. compilation.hooks.runtimeRequirementInTree
  492. .for(RuntimeGlobals.ensureChunkHandlers)
  493. .tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
  494. if (!isEnabledForChunk(chunk)) return;
  495. if (
  496. !chunkGraph.hasModuleInGraph(
  497. chunk,
  498. m =>
  499. m.type === CSS_MODULE_TYPE ||
  500. m.type === CSS_MODULE_TYPE_GLOBAL ||
  501. m.type === CSS_MODULE_TYPE_MODULE ||
  502. m.type === CSS_MODULE_TYPE_AUTO
  503. )
  504. ) {
  505. return;
  506. }
  507. set.add(RuntimeGlobals.hasOwnProperty);
  508. set.add(RuntimeGlobals.publicPath);
  509. set.add(RuntimeGlobals.getChunkCssFilename);
  510. });
  511. compilation.hooks.runtimeRequirementInTree
  512. .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
  513. .tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
  514. if (!isEnabledForChunk(chunk)) return;
  515. if (
  516. !chunkGraph.hasModuleInGraph(
  517. chunk,
  518. m =>
  519. m.type === CSS_MODULE_TYPE ||
  520. m.type === CSS_MODULE_TYPE_GLOBAL ||
  521. m.type === CSS_MODULE_TYPE_MODULE ||
  522. m.type === CSS_MODULE_TYPE_AUTO
  523. )
  524. ) {
  525. return;
  526. }
  527. set.add(RuntimeGlobals.publicPath);
  528. set.add(RuntimeGlobals.getChunkCssFilename);
  529. });
  530. }
  531. );
  532. }
  533. /**
  534. * @param {Chunk} chunk chunk
  535. * @param {Iterable<Module>} modules unordered modules
  536. * @param {Compilation} compilation compilation
  537. * @returns {Module[]} ordered modules
  538. */
  539. getModulesInOrder(chunk, modules, compilation) {
  540. if (!modules) return [];
  541. /** @type {Module[]} */
  542. const modulesList = [...modules];
  543. // Get ordered list of modules per chunk group
  544. // Lists are in reverse order to allow to use Array.pop()
  545. const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
  546. const sortedModules = modulesList
  547. .map(module => ({
  548. module,
  549. index: chunkGroup.getModulePostOrderIndex(module)
  550. }))
  551. .filter(item => item.index !== undefined)
  552. .sort(
  553. (a, b) =>
  554. /** @type {number} */ (b.index) - /** @type {number} */ (a.index)
  555. )
  556. .map(item => item.module);
  557. return { list: sortedModules, set: new Set(sortedModules) };
  558. });
  559. if (modulesByChunkGroup.length === 1)
  560. return modulesByChunkGroup[0].list.reverse();
  561. const boundCompareModulesByIdOrIdentifier = compareModulesByIdOrIdentifier(
  562. compilation.chunkGraph
  563. );
  564. /**
  565. * @param {{ list: Module[] }} a a
  566. * @param {{ list: Module[] }} b b
  567. * @returns {-1 | 0 | 1} result
  568. */
  569. const compareModuleLists = ({ list: a }, { list: b }) => {
  570. if (a.length === 0) {
  571. return b.length === 0 ? 0 : 1;
  572. }
  573. if (b.length === 0) return -1;
  574. return boundCompareModulesByIdOrIdentifier(
  575. a[a.length - 1],
  576. b[b.length - 1]
  577. );
  578. };
  579. modulesByChunkGroup.sort(compareModuleLists);
  580. /** @type {Module[]} */
  581. const finalModules = [];
  582. for (;;) {
  583. const failedModules = new Set();
  584. const list = modulesByChunkGroup[0].list;
  585. if (list.length === 0) {
  586. // done, everything empty
  587. break;
  588. }
  589. /** @type {Module} */
  590. let selectedModule = list[list.length - 1];
  591. let hasFailed;
  592. outer: for (;;) {
  593. for (const { list, set } of modulesByChunkGroup) {
  594. if (list.length === 0) continue;
  595. const lastModule = list[list.length - 1];
  596. if (lastModule === selectedModule) continue;
  597. if (!set.has(selectedModule)) continue;
  598. failedModules.add(selectedModule);
  599. if (failedModules.has(lastModule)) {
  600. // There is a conflict, try other alternatives
  601. hasFailed = lastModule;
  602. continue;
  603. }
  604. selectedModule = lastModule;
  605. hasFailed = false;
  606. continue outer; // restart
  607. }
  608. break;
  609. }
  610. if (hasFailed) {
  611. // There is a not resolve-able conflict with the selectedModule
  612. // TODO print better warning
  613. compilation.warnings.push(
  614. new WebpackError(
  615. `chunk ${chunk.name || chunk.id}\nConflicting order between ${
  616. /** @type {Module} */
  617. (hasFailed).readableIdentifier(compilation.requestShortener)
  618. } and ${selectedModule.readableIdentifier(
  619. compilation.requestShortener
  620. )}`
  621. )
  622. );
  623. selectedModule = /** @type {Module} */ (hasFailed);
  624. }
  625. // Insert the selected module into the final modules list
  626. finalModules.push(selectedModule);
  627. // Remove the selected module from all lists
  628. for (const { list, set } of modulesByChunkGroup) {
  629. const lastModule = list[list.length - 1];
  630. if (lastModule === selectedModule) list.pop();
  631. else if (hasFailed && set.has(selectedModule)) {
  632. const idx = list.indexOf(selectedModule);
  633. if (idx >= 0) list.splice(idx, 1);
  634. }
  635. }
  636. modulesByChunkGroup.sort(compareModuleLists);
  637. }
  638. return finalModules;
  639. }
  640. /**
  641. * @param {Chunk} chunk chunk
  642. * @param {ChunkGraph} chunkGraph chunk graph
  643. * @param {Compilation} compilation compilation
  644. * @returns {Module[]} ordered css modules
  645. */
  646. getOrderedChunkCssModules(chunk, chunkGraph, compilation) {
  647. return [
  648. ...this.getModulesInOrder(
  649. chunk,
  650. /** @type {Iterable<Module>} */
  651. (
  652. chunkGraph.getOrderedChunkModulesIterableBySourceType(
  653. chunk,
  654. "css-import",
  655. compareModulesByIdOrIdentifier(chunkGraph)
  656. )
  657. ),
  658. compilation
  659. ),
  660. ...this.getModulesInOrder(
  661. chunk,
  662. /** @type {Iterable<Module>} */
  663. (
  664. chunkGraph.getOrderedChunkModulesIterableBySourceType(
  665. chunk,
  666. "css",
  667. compareModulesByIdOrIdentifier(chunkGraph)
  668. )
  669. ),
  670. compilation
  671. )
  672. ];
  673. }
  674. /**
  675. * @param {CssModule} module css module
  676. * @param {ChunkRenderContext} renderContext options object
  677. * @param {CompilationHooks} hooks hooks
  678. * @returns {Source} css module source
  679. */
  680. renderModule(module, renderContext, hooks) {
  681. const { codeGenerationResults, chunk, undoPath } = renderContext;
  682. const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
  683. const moduleSourceContent =
  684. /** @type {Source} */
  685. (
  686. codeGenResult.sources.get("css") ||
  687. codeGenResult.sources.get("css-import")
  688. );
  689. const cacheEntry = this._moduleFactoryCache.get(moduleSourceContent);
  690. /** @type {Inheritance} */
  691. const inheritance = [[module.cssLayer, module.supports, module.media]];
  692. if (module.inheritance) {
  693. inheritance.push(...module.inheritance);
  694. }
  695. let source;
  696. if (
  697. cacheEntry &&
  698. cacheEntry.undoPath === undoPath &&
  699. cacheEntry.inheritance.every(([layer, supports, media], i) => {
  700. const item = inheritance[i];
  701. if (Array.isArray(item)) {
  702. return layer === item[0] && supports === item[1] && media === item[2];
  703. }
  704. return false;
  705. })
  706. ) {
  707. source = cacheEntry.source;
  708. } else {
  709. const moduleSourceCode =
  710. /** @type {string} */
  711. (moduleSourceContent.source());
  712. const publicPathAutoRegex = new RegExp(
  713. CssUrlDependency.PUBLIC_PATH_AUTO,
  714. "g"
  715. );
  716. /** @type {Source} */
  717. let moduleSource = new ReplaceSource(moduleSourceContent);
  718. let match;
  719. while ((match = publicPathAutoRegex.exec(moduleSourceCode))) {
  720. /** @type {ReplaceSource} */ (moduleSource).replace(
  721. match.index,
  722. (match.index += match[0].length - 1),
  723. undoPath
  724. );
  725. }
  726. for (let i = 0; i < inheritance.length; i++) {
  727. const layer = inheritance[i][0];
  728. const supports = inheritance[i][1];
  729. const media = inheritance[i][2];
  730. if (media) {
  731. moduleSource = new ConcatSource(
  732. `@media ${media} {\n`,
  733. new PrefixSource("\t", moduleSource),
  734. "}\n"
  735. );
  736. }
  737. if (supports) {
  738. moduleSource = new ConcatSource(
  739. `@supports (${supports}) {\n`,
  740. new PrefixSource("\t", moduleSource),
  741. "}\n"
  742. );
  743. }
  744. // Layer can be anonymous
  745. if (layer !== undefined && layer !== null) {
  746. moduleSource = new ConcatSource(
  747. `@layer${layer ? ` ${layer}` : ""} {\n`,
  748. new PrefixSource("\t", moduleSource),
  749. "}\n"
  750. );
  751. }
  752. }
  753. if (moduleSource) {
  754. moduleSource = new ConcatSource(moduleSource, "\n");
  755. }
  756. source = new CachedSource(moduleSource);
  757. this._moduleFactoryCache.set(moduleSourceContent, {
  758. inheritance,
  759. undoPath,
  760. source
  761. });
  762. }
  763. return tryRunOrWebpackError(
  764. () => hooks.renderModulePackage.call(source, module, renderContext),
  765. "CssModulesPlugin.getCompilationHooks().renderModulePackage"
  766. );
  767. }
  768. /**
  769. * @param {RenderContext} renderContext the render context
  770. * @param {CompilationHooks} hooks hooks
  771. * @returns {Source} generated source
  772. */
  773. renderChunk(
  774. {
  775. undoPath,
  776. chunk,
  777. chunkGraph,
  778. codeGenerationResults,
  779. modules,
  780. runtimeTemplate
  781. },
  782. hooks
  783. ) {
  784. const source = new ConcatSource();
  785. for (const module of modules) {
  786. try {
  787. const moduleSource = this.renderModule(
  788. module,
  789. {
  790. undoPath,
  791. chunk,
  792. chunkGraph,
  793. codeGenerationResults,
  794. runtimeTemplate
  795. },
  796. hooks
  797. );
  798. source.add(moduleSource);
  799. } catch (err) {
  800. /** @type {Error} */
  801. (err).message += `\nduring rendering of css ${module.identifier()}`;
  802. throw err;
  803. }
  804. }
  805. chunk.rendered = true;
  806. return source;
  807. }
  808. /**
  809. * @param {Chunk} chunk chunk
  810. * @param {OutputOptions} outputOptions output options
  811. * @returns {TemplatePath} used filename template
  812. */
  813. static getChunkFilenameTemplate(chunk, outputOptions) {
  814. if (chunk.cssFilenameTemplate) {
  815. return chunk.cssFilenameTemplate;
  816. } else if (chunk.canBeInitial()) {
  817. return /** @type {TemplatePath} */ (outputOptions.cssFilename);
  818. }
  819. return /** @type {TemplatePath} */ (outputOptions.cssChunkFilename);
  820. }
  821. /**
  822. * @param {Chunk} chunk chunk
  823. * @param {ChunkGraph} chunkGraph chunk graph
  824. * @returns {boolean} true, when the chunk has css
  825. */
  826. static chunkHasCss(chunk, chunkGraph) {
  827. return (
  828. Boolean(chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")) ||
  829. Boolean(
  830. chunkGraph.getChunkModulesIterableBySourceType(chunk, "css-import")
  831. )
  832. );
  833. }
  834. }
  835. module.exports = CssModulesPlugin;