@plaudit/webpack-extensions 4.0.0-rc.1 → 4.1.0

package/dist/wordpress-ports/dependency-extraction-webpack-plugin/util.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRequestToExternal = defaultRequestToExternal;
+exports.defaultRequestToExternalModule = defaultRequestToExternalModule;
+exports.defaultRequestToHandle = defaultRequestToHandle;
+exports.camelCaseDash = camelCaseDash;
+exports.isConcatenatedModule = isConcatenatedModule;
+exports.isEntrypoint = isEntrypoint;
+const WORDPRESS_NAMESPACE = '@wordpress/';
+const BUNDLED_PACKAGES = [
+    '@wordpress/admin-ui',
+    '@wordpress/dataviews',
+    '@wordpress/dataviews/wp',
+    '@wordpress/fields',
+    '@wordpress/global-styles-engine',
+    '@wordpress/global-styles-ui',
+    '@wordpress/grid',
+    '@wordpress/icons',
+    '@wordpress/interface',
+    '@wordpress/kebab-case',
+    '@wordpress/react-inert-value',
+    '@wordpress/style-runtime',
+    '@wordpress/sync',
+    '@wordpress/ui',
+    '@wordpress/undo-manager',
+    '@wordpress/views',
+];
+/**
+ * Default request to global transformation
+ *
+ * Transform @wordpress dependencies:
+ * - request `@wordpress/api-fetch` becomes `[ 'wp', 'apiFetch' ]`
+ * - request `@wordpress/i18n` becomes `[ 'wp', 'i18n' ]`
+ *
+ * @param {string} request Module request (the module name in `import from`) to be transformed
+ * @return {string|string[]|undefined} The resulting external definition. Return `undefined`
+ *   to ignore the request. Return `string|string[]` to map the request to an external.
+ */
+function defaultRequestToExternal(request) {
+    switch (request) {
+        case 'moment':
+            return request;
+        case '@babel/runtime/regenerator':
+            return 'regeneratorRuntime';
+        case 'lodash':
+        case 'lodash-es':
+            return 'lodash';
+        case 'jquery':
+            return 'jQuery';
+        case 'react':
+            return 'React';
+        case 'react-dom':
+        case 'react-dom/client':
+            return 'ReactDOM';
+        case 'react/jsx-runtime':
+        case 'react/jsx-dev-runtime':
+            return 'ReactJSXRuntime';
+    }
+    if (request.includes('react-refresh/runtime')) {
+        return 'ReactRefreshRuntime';
+    }
+    if (BUNDLED_PACKAGES.includes(request)) {
+        return undefined;
+    }
+    if (request.startsWith(WORDPRESS_NAMESPACE)) {
+        return [
+            'wp',
+            camelCaseDash(request.substring(WORDPRESS_NAMESPACE.length)),
+        ];
+    }
+    return undefined;
+}
+/**
+ * Default request to external module transformation
+ *
+ * Currently only @wordpress/interactivity and `@wordpress/interactivity-router`
+ * are supported.
+ *
+ * Do not use the boolean shorthand here, it's only handled for the
+ * `requestToExternalModule` option.
+ *
+ * @param {string} request Module request (the module name in `import from`) to be transformed
+ * @return {string|undefined} The resulting external definition.
+ *   - Return `undefined` to ignore the request (do not externalize).
+ *   - Return `string` to map the request to an external.
+ *   - Return `Error` to emit an error.
+ */
+function defaultRequestToExternalModule(request) {
+    if (request === '@wordpress/interactivity') {
+        // This is a special case. Interactivity does not support dynamic imports at
+        // this time. We add the external "module" type to indicate that webpack
+        // should externalize this as a module (instead of our default `import()`
+        // external type) which forces @wordpress/interactivity imports to be
+        // hoisted to static imports.
+        return `module ${request}`;
+    }
+    switch (request) {
+        case '@wordpress/interactivity-router':
+        case '@wordpress/a11y':
+            return `import ${request}`;
+    }
+    const isWordPressScript = Boolean(defaultRequestToExternal(request));
+    if (isWordPressScript) {
+        throw new Error(`Attempted to use WordPress script in a module: ${request}, which is not supported yet.`);
+    }
+    return undefined;
+}
+/**
+ * Default request to WordPress script handle transformation
+ *
+ * Transform @wordpress dependencies:
+ * - request `@wordpress/i18n` becomes `wp-i18n`
+ * - request `@wordpress/escape-html` becomes `wp-escape-html`
+ *
+ * @param {string} request Module request (the module name in `import from`) to be transformed
+ * @return {string|undefined} WordPress script handle to map the request to. Return `undefined`
+ *   to use the same name as the module.
+ */
+function defaultRequestToHandle(request) {
+    switch (request) {
+        case '@babel/runtime/regenerator':
+            return 'regenerator-runtime';
+        case 'lodash-es':
+            return 'lodash';
+        case 'react-dom/client':
+            return 'react-dom';
+        case 'react/jsx-runtime':
+            return 'react-jsx-runtime';
+    }
+    if (request.includes('react-refresh/runtime')) {
+        return 'wp-react-refresh-runtime';
+    }
+    if (request.startsWith(WORDPRESS_NAMESPACE)) {
+        return 'wp-' + request.substring(WORDPRESS_NAMESPACE.length);
+    }
+    return undefined;
+}
+/**
+ * Given a string, returns a new string with dash separators converted to
+ * camelCase equivalent. This is not as aggressive as `_.camelCase` in
+ * converting to uppercase, where Lodash will also capitalize letters
+ * following numbers.
+ *
+ * @param {string} string Input dash-delimited string.
+ * @return {string} Camel-cased string.
+ */
+function camelCaseDash(string) {
+    return string.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function isConcatenatedModule(module) {
+    return 'modules' in module && Array.isArray(module.modules);
+}
+function isEntrypoint(group) {
+    return !!group && group.constructor.name === 'Entrypoint';
+}
+//# sourceMappingURL=util.js.map

package/dist/wordpress-ports/dependency-extraction-webpack-plugin/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../src/wordpress-ports/dependency-extraction-webpack-plugin/util.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+import type { Configuration } from "webpack";
+import { type PlauditWordpressWebpackConfig } from "./api";
+export = _default;
+declare function _default(config: PlauditWordpressWebpackConfig, webpackConfig?: Configuration[] | Configuration): Promise<Configuration[]>;
+//# sourceMappingURL=wordpress-scripts-wrapper.d.ts.map

package/dist/wordpress-scripts-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordpress-scripts-wrapper.d.ts","sourceRoot":"","sources":["../src/wordpress-scripts-wrapper.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAW,aAAa,EAAC,MAAM,SAAS,CAAC;AAGrD,OAAO,EAIN,KAAK,6BAA6B,EASlC,MAAM,OAAO,CAAC;;0BAsWC,MAAM,EAAE,6BAA6B,EAAE,aAAa,GAAE,aAAa,EAAE,GAAC,aAAmE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC"}

package/dist/wordpress-scripts-wrapper.js

@@ -0,0 +1,444 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+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 MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
+const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
+const RootCoordinatorPluginImpl_1 = require("./plugins/RootCoordinatorPluginImpl");
+const register_1 = require("./plugins/register");
+const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
+const shared_1 = require("./shared");
+const utils_1 = require("./utils");
+function testForDuplicatedEntryPaths(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;
+    let duplicatedPaths = "";
+    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"))) {
+                        projectPrefix = new RegExp(`^${p}`);
+                        break;
+                    }
+                }
+                if (projectPrefix === undefined) {
+                    projectPrefix = /^/;
+                }
+            }
+            duplicatedPaths += `\n* ${(0, node_path_1.dirname)(sameNamePaths[0]).replace(projectPrefix, '')}/[${sameNamePaths.map(p => (0, node_path_1.basename)(p)).join(', ')}]`;
+        }
+    }
+    if (duplicatedPaths.length !== 0) {
+        console.error(`Encountered multiple paths that produce the same effective bundle name:${duplicatedPaths}`);
+        process.exit(1);
+    }
+}
+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', 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";
+    }
+    let srcPrefixes;
+    const trailingSlashedSrcDir = srcDir && !srcDir.endsWith("/") ? srcDir + "/" : srcDir;
+    if (config.srcPrefixes === undefined) {
+        srcPrefixes = srcDir ? [trailingSlashedSrcDir] : ["src/"];
+    }
+    else {
+        srcPrefixes = (srcDir && !config.srcPrefixes.includes(trailingSlashedSrcDir) ? [...config.srcPrefixes, trailingSlashedSrcDir] : config.srcPrefixes);
+    }
+    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(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)(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, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries,
+        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, srcDir, srcPrefixes, targetHandlePrefix,
+        useUnifiedLoader, includePostInitFallback, omitDistDev, onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults,
+        pluginConfig
+    };
+    // Destination -> source map
+    const allocatedDestinations = {};
+    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)
+        .reduce((a, dest) => {
+        a[dest] = (a[dest] !== undefined); // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
+        return a;
+    }, {});
+    const sources = partiallyVerifiedSources
+        .map(entry => finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations));
+    testForDuplicatedEntryPaths(sources);
+    return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
+}
+function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations) {
+    if (entry[1].staticallyDeclaredDestination) {
+        return entry;
+    }
+    const extension = (0, node_path_1.extname)(entry[1].destination);
+    const filename = dynamicEffectiveDestinationsWithExpectedNaiveDuplicates[entry[1].effectiveDestination]
+        ? entry[1].effectiveDestination + (extension === '.css' ? "_style" : "_script")
+        : entry[1].effectiveDestination;
+    let count = 0, derivedDestination = filename + extension;
+    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 }];
+}
+/**
+ * TODO: WTF is the bot on about here?
+ * Derives a prefix from whichever piece of package metadata sits next to the config. Returns undefined
+ * when there is nothing to derive from at all — a caller that cannot proceed without one says so itself,
+ * because the ones that can (see `targetNamespace`) would otherwise fail builds that never needed it. A
+ * file that *is* present but unusable still throws, since that is a misconfiguration rather than an absence.
+ */
+function deriveDefaultHandlePrefixFromComposerJsonOrThemeName(stringTransformer, keepPlauditSep = false) {
+    let composerJson;
+    try {
+        composerJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), "composer.json"), 'utf-8'));
+    }
+    catch {
+        // Then composer.json doesn't exist
+        return deriveDefaultHandlePrefixFromThemeName(stringTransformer);
+    }
+    if (typeof composerJson !== 'object' || typeof composerJson.name !== 'string' || !composerJson.name) {
+        throw new ReferenceError("targetHandlePrefix was not set and the adjacent composer.json file does not have a valid name in it");
+    }
+    return stringTransformer(keepPlauditSep ? composerJson.name.replace(/plaudit\/plaudit-/, 'plaudit/') : composerJson.name.replace(/plaudit\/plaudit/, 'plaudit'));
+}
+function deriveDefaultHandlePrefixFromThemeName(stringTransformer) {
+    const styleFilePath = (0, node_path_1.join)(process.cwd(), "style.css");
+    if (!(0, node_fs_1.existsSync)(styleFilePath)) {
+        // Then there is no package metadata to derive anything from
+        return undefined;
+    }
+    const styleFileContents = (0, node_fs_1.readFileSync)(styleFilePath, 'utf-8');
+    const themeName = /^\W*Theme\s*Name:\s*(.+)$/im.exec(styleFileContents)?.[1]?.trim();
+    if (!themeName) {
+        throw new ReferenceError("targetHandlePrefix was not set and the adjacent style.css file does not have a valid name in it");
+    }
+    return stringTransformer(themeName);
+}
+function withDerivedOutputDir(cfg, sources) {
+    const destinations = sources.map(([_, { destination }]) => destination.split(/[/\\]/g));
+    if (!(0, utils_1.arrayHasAtLeastLength)(destinations, 2)) {
+        return { cfg, sources };
+    }
+    const commonParent = destinations[0][0];
+    for (const destination of destinations) {
+        if (destination[0] !== commonParent) {
+            return { cfg, sources };
+        }
+    }
+    return {
+        cfg: { ...cfg, outputDir: commonParent },
+        sources: sources.map(([src, dest]) => {
+            return [src, { ...dest, destination: dest.destination.substring(commonParent.length + 1) }];
+        })
+    };
+}
+let forkTsCheckerInstalled = false;
+function isTypeScriptSourceFile(file) {
+    return /\.[cm]?tsx?$/i.test(file.split('?')[0] ?? '');
+}
+const prefixes = ['c', 'm', ''];
+const suffixes = ['x', ''];
+const tsExtensions = prefixes.map(prefix => prefix + "ts").flatMap(name => suffixes.map(suffix => name + suffix));
+function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins) {
+    if (process.env["NO_TS_CHECKER"] === "true" || forkTsCheckerInstalled) {
+        return;
+    }
+    const include = [];
+    for (const sr of (Array.isArray(srcRoot) ? srcRoot : [srcRoot])) {
+        if ((0, node_path_1.extname)(sr).length === 0) {
+            include.push(...tsExtensions.map(tsExt => (0, node_path_1.join)(sr, "**", `*.${tsExt}`)));
+        }
+        else if ((0, api_1.scriptOrStyleTest)(sr, scriptExtension) === "script") {
+            include.push(sr);
+        }
+    }
+    if (include.length === 0) {
+        return;
+    }
+    forkTsCheckerInstalled = true;
+    let logTsStatus = true;
+    plugins.push({
+        apply(compiler) {
+            compiler.hooks.watchRun.tap('PlauditForkTsCheckerCssQuiet', watchingCompiler => {
+                const changed = [
+                    ...(watchingCompiler.modifiedFiles ?? []),
+                    ...(watchingCompiler.removedFiles ?? [])
+                ];
+                logTsStatus = changed.length === 0 || changed.some(isTypeScriptSourceFile);
+            });
+        }
+    });
+    plugins.push(new fork_ts_checker_webpack_plugin_1.default({
+        async: true,
+        logger: {
+            log(message) {
+                if (!logTsStatus) {
+                    return;
+                }
+                console.log(message);
+            },
+            error(message) {
+                console.error(message);
+            }
+        },
+        typescript: {
+            diagnosticOptions: {
+                semantic: true,
+                syntactic: true,
+            },
+            configOverwrite: {
+                include,
+                compilerOptions: {
+                    skipLibCheck: true
+                }
+            }
+        },
+        issue: {
+            exclude(issue) {
+                return issue.code === 'TS18003';
+            }
+        }
+    }));
+}
+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')
+        .map(plugin => {
+        if (plugin.constructor.name === 'MiniCssExtractPlugin') {
+            return new plugin.constructor({
+                filename(pd) {
+                    const name = pd.chunk?.name?.replaceAll(/__[a-zA-Z0-9]+__/g, ""); // This removes the prefix that the cache group adds
+                    return name ? `${name}.css` : "[name].css";
+                }
+            });
+        }
+        return plugin;
+    })
+        ?? [];
+    plugins.unshift(new PackageConfigSanityChecker_1.PackageConfigSanityChecker(), coordinator);
+    if (bundleAnalyzer) {
+        plugins.unshift(new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static', openAnalyzer: bundleAnalyzer !== 'no-auto-open' }));
+    }
+    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/
+    }), 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');
+    if (dependencyExtractionPluginIndex === -1) {
+        console.error((0, shared_1.dedent) `
+			Unable to find the DependencyExtractionWebpackPlugin.
+			If this is your first time seeing this error, please run: pnpm up && pnpm dedupe && pnpm up
+			Once those commands have finished, re-run whichever command had this error. If it still doesn't work, report the issue immediately.
+			`);
+        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");
+    }
+    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
+    };
+}
+async function commonConfigProcessingPrep(wrapperManager, config, webpackConfig, hasAnyNonModuleBuilds) {
+    const processingModules = webpackConfig.output?.module ?? false;
+    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 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) => {
+            return currentVariables = value;
+        }
+    };
+}
+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.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
+}
+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,
+                filename: '[name].mjs',
+                chunkFilename: '[name].mjs?ver=[chunkhash]',
+            }
+        };
+    }
+    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]) => {
+        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;
+        }
+        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(utils_1.hasAtLeastOneItem);
+    return Promise.all(batches.map(async (currentBatch) => {
+        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
+        const { plugins } = buildCommonPluginConfig(coordinator, webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
+        if (!processingModules || !hasAnyNonModuleBuilds) {
+            handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
+        }
+        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);
+                }
+                (0, utils_1.emitError)(`Encountered an unsupported source type: ${item.dest.sourceType}. The supported source types are ${supportedSourceTypes}`);
+                continue;
+            }
+            await batchProcessor.hooks.beforeDestinationHandler.promise(item);
+            const destinationHandler = batchProcessor.hooks.destinationHandler.call(item);
+            if (destinationHandler === undefined) {
+                await batchProcessor.hooks.afterDestinationHandler.promise(item, destinationHandler);
+                continue;
+            }
+            if (Array.isArray(destinationHandler.plugin)) {
+                plugins.push(...destinationHandler.plugin);
+            }
+            else if (destinationHandler.plugin !== undefined) {
+                plugins.push(destinationHandler.plugin);
+            }
+            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,
+                            }]
+                    }));
+                }
+            }
+        }
+        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 = async (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) => {
+    const { cfg, sources } = buildVerifiedConfig(config);
+    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 finalizer((await Promise.all(webpackConfig.toSorted((a, b) => {
+            if (a.output?.module) {
+                return b.output?.module ? 0 : -1;
+            }
+            return b.output?.module ? 1 : 0;
+        }).map(wpCfg => processIndividualWebpackConfig(wrapperManager, coordinator, cfg, wpCfg, sources, false, hasNonModuleCompiler)))).flat());
+    }
+    return finalizer(await processIndividualWebpackConfig(wrapperManager, coordinator, cfg, webpackConfig, sources, true, false));
+};
+//# sourceMappingURL=wordpress-scripts-wrapper.js.map