@plaudit/webpack-extensions 2.63.2 → 2.65.0

package/build/wordpress-scripts-wrapper.js

@@ -10,6 +10,7 @@ const common_config_helpers_1 = require("./utils/common-config-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
 const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
 const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
+const EnhancedDynamicEntryPlugin_1 = require("./plugins/EnhancedDynamicEntryPlugin");
 const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
 const ExtensionsConfigFileGeneratorPluginV1_1 = require("./plugins/ExtensionsConfigFileGeneratorPluginV1");
 const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
@@ -22,6 +23,7 @@ const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
 const static_configs_1 = require("./plugins/static-configs");
 const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
+const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
 const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
 function resolveLegacyBlockScriptsInFolder(folder) {
@@ -207,21 +209,31 @@ function buildVerifiedConfig(config) {
             .map(([k, v]) => {
             return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
         });
+    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, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, processTranslationConfigs, combineAssetMetadata,
+        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, plainEntrypointsHandlePrefix, srcDir, srcPrefixes, useUnifiedLoader
+    };
     // Destination -> source map
     const allocatedDestinations = {};
     const partiallyVerifiedSources = rawSources.map(rawSource => {
-        const destination = rawSource[1].destination;
+        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false } = rawSource[1];
+        const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn };
         const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
             ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};
         if (destination !== undefined) {
             const effectiveDestination = toEffectiveWebpackDestination(destination);
             allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically-declared destinations
-            return [rawSource[0], { ...rawSource[1], locations, destination, effectiveDestination, staticallyDeclaredDestination: true }];
+            return [rawSource[0], { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true }];
         }
         else {
             const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...rawSource[1], locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
+            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
@@ -234,15 +246,6 @@ function buildVerifiedConfig(config) {
     const sources = partiallyVerifiedSources
         .map(entry => finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations));
     testForDuplicatedEntryPaths(sources);
-    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, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, processTranslationConfigs, combineAssetMetadata,
-        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, plainEntrypointsHandlePrefix, srcDir, srcPrefixes, useUnifiedLoader
-    };
     return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
 }
 function toEffectiveWebpackDestination(destination) {
@@ -284,6 +287,7 @@ function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpecte
     while (derivedDestination in allocatedDestinations && allocatedDestinations[derivedDestination] !== entry[0]) {
         derivedDestination = `${filename}_${++count}${extension}`; // We don't want to add deduplication indexes unless absolutely necessary
     }
+    entry[1].additionalDependencies?.sort();
     allocatedDestinations[derivedDestination] = entry[0];
     return [entry[0], { ...entry[1], destination: derivedDestination }];
 }
@@ -356,11 +360,12 @@ function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins)
         }
     }
 }
-function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, sourceType) {
-    const { assumeGlobalizedPlauditLibraries, combineAssetMetadata, externals, extensionsVersion, plainEntrypointsVersion, } = config;
+function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies) {
+    const { externals } = config;
     const processingModules = webpackConfig.output?.module ?? false;
     const plugins = webpackConfig.plugins?.filter(v => !!v)
         .filter(plugin => plugin.constructor.name !== 'RtlCssPlugin')
+        .filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin')
         .map(plugin => {
         if (plugin.constructor.name === 'MiniCssExtractPlugin') {
             return new plugin.constructor({
@@ -374,35 +379,33 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     })
         ?? [];
     plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
-    if (dest.bundleAnalyzer) {
+    if (bundleAnalyzer) {
         plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static' }));
     }
-    handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins);
     const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
         stage: webpack_remove_empty_scripts_1.default.STAGE_AFTER_PROCESS_PLUGINS,
         extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss'],
         ignore: /block\.json/
     });
     plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
-    plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
-    plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
+    if (config.useWebpackResourceFiltering) {
+        plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
+    }
     plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(config));
     const dependencyExtractionPluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
     if (dependencyExtractionPluginIndex === -1) {
         console.error("Cannot apply externals when they have been disabled via CLI flag. This will greatly increase bundle size and will likely cause the build to fail");
+        throw new Error();
     }
-    else {
-        const localAssumeGlobalizedPlauditLibraries = dest.assumeGlobalizedPlauditLibraries ?? assumeGlobalizedPlauditLibraries;
-        const wantsGroupedDepData = combineAssetMetadata
-            && ((sourceType === "blocks" /* SourceType.blocks */)
-                || (extensionsVersion > 1 && sourceType === "extensions" /* SourceType.extensions */)
-                || (plainEntrypointsVersion > 1 && sourceType === "plain" /* SourceType.plain */));
-        const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, dest.externalize);
-        plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
-        plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
-    }
+    const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, assumeGlobalizedPlauditLibraries, true, externalize);
+    plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
     plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
