@plaudit/webpack-extensions 3.12.0 → 3.12.1

package/CHANGELOG.md

@@ -5,6 +5,10 @@ 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.12.1] - 2026-06-23
+### Fixed
+- The nice name handling not working for blocks
+
 ## [3.12.0] - 2026-06-23
 ### Added
 - Logic to treat the nice name of a file as the suffix of its handle

package/dist/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -44,12 +44,12 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 const cleanBasename = (0, node_path_1.basename)(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
                 const handleNameMap = usedHandleNames[type];
-                const baseFinalHandleName = finalHandleName = `${handlePrefix}/${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(cleanBasename), cleanBasename)}`;
+                const baseFinalHandleName = finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)({ niceName: (0, shared_1.kebabCase)(cleanBasename) }, handlePrefix, cleanBasename);
                 for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                     finalHandleName = `${baseFinalHandleName}-${++count}`;
                 }
                 if (typeof handleName === 'string' || typeof handleName === 'function') {
-                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, finalHandleName);
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, handlePrefix, finalHandleName.substring(handlePrefix.length + 1));
                 }
                 else {
                     handleNameMap[finalHandleName] = src;

package/dist/shared.d.ts

@@ -78,7 +78,9 @@ export type RealUsageLocations = {
 export type UsageLocations = RealUsageLocations & {
     register?: boolean | number;
     inline?: number;
-    handle?: string | ((generatedHandle: string) => string);
+    handle?: string | ((generatedHandle: string) => string) | {
+        niceName: string;
+    };
     registerScriptArgs?: InputRegisterScriptArgs;
 };
 export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'> & {
@@ -207,7 +209,8 @@ export type MinimumViableMetadata = {
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
 };
-export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): 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 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])[];

package/dist/shared.js

@@ -28,6 +28,7 @@ exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.applyStandards = applyStandards;
 exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
+exports.convertUsageLocationsHandleToEmittableHandleSuffix = convertUsageLocationsHandleToEmittableHandleSuffix;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -143,9 +144,37 @@ function resolveStandard(standard) {
             return undefined;
     }
 }
-function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
-    const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
-    return emittableHandle.replaceAll("{basename}", generatedHandle);
+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) {
+    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);
 }
 function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
     const prettyPrintedMetadata = php_writer_1.json2php.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)

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

@@ -46,7 +46,7 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             entrypointField,
             originalValue: ep,
             entrypointName: parsedEntrypoint.name,
-            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handle ?? dest.locations.handle, parsedEntrypoint.name),
+            handle: handle ?? dest.locations.handle ? (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handle ?? dest.locations.handle, parsedEntrypoint.name, parsedEntrypoint.name) : parsedEntrypoint.name,
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
             dest,
             absoluteSrc: ep,
@@ -157,6 +157,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                                 if (!stats.isFile()) {
                                     return undefined;
                                 }
+                                //TODO: Handle alternate methods of declaring a handle
                                 const parsedEntrypoint = (0, node_path_1.parse)((0, node_path_1.normalize)((0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), entrypointPath)));
                                 const extensionlessExpectedSrc = (0, node_path_1.normalize)((0, node_path_1.join)(parsedEntrypoint.dir, parsedEntrypoint.name));
                                 const entrypointName = (0, node_path_1.normalize)(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
@@ -180,7 +181,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         if (!parsedFilename) {
                             continue;
                         }
-                        const { type, locations, flags } = parsedFilename;
+                        const { type, locations, handle, flags } = parsedFilename;
                         if (((type === 'script-module') !== processingModules)) {
                             continue;
                         }
@@ -219,7 +220,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             absoluteSrc,
                             pathQueryParameters: dest.pathQueryParameters,
                             enqueuingFlags,
-                            handle: undefined
+                            handle
                         });
                     }
                     const entrypointNamesWithEffectiveDuplicates = presentEntrypoints
