@plaudit/webpack-extensions 3.21.2 → 4.0.0

package/dist/wordpress-scripts-wrapper.js

@@ -3,38 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const shared_1 = require("./shared");
-const entrypoint_resolution_logic_1 = require("./utils/entrypoint-resolution-logic");
-const common_config_helpers_1 = require("./utils/common-config-helpers");
-const path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
+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"));
+const api_1 = require("./api");
+const auto_registering_plugins_loader_1 = require("./internal-utils/auto-registering-plugins-loader");
+const common_config_helpers_1 = require("./internal-utils/common-config-helpers");
+const entrypoint_resolution_logic_1 = require("./internal-utils/entrypoint-resolution-logic");
+const internal_pseudo_plugin_1 = __importDefault(require("./internal-utils/internal-pseudo-plugin"));
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
 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");
 const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
-const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
-const EnhancedBlockJSONPlugin_1 = require("./plugins/EnhancedBlockJSONPlugin");
-const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
+const RootCoordinatorPluginImpl_1 = require("./plugins/RootCoordinatorPluginImpl");
+const register_1 = require("./plugins/register");
 const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
-const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
-const static_configs_1 = require("./plugins/static-configs");
-const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
-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"));
-const location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
+const shared_1 = require("./shared");
+const utils_1 = require("./utils");
 function testForDuplicatedEntryPaths(sources) {
-    const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
+    const seenPaths = (0, utils_1.groupEntrypointsByAssetName)(Array.isArray(sources)
         ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
         : Object.values(sources).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
-    let projectPrefix = undefined;
+    let projectPrefix;
     let duplicatedPaths = "";
-    for (const sameNamePaths of seenPaths.values()) {
-        if (sameNamePaths.length > 1) {
+    for (const sameNamePaths of Object.values(seenPaths)) {
+        if ((0, utils_1.arrayHasAtLeastLength)(sameNamePaths, 2)) {
             if (projectPrefix === undefined) {
                 for (let p = process.cwd(); p.length > 1; p = (0, node_path_1.dirname)(p)) {
                     if ((0, node_fs_1.existsSync)((0, node_path_1.join)(p, "docker-compose.yml"))) {
@@ -54,99 +48,15 @@ function testForDuplicatedEntryPaths(sources) {
         process.exit(1);
     }
 }
-function replaceDefaultURLProcessing(useWebpackResourceFiltering) {
-    return (rules) => {
-        const cssLoader = require.resolve('css-loader');
-        if (cssLoader) {
-            return rules.map(rule => {
-                if (rule && typeof rule === 'object' && "use" in rule && Array.isArray(rule.use)) {
-                    return {
-                        ...rule,
-                        use: rule.use.map(useElement => {
-                            if (useElement && typeof useElement === 'object' && useElement.loader === cssLoader && typeof useElement.options === 'object') {
-                                return {
-                                    ...useElement,
-                                    options: {
-                                        ...useElement.options,
-                                        url: {
-                                            filter(url) {
-                                                return (useWebpackResourceFiltering || !url.startsWith("/"))
-                                                    && !!url.match(/\.(woff2?|eot|ttf|otf|png|jpe?g|svg|webp|avif|gif|bmp)[^.]*?(\?.*)?/i);
-                                            }
-                                        }
-                                    }
-                                };
-                            }
-                            return useElement;
-                        })
-                    };
-                }
-                return rule;
-            });
-        }
-        return rules;
-    };
-}
-function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig) {
-    const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
-    return rules.map(rule => {
-        if (rule && typeof rule === 'object') {
-            if (Array.isArray(rule.use)) {
-                for (const useItem of rule.use) {
-                    if (useItem && typeof useItem === 'object' && typeof useItem.options === 'object') {
-                        if (useItem.options["sourceMap"] === false) {
-                            useItem.options["sourceMap"] = true;
-                        }
-                        if (useItem.loader?.includes('postcss-loader')) {
-                            if (useItem.options["postcssOptions"]) {
-                                useItem.options["postcssOptions"] = { ...useItem.options["postcssOptions"], ...postcssConfig, sourceMap: true, config: false };
-                            }
-                            else {
-                                useItem.options["postcssOptions"] = { ...postcssConfig, sourceMap: true, config: false };
-                            }
-                        }
-                    }
-                }
-                if (rule.test instanceof RegExp) {
-                    if (rule.test.test("index.ts") || rule.test.test("index.mts")) { // Then this is the JavaScript and TypeScript rule
-                        rule.test = /\.m?[jt]sx?$/; // This hacks in support for mjs and mts files
-                    }
-                    if (config.onlyRunPostCSSOnPCSS && rule.test.test("test.css") && !rule.test.test("test.pcss")) {
-                        // We remove PostCSS processing from the .css file handling pipeline
-                        rule.use = rule.use.filter(useItem => !useItem || typeof useItem !== 'object' || !useItem.loader?.includes('postcss-loader'));
-                    }
-                }
-            }
-            if (rule.type === "asset/inline" && rule.test instanceof RegExp && rule.issuer instanceof RegExp && rule.test.test("test.svg") && rule.issuer.test("test.pcss")) {
-                const { type: originalType, ...commonRuleParams } = rule;
-                return {
-                    ...commonRuleParams,
-                    oneOf: [
-                        { type: originalType, resourceQuery: /string|inline/i },
-                        { type: "asset/resource", generator: { filename: "images/[name].[hash:8][ext]" } }
-                    ]
-                };
-            }
-        }
-        return rule;
-    });
-}
-function injectSupportForInliningSVGsAsStrings(rules) {
-    const svgRLoader = require.resolve('@svgr/webpack');
-    return rules.map(rule => {
-        if (rule && typeof rule === 'object' && "use" in rule && Array.isArray(rule.use) && (rule.use.includes('@svgr/webpack') || rule.use.includes(svgRLoader))) {
-            const { test, issuer, ...reactSpecific } = rule;
-            return { test, issuer, oneOf: [
-                    { type: 'asset/source', resourceQuery: /string/ }, // *.svg?string
-                    reactSpecific
-                ] };
-        }
-        return rule;
-    });
-}
 function buildVerifiedConfig(config) {
+    const baseDir = process.cwd();
     config = (0, shared_1.applyStandards)(config);
-    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false, useBlockSupportsAsThemeJsonDefaults = true, } = config;
+    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', externals, assumeGlobalizedPlauditLibraries = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false, useBlockSupportsAsThemeJsonDefaults = true, pluginConfig = {}, } = config;
+    // This is present to handle the postcss config being in the legacy location
+    if ('postcss' in config) {
+        (0, utils_1.emitWarning)("Found the postcss config object at the root of the config object. Please move it to be a child of pluginConfig");
+        pluginConfig['postcss'] = config.postcss;
+    }
     let outputDir = config.outputDir ?? "";
     if ((0, shared_1.shouldWriteDistDev)({ outputDir, useUnifiedLoader, omitDistDev })) {
         outputDir += "-dev";
@@ -159,87 +69,35 @@ function buildVerifiedConfig(config) {
     else {
         srcPrefixes = (srcDir && !config.srcPrefixes.includes(trailingSlashedSrcDir) ? [...config.srcPrefixes, trailingSlashedSrcDir] : config.srcPrefixes);
     }
-    let targetHandlePrefix = config.targetHandlePrefix ?? config.plainEntrypointsHandlePrefix ?? "";
-    if (plainEntrypointsVersion > 1) {
-        if (!targetHandlePrefix) {
-            targetHandlePrefix = deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.kebabCase) ?? "";
-            if (!targetHandlePrefix) {
-                throw new Error("Plain Entrypoints V2 and higher require either 'targetHandlePrefix' to be set or an adjacent composer.json or style.css file to be present");
-            }
-        }
-        if (!outputDir) {
-            throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
-        }
+    const targetHandlePrefix = config.targetHandlePrefix ?? config.plainEntrypointsHandlePrefix ?? deriveDefaultHandlePrefixFromComposerJsonOrThemeName(utils_1.kebabCase) ?? "";
+    if (!targetHandlePrefix) {
+        throw new Error("'targetHandlePrefix' must be set or the webpack.config.js file must have an adjacent composer.json or style.css file");
+    }
+    if (plainEntrypointsVersion > 1 && !outputDir) {
+        throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
     }
     // Only the lazyLoader emitters read this, so an absence of package metadata is not worth failing a build
     // over: php-writer treats an empty namespace as "emit no namespace", which is what we did before 3.10.0
-    const targetNamespace = config.targetNamespace || deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.camelCaseForPHPLabels, true) || "";
-    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
-    const rawSources = [...staticEntrypoints, ...dynamicEntrypoints];
-    let variablesFilePath = undefined;
+    const targetNamespace = config.targetNamespace || deriveDefaultHandlePrefixFromComposerJsonOrThemeName(utils_1.camelCaseForPHPLabels, true) || "";
+    let variablesFilePath;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
-        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => (0, node_path_1.join)(process.cwd(), p)).filter(p => (0, node_fs_1.existsSync)(p))[0];
+        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => (0, node_path_1.join)(baseDir, p)).filter(p => (0, node_fs_1.existsSync)(p))[0];
     }
     let extensionsVersion = config.extensionsVersion ?? 1;
     if (extensionsVersion === 2) {
         extensionsVersion = 3; // Version 3 is a backwards-compatible upgrade of version 2, so we can automatically upgrade everything
     }
     const cfg = {
-        currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries,
+        currentVariables, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries,
         useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, srcDir, srcPrefixes, targetHandlePrefix,
-        useUnifiedLoader, includePostInitFallback, omitDistDev, onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults
+        useUnifiedLoader, includePostInitFallback, omitDistDev, onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults,
+        pluginConfig
     };
     // Destination -> source map
     const allocatedDestinations = {};
-    const partiallyVerifiedSources = rawSources.map(([src, config]) => {
-        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters: rawPathQueryParameters, enqueuingFlags: rawEnqueuingFlags, locations: rawSourceLocations, } = config;
-        // This guards against a crash later on down the line due to trying to run a spread on a boolean
-        if (externalize && typeof externalize !== 'string' && typeof externalize !== 'object') {
-            throw new TypeError(`externalize must be a string, an array or an object, but "${src}" set externalize to a ${typeof externalize}`);
-        }
-        const { flags: queryEnqueuingFlags, remainder: pathQueryParameters, handle: pathQueryHandle } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, src, 'path query parameters');
-        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(src, rawEnqueuingFlags, queryEnqueuingFlags);
-        const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
-        let locations;
-        if (pathQueryHandle === undefined) {
-            locations = typeof rawSourceLocations === 'string' || typeof rawSourceLocations === 'function' || (rawSourceLocations !== undefined && 'niceName' in rawSourceLocations)
-                ? { handle: rawSourceLocations } : rawSourceLocations ?? {};
-        }
-        else {
-            const rawSourceHandle = typeof rawSourceLocations === 'string' || typeof rawSourceLocations === 'function' || (rawSourceLocations !== undefined && 'niceName' in rawSourceLocations)
-                ? rawSourceLocations : rawSourceLocations?.handle;
-            if (rawSourceHandle === undefined) {
-                locations = { handle: pathQueryHandle };
-            }
-            else if (typeof rawSourceHandle === 'string') {
-                if (rawSourceHandle !== pathQueryHandle) {
-                    throw new ReferenceError(`Encountered mismatched handles "${rawSourceHandle}" and "${pathQueryHandle}" when preparing "${src}"`);
-                }
-                locations = { handle: pathQueryHandle };
-            }
-            else {
-                throw new ReferenceError(`Encountered a function handle and a path query handle when preparing "${src}"`);
-            }
-            // This is just a means of merging the new handle into the rawSourceLocations config without mutating the base config
-            if (rawSourceLocations !== undefined && typeof rawSourceLocations !== 'function' && typeof rawSourceLocations !== 'string') {
-                locations = { ...rawSourceLocations, ...locations };
-            }
-        }
-        if (typeof locations.registerScriptArgs === 'string' && !['lazy', 'eager', 'inline'].includes(locations.registerScriptArgs)) {
-            throw new ReferenceError("The only supported string values for registerScriptArgs are 'lazy', 'eager', and 'inline'");
-        }
-        if (destination !== undefined) {
-            const effectiveDestination = toEffectiveWebpackDestination(destination);
-            allocatedDestinations[effectiveDestination] = src; // We need to pre-populate the allocatedDestinations map with statically declared destinations
-            return [src, { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters, enqueuingFlags }];
-        }
-        else {
-            const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes);
-            const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [src, { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
-        }
-    });
+    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(cfg, config.src, baseDir, allocatedDestinations, srcPrefixes);
+    const partiallyVerifiedSources = [...staticEntrypoints, ...dynamicEntrypoints];
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
         .filter(entry => !entry[1].staticallyDeclaredDestination)
         .map(entry => entry[1].effectiveDestination)
@@ -252,33 +110,6 @@ function buildVerifiedConfig(config) {
     testForDuplicatedEntryPaths(sources);
     return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
 }
-function toEffectiveWebpackDestination(destination) {
-    const pathParts = (0, node_path_1.parse)(destination);
-    return (0, node_path_1.join)(pathParts.dir, pathParts.name);
-}
-function deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes) {
-    if (destination !== undefined) {
-        return destination;
-    }
-    const commaIndex = src.indexOf(',');
-    const primarySource = stripSrcPrefix(commaIndex > -1 ? src.substring(0, commaIndex).trim() : src, srcPrefixes);
-    const scriptParts = shared_1.scriptExtension.exec(primarySource);
-    if (scriptParts !== null) {
-        return `${scriptParts.groups['filename']}.js`; // filename is always defined here
-    }
-    const styleParts = shared_1.styleExtension.exec(primarySource);
-    if (styleParts !== null) {
-        return `${styleParts.groups['filename']}.css`; // filename is always defined here
-    }
-    return primarySource;
-}
-function stripSrcPrefix(src, srcPrefixes) {
-    const prefix = srcPrefixes.find(sp => src.startsWith(sp));
-    if (!prefix) {
-        return src;
-    }
-    return src[prefix.length] === '/' ? src.substring(prefix.length + 1) : src.substring(prefix.length);
-}
 function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations) {
     if (entry[1].staticallyDeclaredDestination) {
         return entry;
@@ -330,8 +161,8 @@ function deriveDefaultHandlePrefixFromThemeName(stringTransformer) {
     return stringTransformer(themeName);
 }
 function withDerivedOutputDir(cfg, sources) {
-    const destinations = sources.map(([_, { destination }]) => destination.split(/[\/\\]/g));
-    if (destinations.length < 2) {
+    const destinations = sources.map(([_, { destination }]) => destination.split(/[/\\]/g));
+    if (!(0, utils_1.arrayHasAtLeastLength)(destinations, 2)) {
         return { cfg, sources };
     }
     const commonParent = destinations[0][0];
@@ -363,7 +194,7 @@ function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins)
         if ((0, node_path_1.extname)(sr).length === 0) {
             include.push(...tsExtensions.map(tsExt => (0, node_path_1.join)(sr, "**", `*.${tsExt}`)));
         }
-        else if ((0, shared_1.scriptOrStyleTest)(sr, scriptExtension) === "script") {
+        else if ((0, api_1.scriptOrStyleTest)(sr, scriptExtension) === "script") {
             include.push(sr);
         }
     }
@@ -415,7 +246,7 @@ function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins)
         }
     }));
 }