-    return { plugins, removeEmptyScriptsPlugin };
+    return {
+        plugins, removeEmptyScriptsPlugin,
+        makeAdditionalDependencyInjectorPlugin(referencePlugin) {
+            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(additionalDependencies ?? [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
+        }
+    };
 }
 function commonConfigProcessingPrep(config, webpackConfig) {
     let scriptExtension; // This is only used in non-block contexts. It might not actually be necessary, but it is good to have
@@ -439,11 +442,16 @@ function commonConfigProcessingPrep(config, webpackConfig) {
         updateCurrentVariables: (value) => currentVariables = value
     };
 }
-//TODO: Try using context to avoid needing to cobble dest paths together?
-function processIndividualWebpackConfig(config, webpackConfig, sources) {
+function destToKey(dest) {
+    const externalize = typeof dest.externalize === 'object' && dest.externalize !== undefined
+        ? (Array.isArray(dest.externalize) ? dest.externalize.join("_") : (dest.externalize ? Object.entries(dest.externalize).flat().sort().join() : "undefined"))
+        : dest.externalize?.toString() ?? "undefined";
+    return [dest.additionalDependencies.join("_"), dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize, dest.withLegacyBlocksIn].join("~");
+}
+function processIndividualWebpackConfig(config, webpackConfig, sources, canClean) {
     const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
     const { processingModules, scriptExtension } = commonConfig;
-    return sources.map(([src, dest]) => {
+    const allSrcRoots = sources.map(([src, dest]) => {
         const srcRoots = (dest.withLegacyBlocksIn
             ? [...src.split(','), ...resolveLegacyBlockScriptsInFolder(node_path_1.default.join(config.srcDir, dest.withLegacyBlocksIn))]
             : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === shared_1.scriptWithModuleExtension.test(s));
@@ -452,108 +460,110 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         if (srcIsDirectory === undefined) {
             return undefined;
         }
-        switch ((0, shared_1.determineCurrentSourceType)(dest, srcIsDirectory)) {
-            case "blocks" /* SourceType.blocks */: {
+        return { srcRoots, src, dest, srcRoot, srcIsDirectory };
+    }).filter(a => a !== undefined);
+    const groupedSrcRoots = {};
+    for (const entry of allSrcRoots) {
+        const key = destToKey(entry.dest);
+        (groupedSrcRoots[key] ?? (groupedSrcRoots[key] = [])).push(entry);
+    }
+    const batches = Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem);
+    return batches.map(currentBatch => {
+        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies } = currentBatch[0].dest;
+        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies);
+        handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
+        for (const { dest, src, srcIsDirectory, srcRoot } of currentBatch) {
+            let plugin;
+            const sourceType = (0, shared_1.determineCurrentSourceType)(dest, srcIsDirectory);
+            if (sourceType === "blocks" /* SourceType.blocks */) {
                 if (!srcIsDirectory) {
-                    return undefined;
+                    continue;
+                }
+                plugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, removeEmptyScriptsPlugin, webpackConfig.context ?? process.cwd(), (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
+                plugins.push(plugin);
+                if (config.processTranslationConfigs && !processingModules) {
+                    plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination, plugin));
                 }
-                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "blocks" /* SourceType.blocks */);
-                return makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins);
             }
-            case "extensions" /* SourceType.extensions */: {
+            else if (sourceType === "extensions" /* SourceType.extensions */) {
                 if (!srcIsDirectory) {
-                    return undefined;
+                    continue;
                 }
-                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "extensions" /* SourceType.extensions */);
-                return makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins);
+                const entry = async () => {
+                    const rawEntrypoints = [];
+                    for await (const dirent of await promises_1.default.opendir(srcRoot)) {
+                        if (dirent.isFile() && !dirent.name.startsWith("~")) {
+                            if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
+                                const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
+                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: "entrypoint-v2" }]);
+                            }
+                        }
+                    }
+                    return Object.fromEntries(rawEntrypoints);
+                };
+                plugin = config.extensionsVersion > 1
+                    ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest, webpackConfig.context ?? process.cwd(), entry)
+                    : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(config, dest.destination, webpackConfig.context ?? process.cwd(), entry);
+                plugins.push(plugin);
             }
