@plaudit/webpack-extensions 2.63.1 → 2.64.0

package/build/utils/common-config-helpers.js

@@ -11,7 +11,6 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
-const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 let isInThemeCache = undefined;
 function isInTheme() {
     return isInThemeCache ?? (isInThemeCache = node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), "theme.json")));
@@ -122,7 +121,6 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             if (!dirent.isDirectory()) {
                 continue;
             }
-            //TODO: It should be possible to handle all block.json files simultaneously, which would allow for better detection of repeated code
             const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
             loadingEntrypoints.push(new Promise(async (resolve) => {
                 const rawEntrypoints = [];
@@ -265,8 +263,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         return currentEntry;
     };
 }
-function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins) {
-    const { standaloneBlocks, variablesFilePath } = config;
+function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externalize, plugins) {
+    const { variablesFilePath } = config;
     const { fixedRules, processingModules, updateCurrentVariables } = commonConfig;
     const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir);
     let publicPath = webpackConfig.output?.publicPath;
@@ -281,12 +279,6 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
         }
     }
     let viableRoots = [...(Array.isArray(webpackConfig.context) ? webpackConfig.context : [webpackConfig.context ?? process.cwd()])];
-    if (Array.isArray(srcRoot)) {
-        viableRoots.push(...(srcIsDirectory ? srcRoot : srcRoot.map(s => node_path_1.default.dirname(s))));
-    }
-    else {
-        viableRoots.push(srcIsDirectory ? srcRoot : node_path_1.default.dirname(srcRoot));
-    }
     let wpContentHolderDirectory = process.cwd();
     while (wpContentHolderDirectory.length > 5) {
         if (node_path_1.default.basename(wpContentHolderDirectory) === 'wp-content') {
@@ -301,10 +293,10 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
     const distinctViableRoots = new Set();
     viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
     let outputLibrary;
-    if (typeof dest === 'object' && dest.externalize) {
-        if (Array.isArray(dest.externalize) || typeof dest.externalize === 'string') {
+    if (externalize) {
+        if (Array.isArray(externalize) || typeof externalize === 'string') {
             outputLibrary = {
-                name: dest.externalize,
+                name: externalize,
                 type: "assign"
             };
         }
@@ -313,30 +305,17 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             if (originalLibrary && typeof originalLibrary === 'object' && !Array.isArray(originalLibrary)) {
                 outputLibrary = {
                     ...originalLibrary,
-                    ...dest.externalize
+                    ...externalize
                 };
             }
             else {
-                outputLibrary = dest.externalize;
+                outputLibrary = externalize;
             }
         }
     }
     else {
         outputLibrary = webpackConfig.output?.library;
     }
-    const canCopyFiles = srcIsDirectory && src !== dest.destination;
-    const possiblePlugins = canCopyFiles
-        ? plugins.filter(plugin => plugin.constructor.name !== 'CleanWebpackPlugin')
-            .map(plugin => !processingModules && plugin.constructor.name === 'CopyPlugin'
-            ? new copy_webpack_plugin_1.default({
-                patterns: [{
-                        from: 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
-                    }]
-            })
-            : plugin)
-        : plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin');
     const extensions = processingModules ? ['.mjsx', '.mjs', '.mtsx', '.mts', '...'] : ['.jsx', '.tsx', '.ts', '...'];
     return {
         ...webpackConfig,
@@ -347,7 +326,8 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             path: outPath,
             chunkFilename: 'webpack-chunks/[id].js',
             publicPath: publicPath,
-            library: outputLibrary
+            library: outputLibrary,
+            clean: false
         },
         optimization: {
             ...webpackConfig.optimization,
@@ -381,13 +361,13 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             extensions
         },
         stats: config.stats,
-        plugins: possiblePlugins,
+        plugins,
         entry() {
             if (variablesFilePath) {
                 delete require.cache[require.resolve(variablesFilePath)];
                 updateCurrentVariables(require(variablesFilePath));
             }
-            return typeof entry === 'function' ? entry() : entry;
+            return {};
         },
         performance: {
             ...webpackConfig.performance,

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,31 @@ 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));
     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 +440,16 @@ function commonConfigProcessingPrep(config, webpackConfig) {
         updateCurrentVariables: (value) => currentVariables = value
     };
 }
-//TODO: Try using context to avoid needing to cobble dest paths together?
+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) {
     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,95 +458,93 @@ 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);
+    }
+    return Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem).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.plainEntrypointsHandlePrefix, 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);
+    }).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)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.63.1",
+  "version": "2.64.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",