-function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
+function buildCommonPluginConfig(coordinator, webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
     const plugins = webpackConfig.plugins?.filter(v => !!v)
         .filter(plugin => plugin.constructor.name !== 'RtlCssPlugin')
         .filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin')
@@ -431,19 +262,15 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
         return plugin;
     })
         ?? [];
-    plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
+    plugins.unshift(new PackageConfigSanityChecker_1.PackageConfigSanityChecker(), coordinator);
     if (bundleAnalyzer) {
-        plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static', openAnalyzer: bundleAnalyzer !== 'no-auto-open' }));
+        plugins.unshift(new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static', openAnalyzer: bundleAnalyzer !== 'no-auto-open' }));
     }
-    const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
+    plugins.push(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());
-    if (config.useWebpackResourceFiltering) {
-        plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
-    }
+    }), new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
     plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(config));
     // We have to use constructor.name here the version desyncs can result in multiple equivalent versions kicking around
     const dependencyExtractionPluginIndex = plugins.findIndex(plugin => plugin.constructor.name === 'DependencyExtractionWebpackPlugin');
@@ -456,51 +283,30 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
         console.error("Once those commands have finished, re-run whichever command had this error. If it still doesn't work, report the issue immediately.");
         throw new 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");
     }
-    const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(config.externals, assumeGlobalizedPlauditLibraries, externalize);
-    plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin;
+    plugins[dependencyExtractionPluginIndex] = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(config.externals, assumeGlobalizedPlauditLibraries, externalize);
     try {
         const { PlauditDevPlugin } = require("@plaudit/dev-webpack-plugin");
         plugins.push(new PlauditDevPlugin(config));
     }
     catch { }
     return {
-        plugins, removeEmptyScriptsPlugin,
-        makeAdditionalDependencyInjectorPlugin(referencePlugin) {
-            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(webpackConfig.output?.module, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
-        }
+        plugins
     };
 }
