weboptimizer 4.0.45 → 4.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weboptimizer",
-  "version": "4.0.45",
+  "version": "4.0.47",
   "description": "A generic web optimizer, (module) bundler and development environment.",
   "keywords": [
     "webpack",
@@ -94,7 +94,7 @@
     "babel-loader": "^10.1.1",
     "babel-plugin-polyfill-corejs3": "^1.0.0",
     "babel-plugin-transform-rewrite-imports": "^1.5.4",
-    "clientnode": "4.0.1479",
+    "clientnode": "4.0.1480",
     "core-js": "^3.49.0",
     "ejs": "^6.0.1",
     "exports-loader": "^5.0.0",

package/webpackConfigurator.js

@@ -17,6 +17,7 @@
 */
 // region imports
 import { convertToValidVariableName, evaluate, escapeRegularExpressions, extend, importFilesystemAPI, isFileSync, isObject, isPlainObject, Logger, mask, optionalImport, represent, UTILITY_SCOPE } from 'clientnode';
+import { rm, writeFile } from 'fs/promises';
 import { extname, join, relative, resolve } from 'path';
 import util from 'util';
 import webpack from 'webpack';
@@ -762,6 +763,70 @@ if (configuration.path.configuration.json) try {
 } catch {
   log.debug('Optional configuration file', `"${configuration.path.configuration.json}" not available.`);
 }
+
+// region collapse multi-module ("multi-main") entry chunks into a barrel
+/*
+    NOTE: Webpack awaits a single (async) entry module before completing the
+    startup evaluation but does NOT await async modules that are referenced as
+    part of an array ("multi-main") entry chunk. As a consequence any
+    top-level "await" (async module) reachable from such an entry - and every
+    side effect depending on it, like jest's synchronous "describe" / "test"
+    registration - would run only after the synchronous startup phase already
+    finished (leading for example to "Cannot nest a describe inside a test").
+
+    To keep evaluation deterministic we collapse every chunk which bundles
+    more than one module into a single generated barrel module which webpack
+    treats (and, when async, awaits) as a whole. Re-exporting via "export *"
+    preserves the (named) exports of all bundled modules while guaranteeing
+    each one is evaluated in the given order.
+
+    NOTE: The barrel and every module it bundles are additionally forced to
+    "sideEffects: true" (see the corresponding module rule below). Otherwise a
+    consuming package declaring "sideEffects": false (e.g. a test bundle whose
+    exports are never imported) would have its bundled modules tree-shaken away
+    completely - resulting for example in a test bundle without any registered
+    test.
+*/
+const generatedBarrelModuleFilePaths = [];
+const barrelledModuleFilePaths = [];
+const normalizedEntryInjection = {};
+for (const [chunkName, moduleIDs] of Object.entries(configuration.injection.entry.normalized)) if (Array.isArray(moduleIDs) && moduleIDs.length > 1) {
+  const barrelModuleFilePath = resolve(configuration.path.context, `.__${convertToValidVariableName(chunkName)}__.barrel.mjs`);
+  await writeFile(barrelModuleFilePath, moduleIDs.map(moduleID => {
+    const specifier = stripLoader(moduleID);
+    const relativeOrAbsoluteSpecifier = specifier.startsWith('.') || specifier.startsWith('/') ? specifier : `./${specifier}`;
+    barrelledModuleFilePaths.push(resolve(configuration.path.context, relativeOrAbsoluteSpecifier));
+    return `export * from ${JSON.stringify(relativeOrAbsoluteSpecifier)}`;
+  }).join('\n') + '\n', {
+    encoding: configuration.encoding
+  });
+  generatedBarrelModuleFilePaths.push(barrelModuleFilePath);
+  normalizedEntryInjection[chunkName] = [`./${relative(configuration.path.context, barrelModuleFilePath)}`];
+} else normalizedEntryInjection[chunkName] = moduleIDs;
+if (generatedBarrelModuleFilePaths.length) pluginInstances.push({
+  apply: compiler => {
+    const removeGeneratedBarrelModules = async () => {
+      for (const filePath of generatedBarrelModuleFilePaths) try {
+        await rm(filePath, {
+          force: true
+        });
+      } catch (error) {
+        log.debug('Removing generated barrel entry module ' + `"${filePath}" failed:`, represent(error));
+      }
+    };
+
+    /*
+        NOTE: "shutdown" is an "AsyncSeriesHook" fired (and awaited) by
+        "compiler.close()" for both one-shot builds and watch-mode
+        teardown, so "tapPromise" guarantees the (async) removal finishes
+        before the process exits. "watchClose" would be a "SyncHook" which
+        cannot await a promise-based cleanup, hence it is not used here.
+    */
+    compiler.hooks.shutdown.tapPromise('WebOptimizerRemoveGeneratedBarrelModules', removeGeneratedBarrelModules);
+  }
+});
+// endregion
+
 export let webpackConfiguration = extend(true, {
   bail: !configuration.givenCommandLineArguments.includes('--watch'),
   context: configuration.path.context,
@@ -791,7 +856,7 @@ export let webpackConfiguration = extend(true, {
     typescript: false
   },
   // region input
-  entry: configuration.injection.entry.normalized,
+  entry: normalizedEntryInjection,
   externals: configuration.injection.external.modules,
   resolve: {
     alias: module.aliases,
@@ -843,7 +908,17 @@ export let webpackConfiguration = extend(true, {
   // endregion
   mode: configuration.debug ? 'development' : 'production',
   module: {
-    rules: module.additional.pre.map(evaluateAdditionalLoaderConfiguration).concat(loader.ejs, loader.script, loader.html.main, loader.html.ejs, loader.html.html, loader.style, loader.font.eot, loader.font.svg, loader.font.ttf, loader.font.woff, loader.image, loader.data, module.additional.post.map(evaluateAdditionalLoaderConfiguration))
+    rules:
+    /*
+        Force the generated barrel entry modules and every module
+        they bundle to be treated as side-effectful so a consuming
+        package declaring "sideEffects": false does not get them
+        tree-shaken away (which would empty e.g. a test bundle).
+    */
+    (generatedBarrelModuleFilePaths.length ? [{
+      include: generatedBarrelModuleFilePaths.concat(barrelledModuleFilePaths),
+      sideEffects: true
+    }] : []).concat(module.additional.pre.map(evaluateAdditionalLoaderConfiguration)).concat(loader.ejs, loader.script, loader.html.main, loader.html.ejs, loader.html.html, loader.style, loader.font.eot, loader.font.svg, loader.font.ttf, loader.font.woff, loader.image, loader.data, module.additional.post.map(evaluateAdditionalLoaderConfiguration))
   },
   node: configuration.nodeEnvironment,
   optimization: {