@plaudit/webpack-extensions 3.16.0 → 3.18.0

package/dist/shared.d.ts

@@ -1,21 +1,24 @@
 import { PHPFile, PHPWriter } from "@plaudit/php-writer";
 import { HereOrNowDoc } from "@plaudit/php-writer/expressions";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { type AssetInfo, type Compilation, type Configuration, type Entrypoint, WebpackError, type Compiler } from "webpack";
+import { type AssetInfo, type Compilation, type Configuration, type Entrypoint, WebpackError } from "webpack";
 import { SourceType } from "./utils/entrypoint-resolution-logic";
 import type { NormalizedEnqueuingControlFlags } from "./utils/path-query-and-related-helpers";
 export * from "./utils/entrypoint-resolution-logic";
-export type WPModuleDependency = {
+export type WPModuleDependency = string | {
     id: string;
     import?: string;
 };
-export type ParsedAssetsJson = Record<string, {
-    dependencies: string[];
+export type ParsedAssetJson = {
+    dependencies: WPModuleDependency[];
+    module_dependencies?: WPModuleDependency[];
     version: string;
-    module_dependencies?: (string | WPModuleDependency)[];
-}>;
+    type?: 'module';
+    handle?: string;
+};
+export type ParsedAssetsJson = Record<string, ParsedAssetJson>;
 export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
+type BaseRestType = [/* dependencies: */ WPModuleDependency[], /* version: */ string];
 export type AssetMetaSegment = {
     inlinedAsset: InlinedAsset;
     assetContents: string;
@@ -28,7 +31,7 @@ export type ScriptArgsObject = {
     strategy?: 'defer' | 'async';
     in_footer?: boolean;
     fetchpriority?: 'auto' | 'low' | 'high';
-    module_dependencies?: (string | WPModuleDependency)[];
+    module_dependencies?: WPModuleDependency[];
 };
 export type InlinedAsset = {
     position?: 'before' | 'after';
@@ -102,9 +105,6 @@ export declare function constantEntries<K extends string, V>(object: {
     [k in K]: V;
 }): [K, V][];
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
-export interface WebpackPlugin {
-    apply(compiler: Compiler): void;
-}
 export type ObjectIndividualExternalDepConfig = {
     import?: string | [string, ...string[]];
     handle: string;
@@ -120,16 +120,16 @@ export type AdvancedOutputConfig = {
     directoryLayout?: SourceType;
     assumeGlobalizedPlauditLibraries?: boolean;
     externalize?: Required<Configuration>['output']['library'];
-    bundleAnalyzer?: boolean;
+    bundleAnalyzer?: boolean | 'no-auto-open';
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
-    pathQueryParameters?: PathQueryParameters;
     enqueuingFlags?: NormalizedEnqueuingControlFlags;
 };
-type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader' | 'pathQueryParameters';
+type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader';
 export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | 'enqueuingFlags' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
     locations: NormalizedUsageLocations;
+    pathQueryParameters?: PathQueryParameters;
 };
 export type SourcesObject = Record<string, string | AdvancedOutputConfig | boolean>;
 export type PlauditWordpressWebpackConfig = {
@@ -144,8 +144,6 @@ export type PlauditWordpressWebpackConfig = {
     };
     externals?: Externals;
     assumeGlobalizedPlauditLibraries?: boolean;
-    processTranslationConfigs?: boolean;
-    combineAssetMetadata?: boolean;
     useWebpackResourceFiltering?: boolean;
     outputDir?: string;
     extensionsVersion?: 1 | 2 | 3;
@@ -160,6 +158,13 @@ export type PlauditWordpressWebpackConfig = {
     targetNamespace?: string;
     useBlockSupportsAsThemeJsonDefaults?: boolean;
 };
+/** Unified-loader watch output: `dist` → `dist-dev` when SERVER_MODE is development. */
+export declare function shouldWriteDistDev(config: Pick<PlauditWordpressWebpackConfig, 'outputDir' | 'useUnifiedLoader' | 'omitDistDev'>): boolean;
+/**
+ * This MUST be kept in sync with the copy in @plaudit/dev-webpack-plugin
+ * @returns true for `dist-dev` (or any `*-dev` output folder produced by {@link shouldWriteDistDev}).
+ */
+export declare function isDistDevOutputPath(outputPath: string): boolean;
 export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
     readonly standard?: "2026-03-13";
     readonly standaloneBlocks?: boolean;
@@ -172,8 +177,6 @@ export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
     };
     readonly externals?: Externals;
     readonly assumeGlobalizedPlauditLibraries?: boolean;
-    readonly processTranslationConfigs?: boolean;
-    readonly combineAssetMetadata?: boolean;
     useWebpackResourceFiltering?: boolean;
     outputDir?: string;
     extensionsVersion?: 1 | 2 | 3;
@@ -219,8 +222,7 @@ export type MinimumViableMetadata = {
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
 };
-export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], handlePrefix: string, generatedNiceName: string): string;
-export declare function convertUsageLocationsHandleToEmittableHandleSuffix(handle: UsageLocations['handle'], generatedNiceName: string): string;
+export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], handlePrefix: string, handleSuffix: string): string;
 export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
 export declare const entrypointFields: readonly ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script", "viewScriptModule"];
 export type EntrypointFields = (typeof entrypointFields[number])[];
