@plaudit/webpack-extensions 2.54.0 → 2.55.0

package/build/wordpress-scripts-wrapper.js

@@ -6,51 +6,22 @@ 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 AdditionalDependencyInjectorPlugin_1 = require("./wordpress-scripts-wrapper/AdditionalDependencyInjectorPlugin");
-const BlockJSONManagingPlugin_1 = require("./wordpress-scripts-wrapper/BlockJSONManagingPlugin");
-const BrowserSyncPlugin_1 = require("./wordpress-scripts-wrapper/BrowserSyncPlugin");
-const ExtensionsConfigFileGeneratorPlugin_1 = require("./wordpress-scripts-wrapper/ExtensionsConfigFileGeneratorPlugin");
-const MiniCSSExtractPluginErrorCleaner_1 = require("./wordpress-scripts-wrapper/MiniCSSExtractPluginErrorCleaner");
-const PackageConfigSanityChecker_1 = require("./wordpress-scripts-wrapper/PackageConfigSanityChecker");
-const SpecialAssetHandlingPlugin_1 = require("./wordpress-scripts-wrapper/SpecialAssetHandlingPlugin");
-const VariablesJSMonitorPlugin_1 = require("./wordpress-scripts-wrapper/VariablesJSMonitorPlugin");
-const WPMLConfigBuilder_1 = require("./wordpress-scripts-wrapper/WPMLConfigBuilder");
-const static_configs_1 = require("./wordpress-scripts-wrapper/static-configs");
-const dependency_extraction_webpack_plugin_config_builder_1 = require("./wordpress-scripts-wrapper/dependency-extraction-webpack-plugin-config-builder");
+const common_config_helpers_1 = require("./utils/common-config-helpers");
+const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
+const BlockJSONManagingPlugin_1 = require("./plugins/BlockJSONManagingPlugin");
+const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
+const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
+const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
+const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
+const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
+const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
+const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
+const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
+const static_configs_1 = require("./plugins/static-configs");
+const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
 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 joinPossiblyAbsolutePaths(...paths) {
-    return paths.filter((p) => !!p)
-        .reduce((res, p) => !res || node_path_1.default.isAbsolute(p) ? p : node_path_1.default.join(res, p), '') || '.';
-}
-function mapToRealEntrypoints(entrypoint, dir, mapper = (entrypoint) => entrypoint, lazyDependent, associatedQuery) {
-    return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
-        .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
-        .filter(ep => node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
-        .map(ep => {
-        const parsedEntrypoint = node_path_1.default.parse(ep);
-        return [joinPossiblyAbsolutePaths(node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep, lazyDependent, associatedQuery }];
-    });
-}
-let isInThemeCache = undefined;
-function isInTheme() {
-    return isInThemeCache ?? (isInThemeCache = node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), "theme.json")));
-}
-function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
-    const seenPaths = new Map();
-    for (const entrypoint of entrypoints) {
-        const entrypointName = entrypointNameExtractor(entrypoint);
-        const key = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
-        let seen = seenPaths.get(key);
-        if (seen === undefined) {
-            seenPaths.set(key, seen = []);
-        }
-        seen.push(entrypoint);
-    }
-    return seenPaths;
-}
 function resolveLegacyBlockScriptsInFolder(folder) {
     const blockScriptEntrypoints = [];
     for (const blockDir of node_fs_1.default.readdirSync(folder)) {
@@ -65,52 +36,8 @@ function resolveLegacyBlockScriptsInFolder(folder) {
     }
     return blockScriptEntrypoints;
 }
-const scriptWithoutModuleExtension = /\.[jt]sx?$/;
-const scriptWithModuleExtension = /\.m[jt]sx?$/;
-const styleExtension = /\.(p?c|sa)ss$/;
-function scriptOrStyleTest(entryPath, scriptExtension) {
-    return scriptExtension.test(entryPath) ? "script" : (styleExtension.test(entryPath) ? "style" : "");
-}
-function determineEntrypointType(entrypoint, scriptExtension) {
-    let res = scriptOrStyleTest(entrypoint[0], scriptExtension);
-    if (res) {
-        return res;
-    }
-    if (typeof entrypoint[1] === 'string') {
-        return scriptOrStyleTest(entrypoint[1], scriptExtension);
-    }
-    else if (Array.isArray(entrypoint[1])) {
-        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
-    }
-    else if (typeof entrypoint[1].import === 'string') {
-        return scriptOrStyleTest(entrypoint[1].import, scriptExtension);
-    }
-    else {
-        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
-    }
-}
-function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
-    const entrypointBasename = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
-    const parts = [];
-    if (type) {
-        parts.push(type);
-    }
-    if (typeCounts[type] ?? (typeCounts[type] = 0)) {
-        parts.push(typeCounts[type].toString());
-    }
-    typeCounts[type] += 1;
-    return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
-}
-function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
-    const type = determineEntrypointType(entrypoint, scriptExtension);
-    let potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
-    while (entry[potentialKey]) {
-        potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
-    }
-    entry[potentialKey] = entrypoint[1];
-}
 function testForDuplicatedEntryPaths(config) {
-    const seenPaths = groupEntrypointsByAssetFile(Array.isArray(config.src) ? config.src : Object.values(config.src).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
+    const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(config.src) ? config.src : Object.values(config.src).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
     let projectPrefix = undefined;
     let duplicatedPaths = "";
     for (const sameNamePaths of seenPaths.values()) {
@@ -167,7 +94,7 @@ function replaceDefaultURLProcessing(useWebpackResourceFiltering) {
         return rules;
     };
 }
-function injectPostcssConfigOverrides(rules, variables, postcssFunctionsConfig, verbose) {
+function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig, verbose) {
     const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(verbose, name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
     return recursivelyAddParentDirectoryStepToImagesAndFonts(rules.map(rule => {
         if (rule && typeof rule === 'object') {
@@ -203,9 +130,12 @@ function injectPostcssConfigOverrides(rules, variables, postcssFunctionsConfig,
             }
         }
         return rule;
-    }));
+    }), config);
 }