-            case "plain" /* SourceType.plain */:
+            else if (sourceType === "plain" /* SourceType.plain */) {
                 if (!srcIsDirectory) {
                     const primarySrcRoot = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
                     if (!scriptExtension.test(primarySrcRoot) && !shared_1.styleExtension.test(primarySrcRoot)) {
-                        return undefined;
+                        continue;
                     }
                 }
-                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "plain" /* SourceType.plain */);
+                const baseDest = stripExtension(dest.destination);
                 if (config.plainEntrypointsVersion > 1) {
-                    return makePlainV2WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory);
+                    const entry = srcIsDirectory // This being true implies that srcRoot is not an array
+                        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
+                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } });
+                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
                 }
-                return makePlainV1WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory);
-        }
-    }).filter(cfg => cfg !== undefined);
-}
-function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
-    const { processingModules } = commonConfig;
-    const blockJSONManagingPlugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, plugins.find(p => p instanceof webpack_remove_empty_scripts_1.default), webpackConfig.context ?? process.cwd(), (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
-    plugins.push(blockJSONManagingPlugin);
-    if (config.processTranslationConfigs && !processingModules) {
-        plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination));
-    }
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, {}, plugins);
-}
-function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
-    if (config.extensionsVersion > 1) {
-        const entry = async () => {
-            const rawEntrypoints = [];
-            for await (const dirent of await promises_1.default.opendir(srcRoot)) {
-                if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                    if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
-                        const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                        rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: "entrypoint-v2" }]);
+                else {
+                    if (srcIsDirectory) {
+                        console.error("Using directory mode with legacy plain entrypoint handling is not supported");
+                        continue;
                     }
+                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, webpackConfig.context ?? process.cwd(), () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } }));
                 }
+                plugins.push(plugin);
             }
-            return Object.fromEntries(rawEntrypoints);
-        };
-        plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest, webpackConfig.context ?? process.cwd(), entry));
-        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, {}, plugins);
-    }
-    else {
-        const plugin = new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination);
-        plugins.push(plugin);
-        const entry = async () => {
-            const rawEntrypoints = [];
-            for await (const dirent of await promises_1.default.opendir(srcRoot)) {
-                if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                    if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
-                        const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                        rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), file]);
-                    }
-                }
+            else {
+                console.error("Unrecognized sourceType");
+                continue;
             }