@@ -233,7 +235,7 @@ export declare const styleExtension: RegExp;
 export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "script" | "style" | "";
 export declare function isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
 export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
-export declare function mergeModuleDependencyArrays(a: (string | WPModuleDependency)[] | undefined, b: (string | WPModuleDependency)[] | undefined): (string | WPModuleDependency)[] | undefined;
+export declare function mergeModuleDependencyArrays(a: WPModuleDependency[] | undefined, b: WPModuleDependency[] | undefined): WPModuleDependency[] | undefined;
 export declare function getHandleGroup(field: string): 'styleHandles' | 'scriptHandles' | 'scriptModuleHandles';
 export type StripFirstTwoItems<A extends any[]> = A extends [any, any, ...rest: infer R] ? R : never;
 export declare function hasAtLeastOneItem<T>(list: T[]): list is [T, ...T[]];
@@ -242,8 +244,6 @@ type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N
 export declare function arrayIsLength<T, N extends number>(arr: T[] | null | undefined, length: N): arr is TupleOf<T, N>;
 export declare function kebabCase(value: string): string;
 export declare function camelCaseForPHPLabels(value: string): string;
-export declare function loadEnvFile(filePath: string): Promise<Record<string, string>>;
-export declare function parseEnvFile(contents: string): Record<string, string>;
 export declare function newCleanWebpackError(error: string | ConstructorParameters<typeof WebpackError>): WebpackError;
 export declare function newWebpackErrorForFile(error: string | ConstructorParameters<typeof WebpackError>, file: string): WebpackError;
 /**
@@ -260,7 +260,7 @@ export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compil
     assetData: ParsedAssetsJson[string];
 } | undefined;
 export declare function emitPHPWriterAsAsset(writer: PHPWriter | PHPFile, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-export declare function dedent(text: TemplateStringsArray): string;
+export declare function dedent(text: TemplateStringsArray, ...values: unknown[]): string;
 export declare function resolveLegacyBlockScriptsInFolder(folder: string): string[];
 /**
  * @param compilation

package/dist/shared.js

@@ -25,10 +25,11 @@ exports.isNormalizedUsageLocations = isNormalizedUsageLocations;
 exports.constantKeys = constantKeys;
 exports.constantEntries = constantEntries;
 exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.shouldWriteDistDev = shouldWriteDistDev;
+exports.isDistDevOutputPath = isDistDevOutputPath;
 exports.applyStandards = applyStandards;
 exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
-exports.convertUsageLocationsHandleToEmittableHandleSuffix = convertUsageLocationsHandleToEmittableHandleSuffix;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -41,8 +42,6 @@ exports.hasAtLeastOneItem = hasAtLeastOneItem;
 exports.arrayIsLength = arrayIsLength;
 exports.kebabCase = kebabCase;
 exports.camelCaseForPHPLabels = camelCaseForPHPLabels;
-exports.loadEnvFile = loadEnvFile;
-exports.parseEnvFile = parseEnvFile;
 exports.newCleanWebpackError = newCleanWebpackError;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
@@ -58,7 +57,6 @@ exports.instanceOfNodeError = instanceOfNodeError;
 exports.shouldBeSkipped = shouldBeSkipped;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
@@ -87,7 +85,7 @@ exports.standardLocationNamesMeta = {
     analytics: { action: "plaudit_enqueue_analytics" },
 };
 function isStandardLocationName(name) {
-    return name in exports.standardLocationNamesMeta;
+    return Object.hasOwn(exports.standardLocationNamesMeta, name);
 }
 function isRegisterScriptArgsShorthandName(name) {
     return ['lazy', 'eager', 'inline'].includes(name);
@@ -117,6 +115,17 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
+/** Unified-loader watch output: `dist` → `dist-dev` when SERVER_MODE is development. */
+function shouldWriteDistDev(config) {
+    return !!(config.outputDir && config.useUnifiedLoader && !config.omitDistDev && (process.env['SERVER_MODE'] ?? 'development') === 'development');
+}
+/**
+ * This MUST be kept in sync with the copy in @plaudit/dev-webpack-plugin
+ * @returns true for `dist-dev` (or any `*-dev` output folder produced by {@link shouldWriteDistDev}).
+ */
+function isDistDevOutputPath(outputPath) {
+    return node_path_1.default.basename(outputPath.replace(/[/\\]+$/, '')).endsWith('-dev');
+}
 function applyStandards(config) {
     switch (config.standard) {
         case '2026-03-13':
@@ -146,37 +155,23 @@ function resolveStandard(standard) {
             return undefined;
     }
 }
-function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, generatedNiceName) {
-    let emittableHandle;
-    if (!handle) {
-        return `${handlePrefix}/${generatedNiceName}`;
-    }
-    if (typeof handle === 'string') {
-        emittableHandle = handle;
-    }
-    else if (typeof handle === 'function') {
-        emittableHandle = handle(`${handlePrefix}/${generatedNiceName}`);
-    }
-    else {
-        emittableHandle = `${handlePrefix}/${handle.niceName}`;
-    }
-    return emittableHandle.replaceAll("{basename}", generatedNiceName);
-}
-function convertUsageLocationsHandleToEmittableHandleSuffix(handle, generatedNiceName) {
+function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, handleSuffix) {
+    const generatedHandle = `${handlePrefix}/${handleSuffix}`;
     let emittableHandle;
     if (!handle) {
-        return generatedNiceName;
+        return generatedHandle;
     }
     if (typeof handle === 'string') {
         emittableHandle = handle;
     }
     else if (typeof handle === 'function') {
-        emittableHandle = handle(generatedNiceName);
+        emittableHandle = handle(generatedHandle);
     }
     else {
-        emittableHandle = handle.niceName;
+        emittableHandle = handle.niceName && `${handlePrefix}/${handle.niceName}`;
     }
-    return emittableHandle.replaceAll("{basename}", generatedNiceName);
+    // A callback is free to return nothing, which means "use the handle you would have generated"
+    return emittableHandle ? emittableHandle.replaceAll("{basename}", handleSuffix) : generatedHandle;
 }
 function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
     const prettyPrintedMetadata = php_writer_1.json2php.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