-function recursivelyAddParentDirectoryStepToImagesAndFonts(rules) {
+function recursivelyAddParentDirectoryStepToImagesAndFonts(rules, config) {
+    if (config.outputDir) {
+        return rules;
+    }
     return rules.map(rule => {
         if (rule && typeof rule === 'object') {
             if (typeof rule.generator === 'object') {
@@ -216,7 +146,7 @@ function recursivelyAddParentDirectoryStepToImagesAndFonts(rules) {
                 }
             }
             if (rule.oneOf) {
-                rule = { ...rule, oneOf: recursivelyAddParentDirectoryStepToImagesAndFonts(rule.oneOf) };
+                rule = { ...rule, oneOf: recursivelyAddParentDirectoryStepToImagesAndFonts(rule.oneOf, config) };
             }
         }
         return rule;
@@ -235,49 +165,156 @@ function injectSupportForInliningSVGsAsStrings(rules) {
         return rule;
     });
 }
-function parseEntrypointsJSON(dir) {
-    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
-    if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir);
+function buildVerifiedConfig(config) {
+    testForDuplicatedEntryPaths(config);
+    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = true, useWebpackResourceFiltering = true, outputDir = "", extensionsVersion = 1, plainEntrypointsHandlePrefix = "", plainEntrypointsVersion = 1, srcDir = "" } = config;
+    if (plainEntrypointsVersion > 1) {
+        if (!plainEntrypointsHandlePrefix) {
+            throw new Error("Plain Entrypoints V2 and higher require 'plainEntrypointsHandlePrefix' to be set");
+        }
+        if (!outputDir) {
+            throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
+        }
     }
-    else {
-        return Object.entries(entrypointsJSON).map(([name, config]) => {
-            if (typeof config === 'string') {
-                return [name, joinPossiblyAbsolutePaths(dir, config)];
-            }
-            else if (Array.isArray(config)) {
-                return [name, config.map(c => joinPossiblyAbsolutePaths(dir, c))];
-            }
-            else {
-                if (typeof config.import === 'string') {
-                    config.import = joinPossiblyAbsolutePaths(dir, config.import);
+    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
+    };
+    const sources = (Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src))
+        .map(entry => {
+        let dest = typeof entry[1] === 'string' ? { destination: entry[1] } : entry[1];
+        if (srcDir) {
+            return [node_path_1.default.join(srcDir, entry[0]), dest];
+        }
+        const relativeSrc = node_path_1.default.isAbsolute(entry[0]) ? node_path_1.default.relative(process.cwd(), entry[0]) : entry[0];
+        if (node_path_1.default.isAbsolute(dest.destination)) {
+            dest = { ...dest, destination: node_path_1.default.relative(process.cwd(), dest.destination) };
+        }
+        return [relativeSrc, dest];
+    });
+    return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
+}
+function withDerivedOutputDir(cfg, sources) {
+    const destinations = sources.map(([_, { destination }]) => destination.split(/[\/\\]/g));
+    if (destinations.length < 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) }];
+        })
+    };
+}
+function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins) {
+    if (process.env["NO_TS_CHECKER"] !== "true") {
+        const include = (Array.isArray(srcRoot) ? srcRoot : [srcRoot])
+            .filter(sr => node_path_1.default.extname(sr).length === 0 || (0, common_config_helpers_1.scriptOrStyleTest)(sr, scriptExtension) === "script")
+            .map(sr => node_path_1.default.extname(sr).length > 0 ? sr : node_path_1.default.join(sr, "**", "*"));
+        if (include.length > 0) {
+            plugins.push(new fork_ts_checker_webpack_plugin_1.default({
+                async: true,
+                typescript: {
+                    diagnosticOptions: {
+                        semantic: true,
+                        syntactic: true,
+                    },
+                    configOverwrite: {
+                        include,
+                        compilerOptions: {
+                            skipLibCheck: true
+                        }
+                    }
+                },
+                issue: {
+                    exclude(issue) {
+                        return issue.code === 'TS18003'; // This hides the "no TypeScript files found" error while still monitoring the directory
+                    }
                 }
-                else {
-                    config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
+            }));
+        }
+    }
+}
+function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, sourceType) {
+    const { assumeGlobalizedPlauditLibraries, combineAssetMetadata, externals, extensionsVersion, plainEntrypointsVersion, variablesFilePath } = config;
+    const processingModules = webpackConfig.output?.module ?? false;
+    const plugins = webpackConfig.plugins?.filter(v => !!v)
+        .filter(plugin => plugin.constructor.name !== 'RtlCssPlugin')
+        .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 [name, config];
-            }
-        });
+            });
+        }
+        return plugin;
+    })
+        ?? [];
+    plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
+    if (typeof dest !== 'string' && dest.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']
+    });
+    plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
+    if (config.useWebpackResourceFiltering) {
+        plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config.outputDir));
+    }
+    if (variablesFilePath) {
+        plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(variablesFilePath));
+    }
+    const pluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
+    if (pluginIndex === -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");
     }