@@ -243,17 +244,27 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         .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.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
+                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandleSuffix)(dest.locations.handle, overallSourceRelativeName);
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
-                        const explicitlySetHandle = typeof presentEntrypoint.handle === 'string'
-                            ? presentEntrypoint.handle
-                            : presentEntrypoint.handle?.(getDefaultHandle(presentEntrypoint).deduplicatedEntrypointName);
-                        if (explicitlySetHandle) {
+                        let explicitlySetHandle;
+                        if (presentEntrypoint.handle) {
+                            if (typeof presentEntrypoint.handle === 'string') {
+                                explicitlySetHandle = presentEntrypoint.handle;
+                            }
+                            else if ('niceName' in presentEntrypoint.handle) {
+                                explicitlySetHandle = `${handlePrefix}/${presentEntrypoint.handle.niceName}`;
+                            }
+                            else {
+                                explicitlySetHandle = presentEntrypoint.handle(`${handlePrefix}/${getDefaultHandle(presentEntrypoint)}`);
+                            }
                             if (explicitlySetHandle.length < 5) {
                                 throw (0, shared_1.newWebpackErrorForFile)(`The handle was invalid. Received: ${explicitlySetHandle}. Expected: a string that is at least 5 characters long`, overallSourceRelativeName);
                             }
                             (seenExplicitHandles[handleGroup][explicitlySetHandle] ??= []).push(overallSource);
                         }
+                        else {
+                            explicitlySetHandle = undefined;
+                        }
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
                             return { blockJsonOrigin, ...presentEntrypoint, handle: explicitlySetHandle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
                         }
@@ -270,7 +281,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: explicitlySetHandle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
+                            handle: explicitlySetHandle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            handleGroup,
                             dest
                         };
                     });

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

@@ -1,17 +1,22 @@
-import { RealUsageLocations, UsageLocations } from "../shared";
+import { RealUsageLocations } from "../shared";
 import { NormalizedEnqueuingControlFlags } from "./path-query-and-related-helpers";
 export type ParsedLocationEncodingFilename = {
     type: 'script' | 'style' | 'script-module';
     locations: RealUsageLocations & {
         register?: boolean | number;
-    } & Pick<UsageLocations, 'handle'>;
+    } & {
+        handle?: {
+            niceName: string;
+        };
+    };
     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'> & {
+export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): (Omit<ParsedLocationEncodingFilename, 'locations'> & {
     locations: Pick<RealUsageLocations, 'clientEditor' | 'clientView'>;
-} | undefined;
+    handle: ParsedLocationEncodingFilename['locations']['handle'];
+}) | undefined;
 /**
  * This handles detecting all keys of standardLocationNamesMeta as well as "view", "client-view", "editor", "client-editor", and "block-assets".
  * It MUST be kept in sync with standardLocationNamesMeta

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

@@ -79,22 +79,21 @@ function parseLocationEncodingFilename(filename) {
         return undefined;
     }
     if (niceName !== undefined) {
-        locations.handle = generatedHandle => {
-            const lastSlash = generatedHandle.lastIndexOf('/');
-            return (lastSlash > 0 ? generatedHandle.substring(0, lastSlash) : generatedHandle) + "/" + niceName;
-        };
+        locations.handle = { niceName };
     }
     return { type, locations, flags, niceName };
 }
 function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
     const parsedFilename = parseLocationEncodingFilename(filename);
     if (parsedFilename !== undefined) {
-        if ((0, shared_1.constantKeys)(parsedFilename.locations).some(value => value !== 'clientView' && value !== 'clientEditor')) {
+        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);
         }
-        if (Object.values(parsedFilename.locations).some(value => typeof value === 'number')) {
+        if (Object.values(locations).some(value => typeof value === 'number')) {
             throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);
         }
+        return { ...parsedFilename, handle, locations };
     }
     return parsedFilename;
 }

package/dist/wordpress-scripts-wrapper.js

@@ -216,7 +216,7 @@ function buildVerifiedConfig(config) {
         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 normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
-        const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
+        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 ?? {};
         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'");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "3.12.0",
+  "version": "3.12.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/dist",