-            return Object.fromEntries(rawEntrypoints);
-        };
-        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, entry, plugins);
-    }
-}
-function makePlainV1WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
-    const baseDest = stripExtension(dest.destination);
-    const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
-        : () => ({ [baseDest]: srcRoot });
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins);
-}
-function makePlainV2WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
-    const baseDest = stripExtension(dest.destination);
-    const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
-        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } });
-    const requester = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, dest.locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
-    plugins.push(requester);
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, {}, plugins);
+            plugins.push(makeAdditionalDependencyInjectorPlugin(plugin));
+            const canCopyFiles = srcIsDirectory && src !== dest.destination;
+            if (canCopyFiles) {
+                plugins.push(new copy_webpack_plugin_1.default({
+                    patterns: [{
+                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)',
+                            to: dest.destination,
+                            context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
+                        }]
+                }));
+            }
+        }
+        plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
+        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2);
+    }).filter(cfg => cfg !== undefined);
 }
 function stripExtension(filepath) {
     return node_path_1.default.join(node_path_1.default.dirname(filepath), node_path_1.default.basename(filepath, node_path_1.default.extname(filepath)));
 }
 module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
     const { cfg, sources } = buildVerifiedConfig(config);
+    if (Array.isArray(webpackConfig) && (0, shared_1.hasAtLeastOneItem)(webpackConfig)) {
+        webpackConfig = webpackConfig[0];
+    }
     if (Array.isArray(webpackConfig)) {
         return webpackConfig.toSorted((a, b) => {
             if (a.output?.module) {
                 return b.output?.module ? 0 : -1;
             }
             return b.output?.module ? 1 : 0;
-        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources));
+        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources, false));
     }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources);
+    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.63.2",
+  "version": "2.65.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -39,7 +39,6 @@
     "@wordpress/scripts": "^30.23.0",
     "autoprefixer": "^10.4.21",
     "browser-sync": "^3.0.4",
-    "clean-webpack-plugin": "^4.0.0",
     "copy-webpack-plugin": "^10.2.4",
     "cssnano": "^6.1.2",
     "eslint-plugin-jsdoc": "^48.11.0",

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.d.ts

@@ -1,19 +0,0 @@
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-import type { ExtensibleEntryObject } from "../utils/common-config-helpers";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
-import { Compilation, Compiler, Entrypoint } from "webpack";
-export type EntryProvider<M> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
-export declare abstract class AbstractMultiPhaseLibraryAndEntryPlugin<M> extends AbstractMultiPhaseLibraryPlugin {
-    private readonly context;
-    private readonly entry;
-    protected readonly entryMetadataRecord: {
-        [entryName: string]: M;
-    };
-    protected constructor(libraryType: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
-    apply(compiler: Compiler): void;
-    protected getRelevantEntrypoints(compilation: Compilation): {
-        entrypoint: Entrypoint;
-        srcPath: string;
-        metadata: M;
-    }[];
-}

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts

@@ -1,14 +0,0 @@
-import { Compilation, Compiler, type WebpackPluginInstance } from "webpack";
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-export declare abstract class AbstractMultiPhaseLibraryPlugin implements WebpackPluginInstance {
-    readonly libraryType: string;
-    private readonly semaphores;
-    protected static readonly phaseTwoAttached: {
-        [key in string]: any;
-    };
-    protected readonly id: string;
-    protected constructor(libraryType: string, semaphores: PseudoSemaphore<any>[]);
-    apply(compiler: Compiler): void;
-    protected resetSemaphores(): void;
-    protected abstract attachSecondPhase(compilation: Compilation): void;
-}

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractMultiPhaseLibraryPlugin = void 0;
-const webpack_1 = require("webpack");
-class AbstractMultiPhaseLibraryPlugin {
-    libraryType;
-    semaphores;
-    static phaseTwoAttached = {};
-    id;
-    constructor(libraryType, semaphores) {
-        this.libraryType = libraryType;
-        this.semaphores = semaphores;
-        this.id = Math.random().toString();
-    }
-    apply(compiler) {
-        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.libraryType);
-        for (const semaphore of this.semaphores) {
-            semaphore.register(this.id);
-        }
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = false;
-            this.resetSemaphores();
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType]) {
-                    AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = this;
-                    this.attachSecondPhase(compilation);
-                }
-            });
-        });
-    }
-    resetSemaphores() {
-        for (const semaphore of this.semaphores) {
-            semaphore.reset(this.id);
-        }
-    }
-}
-exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;