+    else {
+        const localAssumeGlobalizedPlauditLibraries = (typeof dest !== 'string' ? dest.assumeGlobalizedPlauditLibraries : undefined) ?? assumeGlobalizedPlauditLibraries;
+        const wantsGroupedDepData = combineAssetMetadata
+            && ((!processingModules && 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, typeof dest !== 'string' ? dest.externalize : undefined);
+        plugins[pluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
+        plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
+    }
+    if (process.argv.includes('--browser-sync') || process.env['BROWSER_SYNC'] === 'true') {
+        plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
+    }
+    return { plugins, removeEmptyScriptsPlugin };
 }
-function processIndividualWebpackConfig(config, webpackConfig, sources, sharedCache) {
+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;
-    const processingModules = webpackConfig.output?.module ?? false;
+    const processingModules = webpackConfig.output?.module;
     if (processingModules) {
-        scriptExtension = scriptWithModuleExtension;
+        scriptExtension = common_config_helpers_1.scriptWithModuleExtension;
         entrypointFields = ["viewScriptModule", "scriptModule"];
     }
     else {
-        scriptExtension = scriptWithoutModuleExtension;
+        scriptExtension = common_config_helpers_1.scriptWithoutModuleExtension;
         entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
     }
-    const { standaloneBlocks, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, combineAssetMetadata, extensionsVersion } = config;
     let currentVariables = config.currentVariables;
     const fixedRules = [
         replaceDefaultURLProcessing(config.useWebpackResourceFiltering),
         (rules) => {
-            return injectPostcssConfigOverrides(rules, name => currentVariables[name], config.postcss.functions ?? (() => ({})), verbose);
+            return injectPostcssConfigOverrides(rules, config, name => currentVariables[name], config.postcss.functions ?? (() => ({})), config.verbose);
         },
         injectSupportForInliningSVGsAsStrings
     ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
@@ -291,351 +328,103 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, sharedCa
             }
         });
     }