@@ -266,17 +261,6 @@ function camelCaseForPHPLabels(value) {
     })
         .join("\\");
 }
-async function loadEnvFile(filePath) {
-    return (0, promises_1.readFile)(filePath, 'utf-8').then(parseEnvFile, () => ({}));
-}
-function parseEnvFile(contents) {
-    return Object.fromEntries(contents.split(/(\r?\n)+/).map(line => line.trim())
-        .filter(line => line.length > 0 && !line.startsWith("#") && !line.startsWith("//"))
-        .map(line => {
-        const equalsPos = line.indexOf('=');
-        return equalsPos === -1 ? [line, ""] : [line.substring(0, equalsPos), line.substring(equalsPos + 1)];
-    }));
-}
 function newCleanWebpackError(error) {
     const res = typeof error === 'string' ? new webpack_1.WebpackError(error) : new webpack_1.WebpackError(...error);
     res.hideStack = true;
@@ -313,18 +297,10 @@ function emitResolveBaseUriFunction(writer) {
 }
 function getAssetsJson(compilation) {
     const asset = compilation.getAsset("assets.json");
-    if (!asset) {
-        throw new Error("assets.json is unexpectedly missing");
-    }
-    if (isParsedAssetsJson(asset.info["parsed-assets-json"])) {
+    if (asset && isParsedAssetsJson(asset.info["parsed-assets-json"])) {
         return asset.info["parsed-assets-json"];
     }
-    const parsedAssetJson = JSON.parse(asset.source.source().toString('utf-8'));
-    if (!isParsedAssetsJson(parsedAssetJson)) {
-        throw new Error("assets.json is does not match the RawAssetData format");
-    }
-    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
-    return parsedAssetJson;
+    throw new Error("assets.json is unexpectedly missing");
 }
 function getParsedAssetsJsonDataForEntrypoint(compilation, entrypoint, metadata) {
     const dest = metadata.dest;
@@ -364,13 +340,24 @@ function emitPHPWriterAsAsset(writer, compilation, file, assetInfo) {
     const contents = writer.toString() + "\n";
     compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
 }
-function dedent(text) {
-    const actualText = text.join("\n");
-    const firstLineIndent = actualText.split("\r?\n").find(line => line.length > 0)?.match(/^\s+/)?.[0];
-    if (!firstLineIndent) {
-        return actualText;
-    }
-    return actualText.replaceAll(new RegExp("^" + firstLineIndent, 'mg'), "").replace(/\n{2}$/, "\n");
+function dedent(text, ...values) {
+    const lines = text.reduce((result, part, i) => result + String(values[i - 1]) + part).split(/\r?\n/);
+    // A template that opens and closes on its own line frames the content with two throwaway lines
+    if (lines[0]?.trim() === "") {
+        lines.shift();
+    }
+    if (lines.length > 1 && lines.at(-1)?.trim() === "") {
+        lines.pop();
+    }
+    // Only the lines with content get a say in the indent, and a line break must never count as one
+    const indent = lines.filter(line => line.trim() !== "")
+        .reduce((shortest, line) => {
+        const lineIndent = /^[ \t]*/.exec(line)?.[0] ?? "";
+        return shortest === undefined || lineIndent.length < shortest.length ? lineIndent : shortest;
+    }, undefined);
+    return indent
+        ? lines.map(line => line.startsWith(indent) ? line.substring(indent.length) : line).join("\n")
+        : lines.join("\n");
 }
 function resolveLegacyBlockScriptsInFolder(folder) {
     const blockScriptEntrypoints = [];

package/dist/utils/common-config-helpers.d.ts

@@ -1,6 +1,6 @@
 import type { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "../plugins/AbstractBiPhasicGroupAndEntryPlugin";
 import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDependencyInjectorPlugin";
-import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata, WebpackPlugin } from "../shared";
+import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata } from "../shared";
 import type { Compiler, Configuration, DynamicEntryPlugin, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals' | 'standard'>> & {
@@ -8,7 +8,7 @@ export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpre
     currentVariables: Record<string, any>;
 } & Pick<PlauditWordpressWebpackConfig, 'externals'>;
 export type CommonPluginConfig = {
-    plugins: (WebpackPluginInstance | WebpackPlugin | ((this: Compiler, compiler: Compiler) => void))[];
+    plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
     makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
 };

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

@@ -243,8 +243,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     const resolvedBlockEntrypoints = presentEntrypoints
                         .map(presentEntrypoint => {
                         const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
-                        const overallSourceRelativeName = (0, node_path_1.relative)(overallSource, (0, node_path_1.normalize)((0, node_path_1.join)(blockJsonOrigin, (0, node_path_1.relative)(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
-                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandleSuffix)(dest.locations.handle, overallSourceRelativeName);
+                        // The handle suffix is the asset's extensionless name relative to its own block, so it
+                        // has to come off the real on-disk path rather than the destination-relative expected src.
+                        const parsedAbsoluteSrc = (0, node_path_1.parse)(presentEntrypoint.absoluteSrc);
+                        const overallSourceRelativeName = (0, node_path_1.normalize)((0, node_path_1.join)((0, node_path_1.relative)(overallSource, parsedAbsoluteSrc.dir), parsedAbsoluteSrc.name));
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
                         let explicitlySetHandle;
                         if (presentEntrypoint.handle) {
@@ -265,8 +267,9 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         else {
                             explicitlySetHandle = undefined;
                         }
+                        const emittableHandle = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, handlePrefix, explicitlySetHandle ? explicitlySetHandle.substring(handlePrefix.length + 1) : overallSourceRelativeName);
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: explicitlySetHandle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: emittableHandle, dest, handleGroup };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -281,7 +284,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: explicitlySetHandle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            handle: emittableHandle,
                             handleGroup,
                             dest
                         };
@@ -304,15 +307,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         const packageJsonOrigin = (0, node_path_1.join)(dir, 'package.json');
                         const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, s => commonConfig.scriptExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                         if (!processingModules && packageJson['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, s => shared_1.styleExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || (!processingModules && shared_1.styleExtension.test(ep))));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.
@@ -414,10 +417,12 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
         outputLibrary = webpackConfig.output?.library;
     }
     const extensions = processingModules ? ['.mjsx', '.mjs', '.mtsx', '.mts', '...'] : ['.jsx', '.tsx', '.ts', '...'];
+    // `dist` (SERVER_MODE=production, or omitDistDev) is always minified production. `dist-dev` follows NODE_ENV so `wp-scripts start` stays fast.
+    const isProductionBuild = !(0, shared_1.isDistDevOutputPath)(config.outputDir) || process.env['NODE_ENV'] === 'production';
     return {
         ...webpackConfig,
-        devtool: 'source-map',
-        mode: "production",
+        devtool: isProductionBuild ? 'source-map' : (webpackConfig.devtool ?? 'eval-cheap-module-source-map'),
+        mode: isProductionBuild ? 'production' : 'development',
         output: {
             ...webpackConfig.output,
             path: outPath,
@@ -428,6 +433,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
         },
         optimization: {
             ...webpackConfig.optimization,
+            minimize: isProductionBuild,
             splitChunks: {
                 ...(webpackConfig.optimization?.splitChunks || {}),
                 cacheGroups: {
@@ -447,10 +453,12 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
                     default: false
                 }
             },
-            minimizer: [
-                ...(webpackConfig.optimization?.minimizer || []),
-                new css_minimizer_webpack_plugin_1.default()
-            ]
+            minimizer: isProductionBuild
+                ? [
+                    ...(webpackConfig.optimization?.minimizer || []),
+                    new css_minimizer_webpack_plugin_1.default()
+                ]
+                : webpackConfig.optimization?.minimizer
         },
         module: {
             ...webpackConfig.module,

package/dist/utils/css-writer.js

@@ -9,7 +9,7 @@ function convertToCSS(writableCSSObject, pretty = true) {
         return convertToCSSPretty(writableCSSObject, "");
     }
     else {
-        return convertToCSS(writableCSSObject);
+        return convertToCSSUgly(writableCSSObject);
     }
 }
 function convertToCSSPretty(writableCSSObject, indentation) {
@@ -23,7 +23,7 @@ function convertToCSSPretty(writableCSSObject, indentation) {
         }
         else {
             res += " {\n";
-            res += convertToCSSPretty(writableCSSObject, indentation + "\t");
+            res += convertToCSSPretty(value, indentation + "\t");
             res += indentation + "}\n";
         }
     }
@@ -39,7 +39,7 @@ function convertToCSSUgly(writableCSSObject) {
             res += `:${value};`;
         }
         else {
-            res += "{" + convertToCSSUgly(writableCSSObject) + "}";
+            res += "{" + convertToCSSUgly(value) + "}";
         }
     }
     return res;

package/dist/utils/entrypoint-resolution-logic.d.ts

@@ -1,10 +1,13 @@
-import { type AdvancedOutputConfig, type PlauditWordpressWebpackConfig } from "../shared";
+import { type AdvancedOutputConfig, type PathQueryParameters, type PlauditWordpressWebpackConfig } from "../shared";
 export declare const enum SourceType {
     blocks = "blocks",
     extensions = "extensions",
     plain = "plain"
 }
 export declare function isSourceType(str: string): str is SourceType;
-type Entrypoints = [string, AdvancedOutputConfig][];
+type ResolvedSourceConfig = AdvancedOutputConfig & {
+    pathQueryParameters?: PathQueryParameters;
+};
+type Entrypoints = [string, ResolvedSourceConfig][];
 export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig, projectRoot?: string): Record<'staticEntrypoints' | 'dynamicEntrypoints', Entrypoints>;
 export {};

package/dist/utils/location-encoding-filename-parser.d.ts

@@ -10,7 +10,6 @@ export type ParsedLocationEncodingFilename = {
         };
     };
     flags: NormalizedEnqueuingControlFlags;
-    niceName?: string;
 };
 export declare function parseLocationEncodingFilename(filename: string): ParsedLocationEncodingFilename | undefined;
 export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): (Omit<ParsedLocationEncodingFilename, 'locations'> & {

package/dist/utils/location-encoding-filename-parser.js

@@ -79,16 +79,17 @@ function parseLocationEncodingFilename(filename) {
         return undefined;
     }
     if (niceName !== undefined) {
-        locations.handle = { niceName };
+        // We need to kebab-case the nice name value for web-safety
+        locations.handle = { niceName: (0, shared_1.kebabCase)(niceName) };
     }
-    return { type, locations, flags, niceName };
+    return { type, locations, flags };
 }
 function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
     const parsedFilename = parseLocationEncodingFilename(filename);
     if (parsedFilename !== undefined) {
         const { handle, ...locations } = parsedFilename.locations;
         if ((0, shared_1.constantKeys)(locations).some(value => value !== 'clientView' && value !== 'clientEditor')) {
-            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename).join(", ")}`, filename);
+            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename.locations).join(", ")}`, filename);
         }
         if (Object.values(locations).some(value => typeof value === 'number')) {
             throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);

package/dist/utils/path-query-and-related-helpers.d.ts

@@ -15,7 +15,6 @@ export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [st
  */
 export declare function unpackPathQuery(pathQuery: string): PathQueryParameters | undefined;
 export type LoadingStrategy = boolean | 'defer' | 'async' | 'eager' | 'lazy' | 'inline';
-export declare function isValidLoadingStrategy(strategy: any): strategy is LoadingStrategy | undefined;
 export declare function newInvalidLoadingStrategyError(strategy: unknown, file: string): import("webpack").WebpackError;
 export type InFooter = boolean;
 export declare function isValidInFooter(in_footer: unknown): in_footer is InFooter;

package/dist/utils/path-query-and-related-helpers.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAssetFileContents = getAssetFileContents;
 exports.unpackPotentiallyPrefixedFilePath = unpackPotentiallyPrefixedFilePath;
 exports.unpackPathQuery = unpackPathQuery;
-exports.isValidLoadingStrategy = isValidLoadingStrategy;
 exports.newInvalidLoadingStrategyError = newInvalidLoadingStrategyError;
 exports.isValidInFooter = isValidInFooter;
 exports.newInvalidInFooterError = newInvalidInFooterError;
@@ -78,9 +77,6 @@ function unpackPathQuery(pathQuery) {
     }, {});
 }
 const namedStrategies = ['defer', 'async', 'eager', 'lazy', 'inline'];
-function isValidLoadingStrategy(strategy) {
-    return strategy === undefined || (typeof strategy === 'string' && namedStrategies.includes(strategy));
-}
 function newInvalidLoadingStrategyError(strategy, file) {
     return (0, shared_1.newWebpackErrorForFile)(`The strategy was invalid. Received: ${strategy}, Expected: undefined|boolean|'${namedStrategies.join("'|'")}'`, file);
 }

package/dist/wordpress-ports/dependency-extraction-webpack-plugin/index.d.ts

@@ -0,0 +1,72 @@
+import LegacyDependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
+import { Compilation, Compiler, Module, type TemplatePath } from "webpack";
+export interface EnhancedDependencyExtractionWebpackPluginOptions {
+    injectPolyfill?: boolean;
+    useDefaults?: boolean;
+    outputFilename?: TemplatePath;
+    requestToExternal?: (request: string) => string | string[] | undefined;
+    requestToExternalModule?: (request: string) => string | boolean | undefined;
+    requestToHandle?: (request: string) => string | undefined;
+    requestToScriptModule?: (request: string) => string | boolean | Error | undefined;
+    externalizedReport?: string | boolean;
+}
+export declare class EnhancedDependencyExtractionWebpackPlugin {
+    /**
+     * Track requests that are externalized.
+     *
+     * Because we don't have a closed set of dependencies, we need to track what has
+     * been externalized so we can recognize them in a later phase when the dependency
+     * lists are generated.
+     */
+    private readonly externalizedDeps;
+    private readonly options;
+    /**
+     * Track requests that a script build externalizes as script modules.
+     *
+     * These can only be reached through a runtime `import()`, which requires
+     * support for dynamic import in the output environment. The set is used
+     * to report an actionable error when that support is missing.
+     */
+    private readonly scriptModuleDepsInScript;
+    /**
+     * Whether we should use modules. This will be set later to match webpack's `output.module` option.
+     */
+    private useModules;
+    constructor(options: EnhancedDependencyExtractionWebpackPluginOptions | LegacyDependencyExtractionWebpackPlugin | EnhancedDependencyExtractionWebpackPlugin);
+    /**
+     * Convert a script module request to an external suitable for a script
+     * build.
+     *
+     * A classic script cannot contain a static `import`, so the `module`
+     * external type is not usable here: the script module has to be reached
+     * through a runtime `import()`, which is the `import` external type. The
+     * bare specifier is resolved by the import map that WordPress prints for
+     * enqueued script modules.
+     *
+     * @param {string}                request  Original module request.
+     * @param {string|boolean|Error=} external Result of a script module external resolution.
+     * @return {string|undefined} The resulting external definition.
+     */
+    static toScriptModuleExternalInScript(request: string, external?: string | boolean | Error): string | undefined;
+    private readonly externalizeWpDeps;
+    /**
+     * @param {string} request
+     * @return {string} Mapped dependency name
+     */
+    protected mapRequestToDependency(request: string): string;
+    apply(compiler: Compiler): void;
+    /**
+     * Check for magic comments before minification, so minification doesn't have to preserve them.
+     */
+    checkForMagicComments(compilation: Compilation): void;
+    addAssets(compilation: Compilation): void;
+    private static readonly staticDepsCurrent;
+    private static readonly staticDepsCache;
+    /**
+     * Can we trace a line of static dependencies from an entry to a module
+     *
+     * @return {boolean} True if there is a static import path to the root
+     */
+    static hasStaticDependencyPathToRoot(compilation: Compilation, block: Module): boolean;
+    readonly addExternalizedDep: (value: string) => Set<string>;
+}