@plaudit/webpack-extensions 3.16.0 → 3.17.0

package/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.17.0] - 2026-08-18
+### Added
+- A port of WordPress's Dependency Extraction Webpack Plugin because they keep breaking it
+  - This comes from version `2.96.0`
+- Warnings and additional info for entrypoints that are lazy-loaded and assigned to actual locations
+  - This comes from version `2.96.0`
+- An `externalize` that is not a string, an array, an object, or false is now rejected rather than silently ignored
+  - This matches with what webpack's `output.library` config supports
+
+### Changed
+- `handle` callbacks are now passed the un-prefixed nice name rather than the fully-prefixed handle
+  - The `{basename}` token in the string form has always substituted the un-prefixed name, so the two spellings of the option disagreed. A callback like ``name => `acme.cb-${name}` `` was producing `acme.cb-my-theme/thing`
+- Nice names taken from a filename are now kebab-cased, the way the basename-derived handle they replace already was
+  - `view.MyThing.ts` is `<prefix>/my-thing` rather than `<prefix>/MyThing`
+  - This is for web-safety
+- `pathQueryParameters` to be an explicitly internal property instead of just asking people to not set it directly
+  - This fixes a few potential "bugs" that could happen if somebody set it anyway
+
+### Fixed
+- `targetNamespace` being derived eagerly for every config, which failed any build run from a directory with no adjacent `composer.json` *or* `style.css`
+  - Only the `lazyLoader` emitters read it, so it now falls back to an empty namespace (this matches the pre-`3.10.0` behavior)
+  - A missing `style.css` also no longer surfaces as a raw `ENOENT`
+
+### Removed
+- `processTranslationConfigs` because it should not be used and didn't actually do anything
+  - This comes from version `2.96.2`
+
+### Internals
+- Added more integration tests
+
 ## [3.16.0] - 2026-08-04
 ### Added
 - Logic so that files and directories with names equal to "example" or "examples" or that include "example" as a name segment are skipped
@@ -230,6 +260,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Legacy PostCSS features that have been integrated into modern CSS
 - `@extends` support
 
+## [2.96.3] - 2026-08-11
+### Added
+- A few more validation checks
+
+## [2.96.2] - 2026-08-11
+### Removed
+- `processTranslationConfigs` because it should not be used and didn't actually do anything
+
+### Internals
+- Added more integration tests
+
+## [2.96.1] - 2026-08-10
+### Fixed
+- An error in how externalized dependencies were resolved that caused jquery to never be emitted as a dependency
+
+## [2.96.0] - 2026-08-07
+### Added
+- A port of WordPress's Dependency Extraction Webpack Plugin because they keep breaking it
+- Warnings and additional info for entrypoints that are lazy-loaded and assigned to actual locations
+
+### Removed
+- "combineAssetMetadata" - it has never actually been a valid prop
+
+### Fixed
+- Path-query handle handling
+- Double emission of CSS from entrypoint.json files when module processing is enabled
+- A bug that could result in writes outside the webpack context root
+
+### Changed
+- Backported the hook_name fix from the 3.x branch
+
 ## [2.95.0] - 2026-08-04
 ### Added
 - Logic so that files and directories with names equal to "example" or "examples" or that include "example" as a name segment are skipped
@@ -465,7 +526,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [2.72.1] - 2025-10-29
 ### Fixed
-- The wrapper being unable to find the `DependencyExtractionWebpackPlugin` due to version desyncs
+- The wrapper being unable to find the `EnhancedDependencyExtractionWebpackPlugin` due to version desyncs
   - This isn't so much a "fix" as it is a "mitigation" - version desyncs are not fixable at the library level
 
 ## [2.72.0] - 2025-10-13

package/USER-GUIDE.md

@@ -109,7 +109,7 @@ However, if you need to do something unusual or just want to know what everythin
 - All file names are informational placeholders. They can be whatever you want provided that they are web-safe (basically, don't do things like calling the email address block "✉️" and you'll be fine)
 
 ### Examples