+    return {
+        entrypointFields, fixedRules, processingModules, scriptExtension,
+        updateCurrentVariables: (value) => currentVariables = value
+    };
+}
+//TODO: Try using context to avoid needing to cobble dest paths together?
+function processIndividualWebpackConfig(config, webpackConfig, sources) {
+    const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
+    const { processingModules, scriptExtension } = commonConfig;
     return sources.map(([src, dest]) => {
-        const srcRoots = (typeof dest !== 'string' && dest.withLegacyBlocksIn
-            ? [...src.split(','), ...resolveLegacyBlockScriptsInFolder(dest.withLegacyBlocksIn)]
-            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === scriptWithModuleExtension.test(s));
-        const destPath = typeof dest === 'string' ? dest : dest.destination;
-        const srcRoot = srcRoots.length === 1 ? joinPossiblyAbsolutePaths(process.cwd(), src) : srcRoots.map(s => joinPossiblyAbsolutePaths(process.cwd(), s));
+        const 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 === common_config_helpers_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));
         const srcIsDirectory = !Array.isArray(srcRoot) && node_fs_1.default.lstatSync(srcRoot, { throwIfNoEntry: false })?.isDirectory();
         if (srcIsDirectory === undefined) {
             return undefined;
         }
-        const canCopyFiles = srcIsDirectory && src !== dest;
-        const sourceType = (0, shared_1.determineCurrentSourceType)(dest, canCopyFiles);
-        const plugins = webpackConfig.plugins?.filter(v => !!v)
-            .filter(plugin => plugin.constructor.name !== 'RtlCssPlugin')
-            .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.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
-        if (typeof dest !== 'string' && dest.bundleAnalyzer) {
-            plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static' }));
-        }
-        if (process.env["NO_TS_CHECKER"] !== "true") {
-            const include = (Array.isArray(srcRoot) ? srcRoot : [srcRoot])
-                .filter(sr => node_path_1.default.extname(sr).length === 0 || scriptOrStyleTest(sr, scriptExtension) === "script")
-                .map(sr => node_path_1.default.extname(sr).length > 0 ? sr : node_path_1.default.join(sr, "**", "*"));
-            if (include.length > 0) {
-                plugins.push(new fork_ts_checker_webpack_plugin_1.default({
-                    async: true,
-                    typescript: {
-                        diagnosticOptions: {
-                            semantic: true,
-                            syntactic: true,
-                        },
-                        configOverwrite: {
-                            include,
-                            compilerOptions: {
-                                skipLibCheck: true
-                            }
-                        }
-                    },
-                    issue: {
-                        exclude(issue) {
-                            return issue.code === 'TS18003'; // This hides the "no TypeScript files found" error while still monitoring the directory
-                        }
-                    }
-                }));
-            }
-        }
-        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']
-        }), new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
-        if (config.useWebpackResourceFiltering) {
-            plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(sharedCache));
-        }
-        if (variablesFilePath) {
-            plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(variablesFilePath));
-        }
-        if (sourceType === "blocks" /* SourceType.blocks */) {
-            const blockJSONManagingPlugin = new BlockJSONManagingPlugin_1.BlockJSONManagingPlugin(standaloneBlocks, processingModules);
-            plugins.push(blockJSONManagingPlugin);
-            if (config.processTranslationConfigs && srcIsDirectory && !processingModules) {
-                plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(blockJSONManagingPlugin));
-            }
-        }
-        const pluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
-        if (pluginIndex === -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");
-        }
-        else {
-            const localAssumeGlobalizedPlauditLibraries = (typeof dest !== 'string' ? dest.assumeGlobalizedPlauditLibraries : undefined) ?? assumeGlobalizedPlauditLibraries;
-            const wantsGroupedDepData = combineAssetMetadata
-                && ((!processingModules && sourceType === "blocks" /* SourceType.blocks */) || (extensionsVersion > 1 && sourceType === "extensions" /* SourceType.extensions */));
-            const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, typeof dest !== 'string' ? dest.externalize : undefined);
-            plugins[pluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
-            plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
-        }
-        if (srcIsDirectory && sourceType === "extensions" /* SourceType.extensions */) {
-            plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(srcRoot, extensionsVersion, sharedCache));
-        }
-        if (process.argv.includes('--browser-sync') || process.env['BROWSER_SYNC'] === 'true') {
-            plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
-        }
-        let entry;
-        if (srcIsDirectory) {
-            if (typeof dest !== 'string' && dest.directoryLayout === 'extensions') {
-                entry = async () => {
-                    const rawEntrypoints = [];
-                    for await (const dirent of await promises_1.default.opendir(srcRoot)) {
-                        if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                            if (scriptExtension.test(dirent.name) || styleExtension.test(dirent.name)) {
-                                const file = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
-                                rawEntrypoints.push([node_path_1.default.basename(file, node_path_1.default.extname(file)), file]);
-                            }
-                        }
-                    }
-                    return Object.fromEntries(rawEntrypoints);
-                };
-            }
-            else {
-                entry = async () => {
-                    const loadingEntrypoints = [];
-                    for await (const dirent of await promises_1.default.opendir(srcRoot)) {
-                        if (!dirent.isDirectory()) {
-                            continue;
-                        }
-                        const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
-                        loadingEntrypoints.push(new Promise(async (resolve) => {
-                            const rawEntrypoints = [];
-                            const wpmlFiles = [];
-                            try {
-                                const blockJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'block.json'), 'utf8'));
-                                const blockJSONChunkName = node_path_1.default.join(node_path_1.default.basename(dir), "block.json");
-                                for (const key of entrypointFields) {
-                                    if (key in blockJSON) {
-                                        rawEntrypoints.push(...mapToRealEntrypoints(blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep, blockJSONChunkName));
-                                    }
-                                }
-                                wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
-                                BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordBlockJSONAssetSourceDir(blockJSONChunkName, dir);
-                            }
-                            catch (e) {
-                                try {
-                                    const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                                    rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir));
-                                    rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir));
-                                }
-                                catch (e) {
-                                    try {
-                                        rawEntrypoints.push(...parseEntrypointsJSON(dir));
-                                    }
-                                    catch (e) {
-                                        // This just means that the directory doesn't contain any declared entrypoints.
-                                    }
-                                }
-                            }
-                            if (!processingModules) {
-                                try {
-                                    const wpmlFilePath = node_path_1.default.join(dir, "wpml-config.xml");
-                                    await promises_1.default.access(wpmlFilePath);
-                                    wpmlFiles.push(wpmlFilePath);
-                                }
-                                catch (e) {
-                                    // This just means that the file doesn't exist
-                                }
-                            }
-                            resolve([rawEntrypoints, wpmlFiles]);
-                        }));
-                    }
-                    const allEntrypoints = await Promise.all(loadingEntrypoints);
-                    const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(allEntrypoints.flatMap(e => e[0]), e => e[0]);
-                    const currentEntry = {};
-                    for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
-                        if (groupedEntrypoints.length === 1 && groupedEntrypoints[0] !== undefined) {
-                            currentEntry[groupedEntrypoints[0][0]] = groupedEntrypoints[0][1];
-                        }
-                        else {
-                            const typeCounts = {};
-                            for (const entrypoint of groupedEntrypoints) {
-                                addPotentiallyDuplicatedEntrypointName(currentEntry, entrypoint, typeCounts, scriptExtension);
-                            }
-                        }
-                    }
-                    // This is used to allow for block.json dependencies to correctly account for name-deduplication
-                    for (const [key, entry] of Object.entries(currentEntry)) {
-                        if (typeof entry === 'object' && !Array.isArray(entry) && 'lazyDependent' in entry && typeof entry.lazyDependent === 'string') {
-                            BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordRawDependency(entry.lazyDependent, key);
-                        }
-                    }
-                    if (!processingModules) {
-                        const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
-                        try {
-                            await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
-                            currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles] };
-                        }
-                        catch (e) {
-                            if (wpmlEntrypointFiles.length) {
-                                currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles };
-                            }
-                        }
-                    }
-                    return currentEntry;
-                };
-            }
-        }
-        else {
-            const baseDest = node_path_1.default.basename(destPath);
-            entry = () => ({
-                [baseDest.includes('.') ? node_path_1.default.basename(baseDest, node_path_1.default.extname(baseDest)) : baseDest]: srcRoot
-            });
-        }
-        const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir, srcIsDirectory ? destPath : node_path_1.default.dirname(destPath));
-        let publicPath = webpackConfig.output?.publicPath;
-        if (isInTheme()) {
-            let prefix = process.cwd();
-            while (prefix.length > 5 && node_path_1.default.basename(prefix) !== "wp-content") {
-                prefix = node_path_1.default.dirname(prefix);
-            }
-            if (prefix.length > 5) {
-                prefix = node_path_1.default.dirname(prefix);
-                publicPath = `/${node_path_1.default.relative(prefix, outPath)}/`;
-            }
-        }
-        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') {
-                wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
-                if (wpContentHolderDirectory.length > 5) {
-                    viableRoots.push(wpContentHolderDirectory);
+        switch ((0, shared_1.determineCurrentSourceType)(dest, srcIsDirectory)) {
+            case "blocks" /* SourceType.blocks */: {
+                if (!srcIsDirectory) {
+                    return undefined;
                 }
-                break;
-            }
-            wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
-        }
-        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') {
-                outputLibrary = {
-                    name: dest.externalize,
-                    type: "assign"
-                };
+                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "blocks" /* SourceType.blocks */);
+                return makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins);
             }