-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
-    let entrypointFields;
+async function commonConfigProcessingPrep(wrapperManager, config, webpackConfig, hasAnyNonModuleBuilds) {
     const processingModules = webpackConfig.output?.module ?? false;
-    if (processingModules) {
-        scriptExtension = shared_1.scriptWithModuleExtension;
-        entrypointFields = ["viewScriptModule"];
-    }
-    else {
-        scriptExtension = shared_1.scriptWithoutModuleExtension;
-        entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
-    }
+    const scriptExtension = processingModules ? api_1.scriptWithModuleExtension : api_1.scriptWithoutModuleExtension; // This is only used in non-block contexts. It might not actually be necessary, but it is good to have
+    const entrypointFields = (0, api_1.getLoadableEntrypointFields)(processingModules);
     let currentVariables = config.currentVariables;
-    const fixedRules = [
-        replaceDefaultURLProcessing(config.useWebpackResourceFiltering),
-        (rules) => {
-            return injectPostcssConfigOverrides(rules, config, name => currentVariables[name], config.postcss.functions ?? (() => ({})));
-        },
-        injectSupportForInliningSVGsAsStrings
-    ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
-    fixedRules.push({
-        test: /wpml-config\.xml$/i,
-        type: 'asset/resource',
-        generator: {
-            filename: '[name][ext]',
-            emit: false
-        }
-    });
+    const getVariableValue = (name) => currentVariables[name];
+    const draftRules = utils_1.nonFreezingImmer.createDraft(webpackConfig.module?.rules ?? []);
+    await wrapperManager.hooks.webpackConfig.rules.promise(draftRules, { config, hasAnyNonModuleBuilds, webpackConfig, getVariableValue, entrypointFields, scriptExtension });
+    const fixedRules = utils_1.nonFreezingImmer.finishDraft(draftRules);
     return {
         entrypointFields, fixedRules, processingModules, scriptExtension,
-        updateCurrentVariables: (value) => currentVariables = value
+        updateCurrentVariables: (value) => {
+            return currentVariables = value;
+        }
     };
 }
 function destToKey(dest) {
@@ -509,10 +315,11 @@ function destToKey(dest) {
         : dest.externalize?.toString() ?? "undefined";
     return [dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
 }
-function processIndividualWebpackConfig(config, webpackConfig, sources, canClean, preferNonModuleTsChecker) {
+async function processIndividualWebpackConfig(wrapperManager, coordinator, config, webpackConfig, sources, canClean, hasAnyNonModuleBuilds) {
     if (webpackConfig.output?.module) {
         // This ensures that module files are emitted as module files
         webpackConfig = {
+            name: "base:modules",
             ...webpackConfig,
             output: {
                 ...webpackConfig.output,
@@ -521,13 +328,26 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
             }
         };
     }
-    const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
-    const { processingModules, scriptExtension } = commonConfig;
+    else if (!webpackConfig.name) {
+        webpackConfig = { name: "base:non-modules", ...webpackConfig };
+    }
+    const commonConfig = await commonConfigProcessingPrep(wrapperManager, config, webpackConfig, hasAnyNonModuleBuilds);
+    const { entrypointFields, processingModules, scriptExtension } = commonConfig;
+    const legacyBlocksResources = {};
     const allSrcRoots = sources.map(([src, dest]) => {
-        const srcRoots = (dest.withLegacyBlocksIn
-            ? [...src.split(','), ...(0, shared_1.resolveLegacyBlockScriptsInFolder)((0, node_path_1.join)(config.srcDir, dest.withLegacyBlocksIn))]
-            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === shared_1.scriptWithModuleExtension.test(s));
-        const srcRoot = srcRoots.length < 2 ? (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), src) : srcRoots.map(s => (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), s));
+        let srcRoots, legacyBlocksAssets;
+        if (dest.withLegacyBlocksIn !== false) {
+            legacyBlocksAssets = (0, shared_1.resolveLegacyBlockScriptsInFolder)((0, utils_1.joinPossiblyAbsolutePaths)(process.cwd(), config.srcDir, dest.withLegacyBlocksIn));
+            srcRoots = [...src.split(','), ...legacyBlocksAssets];
+        }
+        else {
+            legacyBlocksAssets = [];
+            srcRoots = src.split(',');
+        }
+        const srcRoot = srcRoots.length < 2 ? (0, utils_1.joinPossiblyAbsolutePaths)(process.cwd(), src) : srcRoots.map(s => (0, utils_1.joinPossiblyAbsolutePaths)(process.cwd(), s));
+        for (const legacyBlocksAsset of legacyBlocksAssets) {
+            legacyBlocksResources[legacyBlocksAsset] = srcRoot;
+        }
         const srcIsDirectory = !Array.isArray(srcRoot) && (0, node_fs_1.lstatSync)(srcRoot, { throwIfNoEntry: false })?.isDirectory();
         if (srcIsDirectory === undefined) {
             return undefined;
@@ -539,160 +359,86 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
         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 batches = Object.values(groupedSrcRoots).filter(utils_1.hasAtLeastOneItem);
+    return Promise.all(batches.map(async (currentBatch) => {
         const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
-        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
-        if (!processingModules || !preferNonModuleTsChecker) {
+        const { plugins } = buildCommonPluginConfig(coordinator, webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
+        if (!processingModules || !hasAnyNonModuleBuilds) {
             handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
         }
-        const applicableExtensionTest = (name) => {
-            return commonConfig.scriptExtension.test(name) || (!processingModules && shared_1.styleExtension.test(name));
-        };
-        const contextPath = webpackConfig.context ?? process.cwd();
-        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) {
-                    continue;
-                }
-                plugin = new EnhancedBlockJSONPlugin_1.EnhancedBlockJSONPlugin(config, dest, removeEmptyScriptsPlugin, contextPath, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
-                plugins.push(plugin);
-                if (!processingModules) {
-                    plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination, plugin));
-                }
-            }
-            else if (sourceType === "extensions" /* SourceType.extensions */) {
-                if (!srcIsDirectory) {
-                    continue;
-                }
-                const entry = async () => {
-                    const rawEntrypoints = [];
-                    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-                        if ((0, shared_1.shouldBeSkipped)(dirent.name)) {
-                            continue;
-                        }
-                        if (dirent.isFile()) {
-                            if (applicableExtensionTest(dirent.name)) {
-                                const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                const extensionId = (0, node_path_1.parse)(dirent.name).name;
-                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), {
-                                        import: [absoluteSrc],
-                                        plauditMetadata: { dest, absoluteSrc, extensionId }
-                                    }]);
-                            }
-                        }
-                        else if (dirent.isDirectory()) {
-                            rawEntrypoints.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, applicableExtensionTest, [dirent.name]));
-                        }
-                    }
-                    return Object.fromEntries(rawEntrypoints);
-                };
-                plugin = config.extensionsVersion > 1
-                    ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest, contextPath, entry)
-                    : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination, contextPath, entry);
-                plugins.push(plugin);
-            }
-            else if (sourceType === "plain" /* SourceType.plain */) {
-                const absoluteSrc = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
-                if (!srcIsDirectory && !applicableExtensionTest(absoluteSrc)) {
-                    continue;
-                }
-                const baseDest = stripExtension(dest.destination);
-                if (config.plainEntrypointsVersion > 1) {
-                    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: { purpose: "plain-entrypoint", dest, absoluteSrc } } });
-                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest, config.useUnifiedLoader, contextPath, entry);
-                }
-                else {
-                    if (srcIsDirectory) {
-                        console.error("Using directory mode with legacy plain entrypoint handling is not supported");
-                        continue;
-                    }
-                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(contextPath, () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } }));
+        const batchProcessor = new api_1.IndividualBatchProcessor(plugins, canClean, hasAnyNonModuleBuilds, entrypointFields, scriptExtension);
+        const configLevelProps = { config, hasAnyNonModuleBuilds, webpackConfig };
+        await wrapperManager.hooks.batch.promise(batchProcessor, configLevelProps);
+        await batchProcessor.hooks.beforeBatch.promise();
+        for (const item of currentBatch) {
+            if (item.dest.sourceType && !wrapperManager.supportedSourceTypes.has(item.dest.sourceType)) {
+                let supportedSourceTypes = wrapperManager.supportedSourceTypes.values().map(st => "'" + st + "'").toArray().join(", ");
+                if (wrapperManager.supportedSourceTypes.size > 2) {
+                    const splitIndex = supportedSourceTypes.lastIndexOf("', '") + 2;
+                    supportedSourceTypes = supportedSourceTypes.substring(0, splitIndex) + " and" + supportedSourceTypes.substring(splitIndex);
                 }
-                plugins.push(plugin);
-            }
-            else {
-                console.error("Unrecognized sourceType");
+                (0, utils_1.emitError)(`Encountered an unsupported source type: ${item.dest.sourceType}. The supported source types are ${supportedSourceTypes}`);
                 continue;
             }
-            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)', //TODO: I'm pretty sure that the dots need proper escaping
-                            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);
-}
-async function walkExtensionsTree(srcRoot, dest, applicableExtensionTest, parents) {
-    const res = [];
-    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-        if ((0, shared_1.shouldBeSkipped)(dirent.name)) {
-            continue;
-        }
-        if (dirent.isFile()) {
-            if (!applicableExtensionTest(dirent.name)) {
+            await batchProcessor.hooks.beforeDestinationHandler.promise(item);
+            const destinationHandler = batchProcessor.hooks.destinationHandler.call(item);
+            if (destinationHandler === undefined) {
+                await batchProcessor.hooks.afterDestinationHandler.promise(item, destinationHandler);
                 continue;
             }
-            const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-            if (parsedFilename === undefined) {
-                continue;
+            if (Array.isArray(destinationHandler.plugin)) {
+                plugins.push(...destinationHandler.plugin);
             }
-            const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-            let destFile;
-            if (Object.keys(parsedFilename.locations).length === 1) {
-                if (parsedFilename.locations.clientView) {
-                    destFile = `view-${parsedFilename.type}`;
-                }
-                else if (parsedFilename.locations.clientEditor) {
-                    destFile = `editor-${parsedFilename.type}`;
-                }
-                else {
-                    destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
-                }
+            else if (destinationHandler.plugin !== undefined) {
+                plugins.push(destinationHandler.plugin);
             }
-            else {
-                destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
+            plugins.push(...wrapperManager.emitterPlugins
+                .flatMap(cb => cb(configLevelProps, item, destinationHandler))
+                .filter(p => p !== undefined));
+            await batchProcessor.hooks.afterDestinationHandler.promise(item, destinationHandler);
+            const { dest, src, srcIsDirectory, srcRoot } = item;
+            if (destinationHandler.supportsAssetCopying ?? true) {
+                if (srcIsDirectory && src !== dest.destination) {
+                    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,
+                            }]
+                    }));
+                }
             }
-            const extensionId = parents.join("-") + "-" + destFile;
-            res.push([(0, node_path_1.join)(dest.destination, ...parents, destFile), {
-                    import: [absoluteSrc],
-                    plauditMetadata: { dest, absoluteSrc, extensionId }
-                }]);
-        }
-        else if (dirent.isDirectory()) {
-            res.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, applicableExtensionTest, [...parents, dirent.name]));
         }
