@plaudit/webpack-extensions 3.16.0 → 3.18.0

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

@@ -0,0 +1,150 @@
+"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/grid',
+    '@wordpress/icons',
+    '@wordpress/interface',
+    '@wordpress/style-runtime',
+    '@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';
+}

package/dist/wordpress-scripts-wrapper.js

@@ -10,7 +10,6 @@ const entrypoint_resolution_logic_1 = require("./utils/entrypoint-resolution-log
 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 AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
-const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
 const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
 const EnhancedDynamicEntryPlugin_1 = require("./plugins/EnhancedDynamicEntryPlugin");
 const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
@@ -90,7 +89,7 @@ function replaceDefaultURLProcessing(useWebpackResourceFiltering) {
 }
 function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig) {
     const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
-    return recursivelyAddParentDirectoryStepToImagesAndFonts(rules.map(rule => {
+    return rules.map(rule => {
         if (rule && typeof rule === 'object') {
             if (Array.isArray(rule.use)) {
                 for (const useItem of rule.use) {
@@ -130,26 +129,6 @@ function injectPostcssConfigOverrides(rules, config, variables, postcssFunctions
             }
         }
         return rule;
-    }), config);
-}
-function recursivelyAddParentDirectoryStepToImagesAndFonts(rules, config) {
-    if (config.outputDir) {
-        return rules;
-    }
-    return rules.map(rule => {
-        if (rule && typeof rule === 'object') {
-            if (typeof rule.generator === 'object') {
-                const ruleGeneratorFilename = rule.generator["filename"];
-                if (typeof ruleGeneratorFilename === 'string' && (ruleGeneratorFilename.startsWith("images/") || ruleGeneratorFilename.startsWith("fonts/"))) {
-                    rule.generator["filename"] = `../${ruleGeneratorFilename}`;
-                    rule = { ...rule, generator: { ...rule.generator, filename: `../${ruleGeneratorFilename}` } };
-                }
-            }
-            if (rule.oneOf) {
-                rule = { ...rule, oneOf: recursivelyAddParentDirectoryStepToImagesAndFonts(rule.oneOf, config) };
-            }
-        }
-        return rule;
     });
 }
 function injectSupportForInliningSVGsAsStrings(rules) {
@@ -167,9 +146,9 @@ function injectSupportForInliningSVGsAsStrings(rules) {
 }
 function buildVerifiedConfig(config) {
     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, processTranslationConfigs = true, combineAssetMetadata = 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', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false, useBlockSupportsAsThemeJsonDefaults = true, } = config;
     let outputDir = config.outputDir ?? "";
-    if (outputDir && useUnifiedLoader && !omitDistDev && (process.env['SERVER_MODE'] ?? 'development') === 'development') {
+    if ((0, shared_1.shouldWriteDistDev)({ outputDir, useUnifiedLoader, omitDistDev })) {
         outputDir += "-dev";
     }
     let srcPrefixes;
@@ -183,7 +162,7 @@ function buildVerifiedConfig(config) {
     let targetHandlePrefix = config.targetHandlePrefix ?? config.plainEntrypointsHandlePrefix ?? "";
     if (plainEntrypointsVersion > 1) {
         if (!targetHandlePrefix) {
-            targetHandlePrefix = deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.kebabCase);
+            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");
             }
@@ -192,7 +171,9 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
-    const targetNamespace = config.targetNamespace || deriveDefaultHandlePrefixFromComposerJsonOrThemeName(shared_1.camelCaseForPHPLabels, true);
+    // 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;
@@ -205,31 +186,58 @@ function buildVerifiedConfig(config) {
         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, processTranslationConfigs, combineAssetMetadata,
-        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, srcDir, srcPrefixes, targetHandlePrefix, useUnifiedLoader, includePostInitFallback, omitDistDev,
-        onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults
+        currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries,
+        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, srcDir, srcPrefixes, targetHandlePrefix,
+        useUnifiedLoader, includePostInitFallback, omitDistDev, onlyRunPostCSSOnPCSS, targetNamespace, useBlockSupportsAsThemeJsonDefaults
     };
     // Destination -> source map
     const allocatedDestinations = {};
-    const partiallyVerifiedSources = rawSources.map(rawSource => {
-        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters: rawPathQueryParameters, enqueuingFlags: rawEnqueuingFlags } = rawSource[1];
-        const { flags: queryEnqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, rawSource[0], 'path query parameters');
-        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(rawSource[0], rawEnqueuingFlags, queryEnqueuingFlags);
+    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 };
-        const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function' || (rawSource[1].locations && 'niceName' in rawSource[1].locations)
-            ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};
+        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] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically declared destinations
-            return [rawSource[0], { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters, enqueuingFlags }];
+            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(rawSource, srcPrefixes);
+            const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
+            return [src, { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
@@ -248,7 +256,7 @@ 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) {
+function deriveNaiveDestinationFromUnverifiedSourceEntry(src, destination, srcPrefixes) {
     if (destination !== undefined) {
         return destination;
     }
@@ -287,11 +295,14 @@ function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpecte
     allocatedDestinations[derivedDestination] = entry[0];
     return [entry[0], { ...entry[1], destination: derivedDestination }];
 }
-let defaultHandlePrefix = undefined;
+/**
+ * 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) {
-    if (defaultHandlePrefix !== undefined) {
-        return defaultHandlePrefix;
-    }
     let composerJson;
     try {
         composerJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), "composer.json"), 'utf-8'));
@@ -306,7 +317,12 @@ function deriveDefaultHandlePrefixFromComposerJsonOrThemeName(stringTransformer,
     return stringTransformer(keepPlauditSep ? composerJson.name.replace(/plaudit\/plaudit-/, 'plaudit/') : composerJson.name.replace(/plaudit\/plaudit/, 'plaudit'));
 }
 function deriveDefaultHandlePrefixFromThemeName(stringTransformer) {
-    const styleFileContents = (0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), "style.css"), 'utf-8');
+    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");
@@ -331,34 +347,73 @@ function withDerivedOutputDir(cfg, sources) {
         })
     };
 }
+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") {
-        const include = (Array.isArray(srcRoot) ? srcRoot : [srcRoot])
-            .filter(sr => (0, node_path_1.extname)(sr).length === 0 || (0, shared_1.scriptOrStyleTest)(sr, scriptExtension) === "script")
-            .map(sr => (0, node_path_1.extname)(sr).length > 0 ? sr : (0, node_path_1.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
-                    }
-                }
-            }));
+    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, shared_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(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
     const plugins = webpackConfig.plugins?.filter(v => !!v)
@@ -378,7 +433,7 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
         ?? [];
     plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
     if (bundleAnalyzer) {
-        plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static' }));
+        plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static', openAnalyzer: bundleAnalyzer !== 'no-auto-open' }));
     }
     const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
         stage: webpack_remove_empty_scripts_1.default.STAGE_AFTER_PROCESS_PLUGINS,
@@ -401,9 +456,15 @@ 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, true, externalize);
-    plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
-    plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
+    const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(config.externals, assumeGlobalizedPlauditLibraries, externalize);
+    plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin;
+    if ((0, shared_1.isDistDevOutputPath)(config.outputDir)) {
+        try {
+            const { PlauditDevPlugin } = require("@plaudit/dev-webpack-plugin");
+            plugins.push(new PlauditDevPlugin());
+        }
+        catch { }
+    }
     return {
         plugins, removeEmptyScriptsPlugin,
         makeAdditionalDependencyInjectorPlugin(referencePlugin) {
@@ -431,16 +492,14 @@ function commonConfigProcessingPrep(config, webpackConfig) {
         },
         injectSupportForInliningSVGsAsStrings
     ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
-    if (config.processTranslationConfigs) {
-        fixedRules.push({
-            test: /wpml-config\.xml$/i,
-            type: 'asset/resource',
-            generator: {
-                filename: '[name][ext]',
-                emit: false
-            }
-        });
-    }
+    fixedRules.push({
+        test: /wpml-config\.xml$/i,
+        type: 'asset/resource',
+        generator: {
+            filename: '[name][ext]',
+            emit: false
+        }
+    });
     return {
         entrypointFields, fixedRules, processingModules, scriptExtension,
         updateCurrentVariables: (value) => currentVariables = value
@@ -452,7 +511,7 @@ function destToKey(dest) {
         : dest.externalize?.toString() ?? "undefined";
     return [dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
 }
-function processIndividualWebpackConfig(config, webpackConfig, sources, canClean) {
+function processIndividualWebpackConfig(config, webpackConfig, sources, canClean, preferNonModuleTsChecker) {
     if (webpackConfig.output?.module) {
         // This ensures that module files are emitted as module files
         webpackConfig = {
@@ -486,7 +545,9 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
     return batches.map(currentBatch => {
         const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
         const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
-        handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
+        if (!processingModules || !preferNonModuleTsChecker) {
+            handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
+        }
         const applicableExtensionTest = (name) => {
             return commonConfig.scriptExtension.test(name) || (!processingModules && shared_1.styleExtension.test(name));
         };
@@ -500,7 +561,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 }
                 plugin = new EnhancedBlockJSONPlugin_1.EnhancedBlockJSONPlugin(config, dest, removeEmptyScriptsPlugin, contextPath, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
                 plugins.push(plugin);
-                if (config.processTranslationConfigs && !processingModules) {
+                if (!processingModules) {
                     plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination, plugin));
                 }
             }
@@ -627,12 +688,13 @@ module.exports = function (config, webpackConfig = require("@wordpress/scripts/c
         webpackConfig = webpackConfig[0];
     }
     if (Array.isArray(webpackConfig)) {
+        const hasNonModuleCompiler = webpackConfig.some(cfg => !cfg.output?.module);
         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, false));
+        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources, false, hasNonModuleCompiler));
     }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true);
+    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true, false);
 };

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plaudit/plaudit-webpack-extensions.git"
+  },
   "files": [
     "/dist",
     "README.md",
@@ -28,16 +32,24 @@
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.98.0",
-    "@types/browser-sync-webpack-plugin": "^2.2.5",
+    "@plaudit/dev-webpack-plugin": "^1.0.1",
+    "@plaudit/gutenberg-api-extensions": "^2.98.2",
     "@types/jsdom": "^28.0.3",
     "@types/node": "^25.9.5",
     "@types/postcss-functions": "^4.0.4",
     "@types/postcss-import": "^14.0.3",
     "@types/tapable": "^2.3.0",
     "@types/webpack-sources": "^3.2.3",
+    "atob": "^2.1.2",
+    "css-loader": "^6.11.0",
+    "glob": "^7.2.3",
+    "jest": "^30.4.2",
+    "lodash": "^4.18.1",
+    "mini-css-extract-plugin": "^2.10.2",
+    "mkdirp": "^3.0.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
+    "rimraf": "^5.0.10",
     "typescript": "^6.0.3",
     "webpack-bundle-analyzer": "^5.3.1"
   },
@@ -46,10 +58,9 @@
     "@plaudit/postcss-color-function": "^5.1.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
     "@plaudit/postcss-variables": "^2.0.1",
-    "@wordpress/dependency-extraction-webpack-plugin": "^6.51.0",
+    "@wordpress/dependency-extraction-webpack-plugin": "^6.53.0",
     "@wordpress/scripts": "^32.6.0",
     "autoprefixer": "^10.5.4",
-    "browser-sync": "^3.0.4",
     "copy-webpack-plugin": "10.2.4",
     "css-minimizer-webpack-plugin": "^8.0.0",
     "cssnano": "^7.1.9",
@@ -57,20 +68,28 @@
     "http-proxy-middleware": "^3.0.7",
     "jsdom": "^29.1.1",
     "json2php": "0.0.12",
-    "postcss": "^8.5.20",
+    "postcss": "^8.5.26",
     "postcss-calc": "^10.1.1",
     "postcss-functions": "^4.0.2",
-    "postcss-import": "^16.1.1",
+    "postcss-import": "^16.2.0",
     "postcss-loader": "^8.2.1",
     "postcss-mixins": "^12.1.2",
     "postcss-nested": "^7.0.2",
     "postcss-property-lookup": "^3.0.0",
     "postcss-reporter": "^7.1.0",
     "postcss-url": "^10.1.4",
-    "webpack": "^5.108.4",
+    "webpack": "^5.109.2",
     "webpack-remove-empty-scripts": "^1.1.1",
     "xml-formatter": "^3.7.0"
   },
+  "peerDependencies": {
+    "@plaudit/dev-webpack-plugin": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@plaudit/dev-webpack-plugin": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20"
   },
@@ -79,6 +98,11 @@
     "clean": "rm -rf dist",
     "build:clean": "pnpm run clean && pnpm run build",
     "watch": "tsc -w",
+    "test": "pnpm run build && pnpm run test:no-build",
+    "test:no-build": "rm -rf tests/.tmp/coverage/jest && NODE_V8_COVERAGE=tests/.tmp/coverage/jest jest",
+    "test:update": "pnpm run build && rm -rf tests/.tmp/coverage/jest && NODE_V8_COVERAGE=tests/.tmp/coverage/jest jest -u",
+    "test:paths": "pnpm run build && jest \"tests/integration-[0-9]+x/paths\"",
+    "test:gaps": "node tests/tools/coverage-gaps.js",
     "update": "pnpm add --config '@plaudit/pnpm-plugin-plaudit-config@*' && pnpm up"
   }
 }

package/dist/plugins/BrowserSyncPlugin.d.ts

@@ -1,25 +0,0 @@
-import { type WebpackPlugin } from "../shared";
-import browserSync, { type BrowserSyncInstance } from "browser-sync";
-import type { Compiler } from "webpack";
-export type PluginOptions = {
-    reload: boolean;
-    name: string;
-    callback?: (err: Error, bs: BrowserSyncInstance) => any;
-    injectCss: boolean;
-    middlewareBuilder?: (options: browserSync.Options) => browserSync.Options['middleware'];
-};
-export declare class BrowserSyncPlugin implements WebpackPlugin {
-    private static isBrowserSyncRunning;
-    private static browserSyncPluginOptions?;
-    private readonly pluginOptions;
-    private readonly browserSyncInstance;
-    private isWebpackWatching;
-    private mostRecentChunkHashes;
-    private shouldNotify;
-    constructor(pluginOptions?: Partial<PluginOptions>);
-    private static getBrowserSyncPluginOptions;
-    private static findEnvFile;
-    apply(compiler: Compiler): void;
-    private getCssOnlyEmittedAssetsNames;
-    private static getSiteUrls;
-}