-            else {
-                const originalLibrary = webpackConfig.output?.library;
-                if (originalLibrary && typeof originalLibrary === 'object' && !Array.isArray(originalLibrary)) {
-                    outputLibrary = {
-                        ...originalLibrary,
-                        ...dest.externalize
-                    };
-                }
-                else {
-                    outputLibrary = dest.externalize;
+            case "extensions" /* SourceType.extensions */: {
+                if (!srcIsDirectory) {
+                    return undefined;
                 }
+                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "extensions" /* SourceType.extensions */);
+                return makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins);
             }
-        }
-        else {
-            outputLibrary = webpackConfig.output?.library;
-        }
-        return {
-            ...webpackConfig,
-            devtool: 'source-map',
-            mode: "production",
-            output: {
-                ...webpackConfig.output,
-                path: outPath,
-                chunkFilename: 'webpack-chunks/[id].js',
-                publicPath: publicPath,
-                library: outputLibrary
-            },
-            optimization: {
-                ...webpackConfig.optimization,
-                splitChunks: {
-                    ...(webpackConfig.optimization?.splitChunks || {}),
-                    cacheGroups: {
-                        style: {
-                            // This is a flagrant abuse of cache groups, but it fixes a persistent problem wherein the dependencies and versions of scripts and styles were bleeding into each-other
-                            type: 'css/mini-extract',
-                            chunks: 'all',
-                            enforce: true,
-                            name(_, chunks, cacheGroupKey) {
-                                const chunkName = chunks.find(chunk => chunk.name)?.name;
-                                // We use "__${cacheGroupKey}__" instead of "${cacheGroupKey}-" to make it easier to remove when generating the filename
-                                const filename = `__${cacheGroupKey}__${node_path_1.default.basename(chunkName)}`;
-                                const dirname = node_path_1.default.dirname(chunkName);
-                                return dirname === '.' ? filename : `${dirname}/${filename}`;
-                            }
-                        },
-                        default: false
-                    }
-                }
-            },
-            module: {
-                ...webpackConfig.module,
-                rules: fixedRules
-            },
-            resolve: {
-                ...webpackConfig.resolve,
-                roots: viableRoots,
-                extensions: ['.mjsx', '.mjs', '.mtsx', '.mts', '.jsx', '.tsx', '.ts', '...']
-            },
-            stats: config.stats,
-            plugins: canCopyFiles
-                ? plugins.map(plugin => !processingModules && plugin.constructor.name === 'CopyPlugin'
-                    ? new copy_webpack_plugin_1.default({ patterns: [{ from: standaloneBlocks ? '**/(block.json|*.(php|twig|svg))' : '**/(block.json|*.(asset\.php|svg))',
-                                context: srcRoot, noErrorOnMissing: true }] })
-                    : plugin)
-                : (srcIsDirectory
-                    ? plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin')
-                    : plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin')),
-            entry() {
-                if (variablesFilePath) {
-                    delete require.cache[require.resolve(variablesFilePath)];
-                    currentVariables = require(variablesFilePath);
+            case "plain" /* SourceType.plain */:
+                if (config.plainEntrypointsVersion > 1) {
+                    // plainEntrypoints.push({dest, src, srcRoot});
+                    // return undefined;
+                    return makePlainV2WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, srcIsDirectory);
                 }
-                return entry();
-            },
-            performance: {
-                ...webpackConfig.performance,
-                assetFilter(assetFilename) {
-                    // We don't want to warn about the sizes of incompressible assets
-                    return !/\.(map|svg|png|jpe?g|gif)$/i.test(assetFilename);
-                }
-            }
-        };
+                const { plugins } = buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest, config, "plain" /* SourceType.plain */);
+                return makePlainV1WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory);
+        }
     }).filter(cfg => cfg !== undefined);
 }
