@plaudit/webpack-extensions 2.1.3 → 2.1.4

package/build/wordpress-scripts-wrapper.js

@@ -14,29 +14,76 @@ const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-e
 function joinPossiblyAbsolutePaths(...paths) {
     return paths.reduce((res, p) => !res || node_path_1.default.isAbsolute(p) ? p : node_path_1.default.join(res, p), '') || '.';
 }
-function addEntryPointWithMapper(entrypoints, entrypoint, dir, mapper = (entrypoint) => entrypoint) {
-    for (const ep of Array.isArray(entrypoint) ? entrypoint : [entrypoint]) {
-        const mapped = joinPossiblyAbsolutePaths(dir, mapper(ep));
-        if (node_fs_1.default.existsSync(mapped)) {
-            const parsedEntrypoint = node_path_1.default.parse(mapped);
-            entrypoints[joinPossiblyAbsolutePaths(node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name)] = { import: mapped };
-        }
-    }
+function mapToRealEntrypoints(entrypoint, dir, mapper = (entrypoint) => entrypoint) {
+    return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
+        .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
+        .filter(ep => node_fs_1.default.existsSync(ep))
+        .map(ep => {
+        const parsedEntrypoint = node_path_1.default.parse(ep);
+        return [joinPossiblyAbsolutePaths(node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep }];
+    });
 }
 function isTruthy(value) {
     return !!value;
 }
-module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
+function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
     const seenPaths = new Map();
-    for (const bundleName of (Array.isArray(config.src) ? config.src : Object.values(config.src))) {
-        const key = bundleName.substring(0, bundleName.length - node_path_1.default.extname(bundleName).length);
+    for (const entrypoint of entrypoints) {
+        const entrypointName = entrypointNameExtractor(entrypoint);
+        const key = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
         let seen = seenPaths.get(key);
         if (seen === undefined) {
             seenPaths.set(key, seen = []);
         }
-        seen.push(bundleName);
-        node_path_1.default.basename(bundleName, node_path_1.default.extname(bundleName));
+        seen.push(entrypoint);
+    }
+    return seenPaths;
+}
+const scriptExtension = /\.[jt]sx?$/;
+const styleExtension = /\.(p?c|sa)ss$/;
+function scriptOrStyleTest(entryPath) {
+    return scriptExtension.test(entryPath) ? "script" : (styleExtension.test(entryPath) ? "style" : "");
+}
+function determineEntrypointType(entrypoint) {
+    let res = scriptOrStyleTest(entrypoint[0]);
+    if (res) {
+        return res;
+    }
+    if (typeof entrypoint[1] === 'string') {
+        return scriptOrStyleTest(entrypoint[1]);
+    }
+    else if (Array.isArray(entrypoint[1])) {
+        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep), "");
+    }
+    else if (typeof entrypoint[1].import === 'string') {
+        return scriptOrStyleTest(entrypoint[1].import);
+    }
+    else {
+        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep), "");
     }
+}
+function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
+    const entrypointBasename = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
+    const parts = [];
+    if (type) {
+        parts.push(type);
+    }
+    if (typeCounts[type] ?? (typeCounts[type] = 0)) {
+        parts.push(typeCounts[type].toString());
+    }
+    typeCounts[type] += 1;
+    return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
+}
+function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts) {
+    const type = determineEntrypointType(entrypoint);
+    let potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
+    while (entry[potentialKey]) {
+        potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
+    }
+    entry[potentialKey] = entrypoint[1];
+}
+module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
+    const seenPaths = groupEntrypointsByAssetFile(Array.isArray(config.src) ? config.src : Object.values(config.src), bn => bn);
     let projectPrefix = undefined;
     let duplicatedPaths = "";
     for (const sameNamePaths of seenPaths.values()) {
@@ -59,7 +106,7 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
         console.error(`Encountered multiple paths that produce the same effective bundle name:${duplicatedPaths}`);
         process.exit(1);
     }
-    const { variables = ["variables.js", "preprocess/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p)).map(p => require(p))[0] ?? {}, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true' } = config;
+    const { variables = ["variables.js", "src/site/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p)).map(p => require(p))[0] ?? {}, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true' } = config;
     const cssLoader = require.resolve('css-loader');
     if (cssLoader && webpackConfig.module?.rules) {
         for (const rule of webpackConfig.module.rules) {
@@ -138,37 +185,39 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
         }
         let entry;
         if (srcIsDirectory) {
-            entry = node_fs_1.default.readdirSync(srcRoot, 'utf8')
+            const rawEntrypoints = node_fs_1.default.readdirSync(srcRoot, 'utf8')
                 .map(dir => joinPossiblyAbsolutePaths(srcRoot, dir))
                 .filter(dir => node_fs_1.default.statSync(dir).isDirectory())
-                .reduce((entrypoints, dir) => {
+                .flatMap(dir => {
+                const res = [];
                 try {
                     const blockJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'block.json'), 'utf8'));
                     for (const key of ["editorStyle", "style", "editorScript", "viewScript", "script"]) {
                         if (key in blockJSON) {
-                            addEntryPointWithMapper(entrypoints, blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep);
+                            res.push(...mapToRealEntrypoints(blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep));
                         }
                     }
+                    return res;
                 }
                 catch (e) {
                     try {
                         const packageJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                        addEntryPointWithMapper(entrypoints, packageJSON['main'], dir);
-                        addEntryPointWithMapper(entrypoints, packageJSON['style'], dir);
+                        res.push(...mapToRealEntrypoints(packageJSON['main'], dir));
+                        res.push(...mapToRealEntrypoints(packageJSON['style'], dir));
                     }
                     catch (e) {
                         try {
                             const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
                             if (Array.isArray(entrypointsJSON)) {
-                                addEntryPointWithMapper(entrypoints, entrypointsJSON, dir);
+                                res.push(...mapToRealEntrypoints(entrypointsJSON, dir));
                             }
                             else {
                                 for (const [name, config] of Object.entries(entrypointsJSON)) {
                                     if (typeof config === 'string') {
-                                        entrypoints[name] = joinPossiblyAbsolutePaths(dir, config);
+                                        res.push([name, joinPossiblyAbsolutePaths(dir, config)]);
                                     }
                                     else if (Array.isArray(config)) {
-                                        entrypoints[name] = config.map(c => joinPossiblyAbsolutePaths(dir, c));
+                                        res.push([name, config.map(c => joinPossiblyAbsolutePaths(dir, c))]);
                                     }
                                     else {
                                         if (typeof config.import === 'string') {
@@ -177,7 +226,7 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                                         else {
                                             config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
                                         }
-                                        entrypoints[name] = config;
+                                        res.push([name, config]);
                                     }
                                 }
                             }
@@ -187,8 +236,21 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                         }
                     }
                 }
-                return entrypoints;
-            }, {});
+                return res;
+            });
+            const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(rawEntrypoints, e => e[0]);
+            entry = {};
+            for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
+                if (groupedEntrypoints.length === 1) {
+                    entry[groupedEntrypoints[0][0]] = groupedEntrypoints[0][1];
+                }
+                else {
+                    const typeCounts = {};
+                    for (const entrypoint of groupedEntrypoints) {
+                        addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts);
+                    }
+                }
+            }
         }
         else {
             const baseDest = node_path_1.default.basename(dest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "scripts": {
     "prepublishOnly": "rm -rf build && mkdir build && tsc",
     "build": "tsc",