-    }
-    return res;
-}
-function stripExtension(filepath) {
-    return (0, node_path_1.join)((0, node_path_1.dirname)(filepath), (0, node_path_1.basename)(filepath, (0, node_path_1.extname)(filepath)));
+        plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin());
+        await batchProcessor.hooks.afterBatch.promise(plugins);
+        return (0, common_config_helpers_1.commonMakeWebpackConfig)(wrapperManager, config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2, hasAnyNonModuleBuilds);
+    }));
 }
-module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
+module.exports = async (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) => {
     const { cfg, sources } = buildVerifiedConfig(config);
-    if (Array.isArray(webpackConfig) && (0, shared_1.arrayIsLength)(webpackConfig, 1)) {
+    const { coordinator, finalizer } = RootCoordinatorPluginImpl_1.RootCoordinatorPluginImpl.make();
+    const wrapperManager = new api_1.WrapperManager(coordinator, cfg);
+    await (0, register_1.registerBuiltins)(wrapperManager);
+    await (0, auto_registering_plugins_loader_1.registerAutoLoadingPlugins)(wrapperManager);
+    if (config.wrapperPlugins) {
+        for (const plugin of config.wrapperPlugins) {
+            await plugin.register(wrapperManager);
+        }
+    }
+    await internal_pseudo_plugin_1.default.register(wrapperManager);
+    if (Array.isArray(webpackConfig) && (0, utils_1.arrayIsLength)(webpackConfig, 1)) {
         webpackConfig = webpackConfig[0];
     }
     if (Array.isArray(webpackConfig)) {
         const hasNonModuleCompiler = webpackConfig.some(cfg => !cfg.output?.module);
-        return webpackConfig.toSorted((a, b) => {
+        return finalizer((await Promise.all(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, false, hasNonModuleCompiler));
+        }).map(wpCfg => processIndividualWebpackConfig(wrapperManager, coordinator, cfg, wpCfg, sources, false, hasNonModuleCompiler)))).flat());
     }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true, false);
+    return finalizer(await processIndividualWebpackConfig(wrapperManager, coordinator, cfg, webpackConfig, sources, true, false));
 };
+//# sourceMappingURL=wordpress-scripts-wrapper.js.map