-module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
-    testForDuplicatedEntryPaths(config);
-    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = true, useWebpackResourceFiltering = true, outputDir = "", extensionsVersion = 1 } = config;
-    let variablesFilePath = undefined;
-    const currentVariables = rawVariables ?? {};
-    if (!rawVariables) {
-        variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p))[0];
+function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
+    const { processingModules } = commonConfig;
+    const blockJSONManagingPlugin = new BlockJSONManagingPlugin_1.BlockJSONManagingPlugin(config.standaloneBlocks, processingModules, dest.destination);
+    plugins.push(blockJSONManagingPlugin);
+    if (config.processTranslationConfigs && !processingModules) {
+        plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(blockJSONManagingPlugin, dest.destination));
     }
-    const cfg = {
-        currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, processTranslationConfigs, combineAssetMetadata,
-        useWebpackResourceFiltering, outputDir, extensionsVersion
+    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest), plugins);
+}
+function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
+    plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(srcRoot, config.extensionsVersion, dest.destination));
+    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) || common_config_helpers_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]);
+                }
+            }
+        }
+        return Object.fromEntries(rawEntrypoints);
     };
-    const sources = Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src);
-    const sharedCache = {};
+    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, srcIsDirectory) {
+    const { plugins } = buildCommonPluginConfig(srcRoot, commonConfig.scriptExtension, webpackConfig, dest, config, "extensions" /* SourceType.extensions */);
+    plugins.push(new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, dest.locations ?? {}, config.plainEntrypointsHandlePrefix));
+    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 stripExtension(filepath) {
+    return node_path_1.default.join(node_path_1.default.dirname(filepath), node_path_1.default.basename(filepath, node_path_1.default.extname(filepath)));
+}
+module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
+    const { cfg, sources } = buildVerifiedConfig(config);
     if (Array.isArray(webpackConfig)) {
         return webpackConfig.toSorted((a, b) => {
             if (a.output?.module) {
                 return b.output?.module ? 0 : -1;
             }
             return b.output?.module ? 1 : 0;
-        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources, sharedCache));
+        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources));
     }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources, sharedCache);
+    return processIndividualWebpackConfig(cfg, webpackConfig, sources);
 };