@plaudit/webpack-extensions 2.18.1 → 2.20.0

package/build/wordpress-scripts-wrapper/AdditionalDependencyInjectorPlugin.d.ts

@@ -1,6 +1,7 @@
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export default class AdditionalDependencyInjectorPlugin implements WebpackPluginInstance {
     private readonly entrypointAdditionalDependencies;
-    constructor(entrypointAdditionalDependencies: string[]);
+    private readonly processingModules;
+    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean);
     apply(compiler: Compiler): void;
 }

package/build/wordpress-scripts-wrapper/AdditionalDependencyInjectorPlugin.js

@@ -7,8 +7,10 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const webpack_1 = require("webpack");
 class AdditionalDependencyInjectorPlugin {
     entrypointAdditionalDependencies;
-    constructor(entrypointAdditionalDependencies) {
+    processingModules;
+    constructor(entrypointAdditionalDependencies, processingModules) {
         this.entrypointAdditionalDependencies = entrypointAdditionalDependencies;
+        this.processingModules = processingModules;
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap("AdditionalDependencyInjectorPlugin", compilation => {
@@ -16,9 +18,10 @@ class AdditionalDependencyInjectorPlugin {
                 name: "AdditionalDependencyInjectorPlugin_ProcessAssets",
                 stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE
             }, compilationAssets => {
+                const usableEntrypointTest = this.processingModules ? /\.mtsx?$/ : /\.tsx?$/;
                 const assetSources = new Map();
                 for (const entrypoint of compilation.entrypoints.values()) {
-                    const req = entrypoint.origins.filter(origin => /\.m?tsx?$/.test(origin.request))[0]?.request;
+                    const req = entrypoint.origins.filter(origin => usableEntrypointTest.test(origin.request))[0]?.request;
                     if (req) {
                         for (const chunk of entrypoint.chunks) {
                             for (const file of chunk.files) {

package/build/wordpress-scripts-wrapper/BlockJSONManagingPlugin.d.ts

@@ -1,8 +1,13 @@
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export default class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private readonly standaloneBlocks;
-    constructor(standaloneBlocks: boolean);
+    private readonly processingModules;
+    private static readonly sourceToOutputMapping;
+    private static readonly moduleSourcesToOutputs;
+    constructor(standaloneBlocks: boolean, processingModules: boolean);
     apply(compiler: Compiler): void;
     findCommonAncestor(...paths: string[]): string[];
     findRelativeRouteBetween(path1: string, path2: string): string;
+    private static hashThingForAsset;
+    private static resolveFilesFromStats;
 }

package/build/wordpress-scripts-wrapper/BlockJSONManagingPlugin.js

@@ -3,83 +3,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const webpack_1 = require("webpack");
 const php_serializer_1 = __importDefault(require("./php-serializer"));
 class BlockJSONManagingPlugin {
     standaloneBlocks;
-    constructor(standaloneBlocks) {
+    processingModules;
+    static sourceToOutputMapping = new Map();
+    static moduleSourcesToOutputs = new Map();
+    constructor(standaloneBlocks, processingModules) {
         this.standaloneBlocks = standaloneBlocks;
+        this.processingModules = processingModules;
     }
     apply(compiler) {
         compiler.hooks.compilation.tap("BlockJSONManagingPlugin", compilation => {
             compilation.hooks.afterProcessAssets.tap("BlockJSONStyleRemappingPlugin_ProcessAssets", compilationAssets => {
-                const stats = compilation.getStats().toJson({
-                    hash: true,
-                    publicPath: true,
-                    assets: true,
-                    chunks: true,
-                    modules: true,
-                    source: true,
-                    errorDetails: false,
-                    timings: false
-                });
-                if (!stats.assets) {
-                    throw new Error("Stats did not include assets despite them being requested");
-                }
-                if (!stats.modules) {
-                    throw new Error("Stats did not include modules despite them being requested");
-                }
-                const assetSourceFiles = new Map(stats.assets
-                    .map(asset => [asset.name, asset.info?.sourceFilename])
-                    .filter((v) => v[0] !== undefined && v[1] !== undefined));
-                const singleFileChunkToOutputName = new Map(stats.assets
-                    .filter((asset) => asset.chunks?.length === 1)
-                    .filter(asset => !asset.name.endsWith('.asset.php'))
-                    .map(asset => [asset.chunks[0], asset.name]));
-                const singleFileInputToOutputName = new Map(stats.modules
-                    .map(module => {
-                    if (module.nameForCondition !== undefined && module.chunks?.length === 1) {
-                        const output = singleFileChunkToOutputName.get(module.chunks[0]);
-                        return output !== undefined ? [module.nameForCondition, output] : undefined;
+                let assetSourceFilesCache = undefined;
+                let singleFileInputToOutputNameAndHashCache = undefined;
+                const sourceFileMappers = () => {
+                    if (singleFileInputToOutputNameAndHashCache === undefined || assetSourceFilesCache === undefined) {
+                        const stats = compilation.getStats().toJson({
+                            hash: true,
+                            publicPath: true,
+                            assets: true,
+                            moduleAssets: true,
+                            chunks: true,
+                            modules: true,
+                            source: true,
+                            errorDetails: false,
+                            timings: false
+                        });
+                        if (!stats.assets) {
+                            throw new Error("Stats did not include assets despite them being requested");
+                        }
+                        if (!stats.modules) {
+                            throw new Error("Stats did not include modules despite them being requested");
+                        }
+                        singleFileInputToOutputNameAndHashCache = BlockJSONManagingPlugin.resolveFilesFromStats(compilationAssets, stats);
+                        assetSourceFilesCache = new Map(stats.assets
+                            .map(asset => [asset.name, asset.info?.sourceFilename])
+                            .filter((v) => v[0] !== undefined && v[1] !== undefined));
                     }
-                    return undefined;
-                })
-                    .filter((v) => v !== undefined));
-                const remapValue = (value, name, dirname) => {
+                    return { assetSourceFiles: assetSourceFilesCache, singleFileInputToOutputNameAndHash: singleFileInputToOutputNameAndHashCache };
+                };
+                const remapValue = (value, name) => {
                     if (value.startsWith("file:")) {
+                        let res = BlockJSONManagingPlugin.sourceToOutputMapping.get(`${name};${value}`);
+                        if (res !== undefined) {
+                            return res;
+                        }
+                        const { assetSourceFiles, singleFileInputToOutputNameAndHash } = sourceFileMappers();
+                        const dirname = node_path_1.default.dirname(assetSourceFiles.get(name) ?? name);
                         const styleInputPath = node_path_1.default.normalize(node_path_1.default.join(compiler.context, dirname, value.substring(5)));
-                        const styleOutputPath = singleFileInputToOutputName.get(styleInputPath);
+                        const styleOutputPath = singleFileInputToOutputNameAndHash.get(styleInputPath);
                         if (styleOutputPath !== undefined) {
                             const prefix = value.startsWith("./", 5) ? "./" : "";
-                            const relativePath = node_path_1.default.relative(node_path_1.default.dirname(name), styleOutputPath);
-                            return `file:${prefix}${relativePath}`;
+                            const relativePath = node_path_1.default.relative(node_path_1.default.dirname(name), styleOutputPath[0]);
+                            const res = [`file:${prefix}${relativePath}`, typeof styleOutputPath[1] === 'string' ? styleOutputPath[1] : styleOutputPath[1]()];
+                            BlockJSONManagingPlugin.sourceToOutputMapping.set(`${name};${value}`, res);
+                            return res;
                         }
                     }
-                    return value;
+                    return [value, ""];
                 };
+                if (this.processingModules) {
+                    for (const [key, value] of sourceFileMappers().singleFileInputToOutputNameAndHash.entries()) {
+                        BlockJSONManagingPlugin.moduleSourcesToOutputs.set(key, value);
+                    }
+                }
                 const blockDirConfigData = {};
-                const mappableKeys = ["editorStyle", "style", "viewStyle", "viewScript", "script", "editorScript"];
+                const mappableKeys = ["editorStyle", "style", "viewStyle", "viewScript", "script", "editorScript", "viewScriptModule", "scriptModule"];
                 for (const [name, asset] of Object.entries(compilationAssets)) {
                     if (name.endsWith("block.json")) {
+                        let compositeHash = "";
                         blockDirConfigData[name] = true;
                         if (asset.constructor.name === 'RawSource') {
-                            const dirname = node_path_1.default.dirname(assetSourceFiles.get(name) ?? name);
                             const json = JSON.parse(asset.source().toString());
                             for (const mappableKey of mappableKeys) {
                                 if (mappableKey in json) {
                                     const unmappedValue = json[mappableKey];
                                     if (Array.isArray(unmappedValue)) {
-                                        json[mappableKey] = unmappedValue.map(value => remapValue(value, name, dirname));
+                                        const remappedValue = unmappedValue.map(value => remapValue(value, name));
+                                        json[mappableKey] = remappedValue.map(([resource]) => resource);
+                                        compositeHash += "~" + remappedValue.map(([_, hash]) => hash).join("~");
                                     }
                                     else if (typeof unmappedValue === 'string') {
-                                        json[mappableKey] = remapValue(unmappedValue, name, dirname);
+                                        const remappedValue = remapValue(unmappedValue, name);
+                                        json[mappableKey] = remappedValue[0];
+                                        compositeHash += "~" + remappedValue[1];
                                     }
                                 }
                             }
+                            if (json["version"]) {
+                                json["version"] = `${json["version"]}-${BlockJSONManagingPlugin.hashThingForAsset(compositeHash)}`;
+                            }
+                            else {
+                                json["version"] = BlockJSONManagingPlugin.hashThingForAsset(compositeHash);
+                            }
                             if (!this.standaloneBlocks && json["plaudit"] !== "simple") {
-                                const sourceDir = node_path_1.default.join(compiler.context, dirname);
+                                const { assetSourceFiles } = sourceFileMappers();
+                                const sourceDir = node_path_1.default.join(compiler.context, node_path_1.default.dirname(assetSourceFiles.get(name) ?? name));
                                 const outputDir = node_path_1.default.join(compiler.outputPath, node_path_1.default.dirname(name));
                                 const stripFilePrefix = (file) => file.startsWith("file:./") ? file.substring(7) : file;
                                 let setupFiles = (json["plaudit"]?.["setup"]
@@ -164,5 +189,36 @@ class BlockJSONManagingPlugin {
         route.push(node_path_1.default.relative(commonAncestor.join(node_path_1.default.sep), path2));
         return route.join(node_path_1.default.sep);
     }
+    static hashThingForAsset(thing) {
+        return node_crypto_1.default.createHash('md5').update(thing).digest("hex").substring(0, 20).toLowerCase();
+    }
+    static resolveFilesFromStats(compilationAssets, stats) {
+        const singleFileChunkToOutputName = new Map(stats.assets
+            .filter((asset) => asset.chunks?.length === 1)
+            .filter(asset => !asset.name.endsWith('.asset.php'))
+            .map(asset => {
+            let assetHash = asset.info.contenthash ?? asset.info.fullhash;
+            if (Array.isArray(assetHash)) {
+                assetHash = BlockJSONManagingPlugin.hashThingForAsset(assetHash.join('~'));
+            }
+            return [asset.chunks[0], [asset.name, assetHash ?? (() => {
+                        const realAsset = compilationAssets[asset.name];
+                        return BlockJSONManagingPlugin.hashThingForAsset(realAsset ? realAsset.source().toString() : Date.now().toString());
+                    })]];
+        }));
+        const res = new Map(stats.modules
+            .map(module => {
+            if (module.nameForCondition !== undefined && module.chunks?.length === 1) {
+                const output = singleFileChunkToOutputName.get(module.chunks[0]);
+                return output !== undefined ? [module.nameForCondition, output] : undefined;
+            }
+            return undefined;
+        })
+            .filter((v) => v !== undefined));
+        for (const [key, value] of BlockJSONManagingPlugin.moduleSourcesToOutputs.entries()) {
+            res.set(key, value);
+        }
+        return res;
+    }
 }
 exports.default = BlockJSONManagingPlugin;

package/build/wordpress-scripts-wrapper.d.ts

@@ -5,12 +5,12 @@ interface AdvancedOutputConfig {
     additionalDependencies?: string[];
     directoryLayout?: 'blocks' | 'extensions';
 }
-interface PlauditWordpressWebpackConfig {
+type PlauditWordpressWebpackConfig = {
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
     verbose?: boolean;
     src: string[] | Record<string, string | AdvancedOutputConfig>;
     stats?: Configuration['stats'];
-}
-declare const _default: (config: PlauditWordpressWebpackConfig, webpackConfig?: Configuration) => Configuration[];
+};
+declare const _default: (config: PlauditWordpressWebpackConfig, webpackConfig?: Configuration[] | Configuration) => Configuration[];
 export = _default;

package/build/wordpress-scripts-wrapper.js

@@ -59,27 +59,28 @@ function resolveLegacyBlockScriptsInFolder(folder) {
     }
     return blockScriptEntrypoints;
 }
-const scriptExtension = /\.m?[jt]sx?$/;
+const scriptWithoutModuleExtension = /\.[jt]sx?$/;
+const scriptWithModuleExtension = /\.m[jt]sx?$/;
 const styleExtension = /\.(p?c|sa)ss$/;
-function scriptOrStyleTest(entryPath) {
+function scriptOrStyleTest(entryPath, scriptExtension) {
     return scriptExtension.test(entryPath) ? "script" : (styleExtension.test(entryPath) ? "style" : "");
 }
-function determineEntrypointType(entrypoint) {
-    let res = scriptOrStyleTest(entrypoint[0]);
+function determineEntrypointType(entrypoint, scriptExtension) {
+    let res = scriptOrStyleTest(entrypoint[0], scriptExtension);
     if (res) {
         return res;
     }
     if (typeof entrypoint[1] === 'string') {
-        return scriptOrStyleTest(entrypoint[1]);
+        return scriptOrStyleTest(entrypoint[1], scriptExtension);
     }
     else if (Array.isArray(entrypoint[1])) {
-        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep), "");
+        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
     }
     else if (typeof entrypoint[1].import === 'string') {
-        return scriptOrStyleTest(entrypoint[1].import);
+        return scriptOrStyleTest(entrypoint[1].import, scriptExtension);
     }
     else {
-        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep), "");
+        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
     }
 }
 function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
@@ -94,8 +95,8 @@ function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
     typeCounts[type] += 1;
     return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
 }
-function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts) {
-    const type = determineEntrypointType(entrypoint);
+function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
+    const type = determineEntrypointType(entrypoint, scriptExtension);
     let potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
     while (entry[potentialKey]) {
         potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
@@ -141,12 +142,10 @@ function disableDefaultURLProcessing(webpackConfig) {
         }
     }
 }
-function injectPostcssConfigOverrides(webpackConfig, variables, verbose) {
+function injectPostcssConfigOverrides(webpackConfig, variables, verbose, processingModules) {
     if (webpackConfig.module?.rules) {
-        const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(verbose, (name) => {
-            return variables(name) ?? (name === 'ENV' ? '' : undefined);
-        });
-        for (const rule of webpackConfig.module.rules) {
+        const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(verbose, name => variables(name) ?? (name === 'ENV' ? '' : undefined));
+        return webpackConfig.module.rules.map(rule => {
             if (isTruthy(rule) && typeof rule === 'object' && Array.isArray(rule.use)) {
                 for (const useItem of rule.use) {
                     if (isTruthy(useItem) && typeof useItem === 'object' && typeof useItem.options === 'object') {
@@ -163,12 +162,14 @@ function injectPostcssConfigOverrides(webpackConfig, variables, verbose) {
                         }
                     }
                 }
-                if (rule.test instanceof RegExp && rule.test.test("index.ts")) { // Then this is the javascript and typescript rule
-                    rule.test = /\.m?[jt]sx?$/; // This hacks in support for mjs and mts files
+                if (rule.test instanceof RegExp && (rule.test.test("index.ts") || rule.test.test("index.mts"))) { // Then this is the javascript and typescript rule
+                    return { ...rule, test: processingModules ? scriptWithModuleExtension : scriptWithoutModuleExtension }; // This hacks in differentiated support for mjs and mts files
                 }
             }
-        }
+            return rule;
+        });
     }
+    return undefined;
 }
 function parseEntrypointsJSON(dir) {
     const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
@@ -195,21 +196,26 @@ function parseEntrypointsJSON(dir) {
         });
     }
 }
-module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
-    testForDuplicatedEntryPaths(config);
-    const { standaloneBlocks = false, variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true' } = config;
-    let variablesFilePath = undefined;
-    let currentVariables = rawVariables ?? {};
-    if (!rawVariables) {
-        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p))[0];
+function processIndividualWebpackConfig(config, webpackConfig, sources) {
+    let scriptExtension;
+    let entrypointFields;
+    const processingModules = webpackConfig.output?.module ?? false;
+    if (processingModules) {
+        scriptExtension = scriptWithModuleExtension;
+        entrypointFields = ["viewScriptModule", "scriptModule"];
     }
+    else {
+        scriptExtension = scriptWithoutModuleExtension;
+        entrypointFields = ["editorStyle", "style", "editorScript", "viewScript", "script"];
+    }
+    const { standaloneBlocks, variablesFilePath, verbose } = config;
+    let currentVariables = config.currentVariables;
     disableDefaultURLProcessing(webpackConfig);
-    injectPostcssConfigOverrides(webpackConfig, name => currentVariables[name], verbose);
-    const sources = Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src);
+    const fixedRules = injectPostcssConfigOverrides(webpackConfig, name => currentVariables[name], verbose, processingModules);
     return sources.map(([src, dest]) => {
-        const srcRoots = typeof dest !== 'string' && dest.withLegacyBlocksIn
+        const srcRoots = (typeof dest !== 'string' && dest.withLegacyBlocksIn
             ? [...src.split(','), ...resolveLegacyBlockScriptsInFolder(dest.withLegacyBlocksIn)]
-            : src.split(',');
+            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === scriptWithModuleExtension.test(s));
         const destPath = typeof dest === 'string' ? dest : dest.destination;
         const srcRoot = srcRoots.length === 1 ? joinPossiblyAbsolutePaths(process.cwd(), src) : srcRoots.map(s => joinPossiblyAbsolutePaths(process.cwd(), s));
         const srcIsDirectory = !Array.isArray(srcRoot) && node_fs_1.default.lstatSync(srcRoot).isDirectory();
@@ -217,7 +223,7 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
         const plugins = webpackConfig.plugins?.filter(isTruthy) ?? [];
         if (process.env["NO_TS_CHECKER"] !== "true") {
             const include = (Array.isArray(srcRoot) ? srcRoot : [srcRoot])
-                .filter(sr => node_path_1.default.extname(sr).length === 0 || scriptOrStyleTest(sr) === "script")
+                .filter(sr => node_path_1.default.extname(sr).length === 0 || scriptOrStyleTest(sr, scriptExtension) === "script")
                 .map(sr => node_path_1.default.extname(sr).length > 0 ? sr : node_path_1.default.join(sr, "**", "*"));
             if (include.length > 0) {
                 plugins.push(new fork_ts_checker_webpack_plugin_1.default({
@@ -233,6 +239,11 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                                 skipLibCheck: true
                             }
                         }
+                    },
+                    issue: {
+                        exclude(issue) {
+                            return issue.code === 'TS18003'; // This hides the "no TypeScript files found" error while still monitoring the directory
+                        }
                     }
                 }));
             }
@@ -245,9 +256,9 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
             plugins.push(new VariablesJSMonitorPlugin_1.default(variablesFilePath));
         }
         if (copyFiles && (typeof dest === 'string' || dest.directoryLayout !== 'extensions')) {
-            plugins.push(new BlockJSONManagingPlugin_1.default(standaloneBlocks));
+            plugins.push(new BlockJSONManagingPlugin_1.default(standaloneBlocks, processingModules));
         }
-        plugins.push(new AdditionalDependencyInjectorPlugin_1.default(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : []));
+        plugins.push(new AdditionalDependencyInjectorPlugin_1.default(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules));
         if (srcIsDirectory && (typeof dest !== 'string' && dest.directoryLayout === 'extensions')) {
             plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.default(srcRoot));
         }
@@ -274,7 +285,7 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                         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"]) {
+                            for (const key of entrypointFields) {
                                 if (key in blockJSON) {
                                     res.push(...mapToRealEntrypoints(blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep));
                                 }
@@ -307,7 +318,7 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                         else {
                             const typeCounts = {};
                             for (const entrypoint of groupedEntrypoints) {
-                                addPotentiallyDuplicatedEntrypointName(currentEntry, entrypoint, typeCounts);
+                                addPotentiallyDuplicatedEntrypointName(currentEntry, entrypoint, typeCounts, scriptExtension);
                             }
                         }
                     }
@@ -343,7 +354,15 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
                 chunkFilename: 'webpack-chunks/[id].js',
                 publicPath: publicPath
             },
-            stats: config.stats ?? 'errors-warnings',
+            module: {
+                ...webpackConfig.module,
+                rules: fixedRules
+            },
+            resolve: {
+                ...webpackConfig.resolve,
+                extensions: processingModules ? ['.mjsx', '.mjs', '.mtsx', '.mts'] : ['.jsx', '.tsx', '.ts', '...']
+            },
+            stats: config.stats,
             plugins: copyFiles
                 ? plugins.map(plugin => plugin.constructor.name === 'CopyPlugin'
                     ? new copy_webpack_plugin_1.default({ patterns: [{ from: standaloneBlocks ? '**/(block.json|*.(php|twig|svg))' : '**/(block.json|*.(asset\.php|svg))',
@@ -361,4 +380,19 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
             }
         };
     });
+}
+module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
+    testForDuplicatedEntryPaths(config);
+    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true' } = config;
+    let variablesFilePath = undefined;
+    const currentVariables = rawVariables ?? {};
+    if (!rawVariables) {
+        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p))[0];
+    }
+    const cfg = { currentVariables, standaloneBlocks, stats, variablesFilePath, verbose };
+    const sources = Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src);
+    if (Array.isArray(webpackConfig)) {
+        return webpackConfig.flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources));
+    }
+    return processIndividualWebpackConfig(cfg, webpackConfig, sources);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.18.1",
+  "version": "2.20.0",
   "scripts": {
     "prepublishOnly": "rm -rf build && mkdir build && tsc",
     "build": "tsc",
@@ -19,28 +19,28 @@
   },
   "devDependencies": {
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^20.11.30",
+    "@types/node": "^20.12.10",
     "@types/tapable": "^2.2.7",
     "@types/webpack": "^5.28.5",
     "@types/webpack-sources": "^3.2.3",
     "postcss-load-config": "^4.0.2",
     "postcss-loader": "^7.3.4",
     "ts-node": "^10.9.2",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.5"
   },
   "dependencies": {
     "@plaudit/postcss-color-function": "^5.0.0",
     "@plaudit/postcss-silent-extend": "^3.0.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
     "@plaudit/postcss-variables": "^1.0.0",
-    "@wordpress/scripts": "^27.5.0",
-    "autoprefixer": "^10.4.18",
+    "@wordpress/scripts": "^27.8.0",
+    "autoprefixer": "^10.4.19",
     "browser-sync": "^3.0.2",
     "clean-webpack-plugin": "^4.0.0",
     "copy-webpack-plugin": "^12.0.2",
-    "cssnano": "^6.1.1",
+    "cssnano": "^6.1.2",
     "eslint": "^8.57.0",
-    "eslint-plugin-jsdoc": "^48.2.1",
+    "eslint-plugin-jsdoc": "^48.2.3",
     "fork-ts-checker-webpack-plugin": "^9.0.2",
 	"http-proxy-middleware": "^3.0.0-beta.1",
     "postcss": "^8.4.38",