-- Any uses of `acme-my-plugin` should be replaced with your plugin or theme's kebab-case name (ex: `acme-my-plugin.wp-admin` => `plaudit-base.wp-admin`)
+- Any uses of `acme-my-plugin` should be replaced with your plugin or theme's kebab-case name (ex: `acme-my-plugin/wp-admin` => `plaudit-base/wp-admin`)
 
 ---
 
@@ -205,8 +205,11 @@ After building, each asset gets a handle you can reference in PHP.
 
 ### Handle Format
 
-**Plain:** `{prefix}.{filename}`
-- Example: `acme-my-plugin.admin-editor`
+**Plain:** `{prefix}/{filename}`
+- Example: `acme-my-plugin/admin-editor`
+- If the filename carries a nice-name segment, that segment *replaces* the location-derived name rather than being appended to it, and it is kebab-cased on the way in
+  - `view.MyThing.ts` is `acme-my-plugin/my-thing`, not `acme-my-plugin/view-my-thing`
+  - Because the location is dropped, two files that differ only by location cannot share a nice name
 
 **Blocks:** `{prefix}_blocks_{block-name}-{type}`
 - Example: `acme-my-plugin_blocks_hero-banner-editor-script`
@@ -231,14 +234,14 @@ After building, each asset gets a handle you can reference in PHP.
 add_action('admin_enqueue_scripts', function($hook) {
 	if ($hook === 'post.php') {
 		// Localize data first (optional)
-		wp_localize_script('acme-my-plugin.admin-editor', 'myData', [
+		wp_localize_script('acme-my-plugin/admin-editor', 'myData', [
 			'ajaxUrl' => admin_url('admin-ajax.php'),
 			'nonce' => wp_create_nonce('my_ajax_action'),
 		]);
 		
 		// Then enqueue
-		wp_enqueue_script('acme-my-plugin.admin-editor');
-		wp_enqueue_style('acme-my-plugin.admin-editor');
+		wp_enqueue_script('acme-my-plugin/admin-editor');
+		wp_enqueue_style('acme-my-plugin/admin-editor');
 	}
 });
 ```
@@ -277,7 +280,7 @@ src: {
 // In your plugin
 add_action('admin_enqueue_scripts', function($hook) {
 	if ($hook === 'post.php') {
-		wp_enqueue_script('acme-my-plugin.post-editor');
+		wp_enqueue_script('acme-my-plugin/post-editor');
 	}
 });
 ```
@@ -315,7 +318,7 @@ src: {
 | `srcDir`                           | `string`  | `""`    | Source directory (**Required** on new sites)                                                                                                                                                 |
 | `outputDir`                        | `string`  | `""`    | Output directory (**Required** on new sites)                                                                                                                                                 |
 | `useUnifiedLoader`                 | `boolean` | `false` | Generate unified-loader.php (always set to `true` on new sites!)                                                                                                                             |
-| `useWebpackResourceFiltering`      | `boolean` | `false` | Generates versioned copies of images, fonts, etc (always set to `true` on new sites!)                                                                                                        |
+| `useWebpackResourceFiltering`      | `boolean` | `true`  | Generates versioned copies of images, fonts, etc (always set to `true` on new sites!)                                                                                                        |
 | `plainEntrypointsVersion`          | `1\|2`    | `1`     | Use 2 for new sites                                                                                                                                                                          |
 | `extensionsVersion`                | `1\|2\|3` | `1`     | Use 3 for new sites                                                                                                                                                                          |
 | `verbose`                          | `boolean` | `false` | Verbose logging                                                                                                                                                                              |
@@ -571,11 +574,11 @@ This is the form that *should* be used. It has two categories of keys: control f
 
 **Control Flags:**
 
-| Key                  | Type                                                                     | Default | Description                                                                                                                                      |
-|----------------------|--------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------|
-| `handle`             | `string \| fn(string) => string`                                         | Auto    | The handle by which the entrypoint will be referenced. The function form is passed the default handle for manual tweaking                        |
-| `register`           | `boolean \| number`                                                      | `true`  | **[Advanced]** Whether the entrypoint should be registered at all or, if a number, the priority of the hook in which the registration will occur |
-| `registerScriptArgs` | `boolean` \| `'lazy'` \| [`WordPressScriptArgs`](#wordpress-script-args) | Auto    | The loading flags (strategy, in_footer, and fetchpriority) for the script.<br>'lazy' is an alias for `{strategy: 'defer', in_footer: true}`      |
+| Key                  | Type                                                                     | Default | Description                                                                                                                                                             |
+|----------------------|--------------------------------------------------------------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `handle`             | `string \| fn(string) => string`                                         | Auto    | The handle by which the entrypoint will be referenced. The function form is passed the default handle for manual tweaking, and may return nothing to accept the default |
+| `register`           | `boolean \| number`                                                      | `true`  | **[Advanced]** Whether the entrypoint should be registered at all or, if a number, the priority of the hook in which the registration will occur                        |
+| `registerScriptArgs` | `boolean` \| `'lazy'` \| [`WordPressScriptArgs`](#wordpress-script-args) | Auto    | The loading flags (strategy, in_footer, and fetchpriority) for the script.<br>'lazy' is an alias for `{strategy: 'defer', in_footer: true}`                             |
 
 **Location Identifiers:**
 

package/dist/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -2,7 +2,7 @@ import { MinimumViableMetadata, ParsedAssetJsonProvider, ParsedAssetsJson } from
 import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
-import { Compilation, Compiler, Entrypoint } from "webpack";
+import { type Compilation, type Compiler, type Entrypoint } from "webpack";
 export type EntryProvider<M extends MinimumViableMetadata = MinimumViableMetadata> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
 export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M extends MinimumViableMetadata = MinimumViableMetadata> extends AbstractBiPhasicGroupPlugin {
     private readonly context;

package/dist/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -24,6 +24,7 @@ export declare class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEnt
     constructor(config: VerifiedPlauditWordpressWebpackConfig, dest: VerifiedAdvancedOutputConfig, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<BlockEntrypointInfo>);
     protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): Promise<void>;
     private emitBlockLoaderFile;
+    private static readonly THEME_JSON_FLAG_PROPS;
     private static pickOutFlagPropsFromBlockSupports;
     private callRegisterFunction;
     private transformBlocks;

package/dist/plugins/EnhancedBlockJSONPlugin.js

@@ -226,37 +226,48 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             compilation.emitAsset((0, node_path_1.join)(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
-    // This isn't strictly necessary, but it allows us to trivially eliminate commonly-used block supports flags that aren't used in theme.json
-    // private static readonly IGNORED_THEME_JSON_FLAG_PROPS = ['align', 'alignWide', 'anchor', 'contentRole', 'inserter', 'interactivity', 'listView', 'plaudit'];
+    /*
+     * The block supports that have a boolean counterpart under theme.json's settings, as
+     * `settings key -> {support prop: settings prop}`. This is an allow-list rather than an ignore-list
+     * because most supports (align, alignWide, anchor, contentRole, inserter, interactivity, listView,
+     * plaudit, ...) have no theme.json settings equivalent at all, and the ones that do don't always
+     * share a name: typography's fontSize is settings.typography.customFontSize, and Gutenberg still
+     * ships several of these under an __experimental prefix.
+     */
+    static THEME_JSON_FLAG_PROPS = {
+        color: { background: 'background', link: 'link', text: 'text' },
+        dimensions: { aspectRatio: 'aspectRatio', minHeight: 'minHeight' },
+        spacing: { blockGap: 'blockGap', margin: 'margin', padding: 'padding' },
+        typography: {
+            fontSize: 'customFontSize',
+            lineHeight: 'lineHeight',
+            textAlign: 'textAlign',
+            fontStyle: 'fontStyle', __experimentalFontStyle: 'fontStyle',
+            fontWeight: 'fontWeight', __experimentalFontWeight: 'fontWeight',
+            letterSpacing: 'letterSpacing', __experimentalLetterSpacing: 'letterSpacing',
+            textDecoration: 'textDecoration', __experimentalTextDecoration: 'textDecoration',
+            textTransform: 'textTransform', __experimentalTextTransform: 'textTransform',
+            writingMode: 'writingMode', __experimentalWritingMode: 'writingMode'
+        }
+    };
     static pickOutFlagPropsFromBlockSupports(supports) {
         function isRecord(value) {
             return typeof value === 'object' && !!value && !Array.isArray(value);
         }
         let addedProp = false;
         const res = {};
-        if ('color' in supports) {
-            const color = supports.color;
-            if (isRecord(color)) {
-                const colorFlags = {};
-                for (const prop of ['background', 'link', 'text']) {
-                    if (supports[prop]) {
-                        colorFlags[prop] = true;
-                        res.color = colorFlags;
-                        addedProp = true;
-                    }
-                }
+        for (const [settingsKey, props] of Object.entries(EnhancedBlockJSONPlugin.THEME_JSON_FLAG_PROPS)) {
+            const support = supports[settingsKey];
+            if (!isRecord(support)) {
+                continue;
             }
-        }
-        if ('dimensions' in supports) {
-            const dimensions = supports.dimensions;
-            if (isRecord(dimensions)) {
-                const dimensionsFlags = {};
-                for (const prop of ['aspectRatio']) {
-                    if (supports[prop]) {
-                        dimensionsFlags[prop] = true;
-                        res.color = dimensionsFlags;
-                        addedProp = true;
-                    }
+            const flags = {};
+            for (const [supportProp, settingsProp] of Object.entries(props)) {
+                // A sided support such as `"margin": ["top", "bottom"]` is still just "on" as far as theme.json is concerned
+                if (support[supportProp]) {
+                    flags[settingsProp] = true;
+                    res[settingsKey] = flags;
+                    addedProp = true;
                 }
             }
         }
@@ -536,7 +547,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
             delete blockJson[invalidTemplateLocation];
             if (renderTemplate.length > 1) {
-                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Encountered a block with multiple possible render files. Please set the render key in block.json to the proper one", (0, node_path_1.join)(sourceDir, 'block.json')));
+                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Encountered a block with multiple possible render files. Please set the render key in block.json to the intended one", (0, node_path_1.join)(sourceDir, 'block.json')));
                 blockJson[validTemplateLocation] = renderTemplate.find(p => p.endsWith(".php")) ?? renderTemplate[0];
             }
             else {

package/dist/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -41,20 +41,20 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                     finalHandleName = `${baseFinalHandleName}-${++count}`;
                 }
-                if (typeof handleName === 'string' || typeof handleName === 'function' || (handleName && 'niceName' in handleName)) {
+                if (handleName !== undefined) {
                     finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, handlePrefix, finalHandleName.substring(handlePrefix.length + 1));
                 }
                 handleNameMap[finalHandleName] = src;
                 plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };
             }
         }
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'script', Object.entries(plainEntrypointsConfig.scriptHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script_module', Object.entries(plainEntrypointsConfig.script_moduleHandles)
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'script_module', Object.entries(plainEntrypointsConfig.script_moduleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
         const sortedStyleHandles = Object.entries(plainEntrypointsConfig.styleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b));
-        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('style', sortedStyleHandles, handleLists);
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists(compilation, 'style', sortedStyleHandles, handleLists);
         const callItemSorter = (a, b) => a.handle.localeCompare(b.handle);
         for (const list of Object.values(handleLists)) {
             list.sort(callItemSorter);
@@ -113,8 +113,10 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 writer.return(editorSettings);
             }, { functionArgParameters: [editorSettings], accountForAlreadyDoing: false });
         }
-        const lazyLoadedHandles = Object.values(handleLists)
-            .flatMap(handleList => handleList.map(handle => [handle.data.lazyLoader, handle]))
+        // Only the register and inline lists, which are mutually exclusive, so each handle is collected
+        // exactly once. Flattening every list instead would collect a handle once per location it declares.
+        const lazyLoadedHandles = [...handleLists.register, ...handleLists.inline]
+            .map(handle => [handle.data.lazyLoader, handle])
             .filter((entry) => entry[0] !== undefined)
             .sort((a, b) => a[0].localeCompare(b[0]) || a[1].priority - b[1].priority);
         if (lazyLoadedHandles.length > 0) {
@@ -134,7 +136,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         }
         (0, shared_1.emitPHPWriterAsAsset)(file, compilation, "plain-entrypoints-loader.php");
     }
-    static addHandlesToHandleLists(type, handles, handleLists) {
+    static addHandlesToHandleLists(compilation, type, handles, handleLists) {
         const defaultPriority = 10;
         for (const [handle, data] of handles) {
             if (data.locations.register !== false) {
@@ -143,6 +145,19 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             else if (data.inlinedAsset !== undefined) {
                 handleLists.inline.push({ handle, type, data, priority: typeof data.locations.inline === 'number' ? data.locations.inline : 10 });
             }
+            if (data.lazyLoader !== undefined) {
+                // A lazily loaded handle is enqueued by its generated function and never by an action, so it
+                // is deliberately kept out of the location lists. Those lists are also what the lazy function
+                // is built from, and a handle present in several of them would be enqueued once per list.
+                const declaredLocations = (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)
+                    .filter(location => data.locations[location] || typeof data.locations[location] === 'number');
+                if (declaredLocations.length > 0) {
+                    const locText = declaredLocations.length === 1 ? "location" : "locations";
+                    compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`The handle "${handle}" declares both a lazyLoader (${data.lazyLoader}) and the ${declaredLocations.join(", ")} ${locText}.`
+                        + ` It will only be enqueued by ${data.lazyLoader}(); remove either the ${locText} or the lazyLoader.`, data.src));
+                }
+                continue;
+            }
             for (const location of (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)) {
                 let priority, hook_name;
                 const dataLocation = data.locations[location];
@@ -186,7 +201,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         }
     }
     static appendEnqueuingHandleLists(writer, handleLists) {
-        const lazyLoadableHandles = {};
         for (const [sln, { action, supports_hook_name, additional_action_code }] of (0, shared_1.constantEntries)(shared_1.standardLocationNamesMeta)) {
             const handleList = handleLists[sln];
             if (handleList.length > 0) {
@@ -226,7 +240,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 }
             }
         }
-        return lazyLoadableHandles;
     }
     static separateHandleListByPriority(handleItems) {
         const lists = new Map();

package/dist/plugins/dependency-extraction-webpack-plugin-config-builder.d.ts

@@ -1,7 +1,4 @@
-import DependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
-import { Externals } from "../shared";
+import type { Externals } from "../shared";
+import { EnhancedDependencyExtractionWebpackPlugin } from "../wordpress-ports/dependency-extraction-webpack-plugin";
 import type { Configuration } from "webpack";
-export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, wantsGroupedDepData: boolean, externalizing: Required<Configuration>['output']['library']): {
-    instance: DependencyExtractionWebpackPlugin;
-    addExternalizedDep: (dep: string) => void;
-};
+export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, externalizing: Required<Configuration>['output']['library']): EnhancedDependencyExtractionWebpackPlugin;

package/dist/plugins/dependency-extraction-webpack-plugin-config-builder.js

@@ -1,19 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeDependencyExtractionPlugin = makeDependencyExtractionPlugin;
-const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
-function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries, wantsGroupedDepData, externalizing) {
-    const baseProps = makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing);
-    const instance = new dependency_extraction_webpack_plugin_1.default(wantsGroupedDepData ? { ...baseProps, outputFormat: "json", combineAssets: true } : baseProps);
-    return {
-        instance,
-        addExternalizedDep: (dep) => {
-            instance.externalizedDeps.add(dep);
-        }
-    };
+const dependency_extraction_webpack_plugin_1 = require("../wordpress-ports/dependency-extraction-webpack-plugin");
+const util_1 = require("../wordpress-ports/dependency-extraction-webpack-plugin/util");
+function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries, externalizing) {
+    return new dependency_extraction_webpack_plugin_1.EnhancedDependencyExtractionWebpackPlugin(makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing));
 }
 function makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries, externalizing) {
     if (!externals) {
@@ -93,7 +84,7 @@ const EXTERNALIZABLE_PLAUDIT_LIBRARIES = {
     ...Object.fromEntries(['@plaudit/frontend-apis', '@plaudit/library-extensions', '@plaudit/block-supports', '@plaudit/gutenberg-api-extensions']
         .map(req => {
         return [req, {
-                import: ['plaudit', camelCaseDash(req.substring(PLAUDIT_NAMESPACE.length))],
+                import: ['plaudit', (0, util_1.camelCaseDash)(req.substring(PLAUDIT_NAMESPACE.length))],
                 handle: `plaudit-${req.substring(PLAUDIT_NAMESPACE.length)}`
             }];
     })),
@@ -116,12 +107,6 @@ function normalizeRequest(request) {
 function curryRequestHandlers(primary, secondary) {
     return (...args) => primary(...args) ?? secondary(...args);
 }
-/**
- * Copied from @wordpress/dependency-extraction-webpack-plugin for consistency
- */
-function camelCaseDash(string) {
-    return string.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-}
 function handleExternalizingEqualsPossibleExternal(possibleExternal, ext) {
     if (!ext || !possibleExternal) {
         return possibleExternal;
@@ -151,7 +136,9 @@ function handleExternalizingEqualsPossibleExternal(possibleExternal, ext) {
     }
     else {
         for (const key of ['amd', 'commonjs', 'root']) {
-            if (key in ext && handleExternalizingEqualsPossibleExternal(possibleExternal, ext[key])) {
+            // The recursion returns the external when it should be kept and undefined when it matched, so
+            // only an undefined result means this umd name is the thing being built and must not externalize.
+            if (key in ext && handleExternalizingEqualsPossibleExternal(possibleExternal, ext[key]) === undefined) {
                 return undefined;
             }
         }

package/dist/shared.d.ts

@@ -5,17 +5,20 @@ import { type AssetInfo, type Compilation, type Configuration, type Entrypoint,
 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';
@@ -120,16 +123,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 +147,6 @@ export type PlauditWordpressWebpackConfig = {
     };
     externals?: Externals;
     assumeGlobalizedPlauditLibraries?: boolean;
-    processTranslationConfigs?: boolean;
-    combineAssetMetadata?: boolean;
     useWebpackResourceFiltering?: boolean;
     outputDir?: string;
     extensionsVersion?: 1 | 2 | 3;
@@ -172,8 +173,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 +218,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 +231,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[]];
@@ -260,7 +258,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

@@ -28,7 +28,6 @@ exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.applyStandards = applyStandards;
 exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
-exports.convertUsageLocationsHandleToEmittableHandleSuffix = convertUsageLocationsHandleToEmittableHandleSuffix;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -87,7 +86,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);
@@ -146,37 +145,23 @@ function resolveStandard(standard) {
             return undefined;
     }
 }
-function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, generatedNiceName) {
+function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, handleSuffix) {
+    const generatedHandle = `${handlePrefix}/${handleSuffix}`;
     let emittableHandle;
     if (!handle) {
-        return `${handlePrefix}/${generatedNiceName}`;
+        return generatedHandle;
     }
     if (typeof handle === 'string') {
         emittableHandle = handle;
     }
     else if (typeof handle === 'function') {
-        emittableHandle = handle(`${handlePrefix}/${generatedNiceName}`);
+        emittableHandle = handle(generatedHandle);
     }
     else {
-        emittableHandle = `${handlePrefix}/${handle.niceName}`;
+        emittableHandle = handle.niceName && `${handlePrefix}/${handle.niceName}`;
     }
-    return emittableHandle.replaceAll("{basename}", generatedNiceName);
-}
-function convertUsageLocationsHandleToEmittableHandleSuffix(handle, generatedNiceName) {
-    let emittableHandle;
-    if (!handle) {
-        return generatedNiceName;
-    }
-    if (typeof handle === 'string') {
-        emittableHandle = handle;
-    }
-    else if (typeof handle === 'function') {
-        emittableHandle = handle(generatedNiceName);
-    }
-    else {
-        emittableHandle = 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)
@@ -313,18 +298,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 +341,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 = [];