@plaudit/webpack-extensions 3.11.0 → 3.12.1

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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
+
+### Changed
+- The handle-part-separator for plain entrypoints from `.` to `/`
+
 ## [3.11.0] - 2026-06-22
 ### Added
 - Logic to allow our internal PostCSS plugins to be "optional"

package/dist/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -43,15 +43,15 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             for (const { src, rest, locations, type, handleName, lazyLoader, ...otherProps } of handles) {
                 const cleanBasename = (0, node_path_1.basename)(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
-                if (typeof handleName === 'string') {
-                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, cleanBasename);
+                const handleNameMap = usedHandleNames[type];
+                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, handlePrefix, finalHandleName.substring(handlePrefix.length + 1));
                 }
                 else {
-                    const handleNameMap = usedHandleNames[type];
-                    const baseFinalHandleName = finalHandleName = `${handlePrefix}.${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(cleanBasename), cleanBasename)}`;
-                    for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
-                        finalHandleName = `${baseFinalHandleName}-${++count}`;
-                    }
                     handleNameMap[finalHandleName] = src;
                 }
                 plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };

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

@@ -40,13 +40,13 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
         .map(([ep, rawPathQueryParameters]) => {
         const parsedEntrypoint = (0, node_path_1.parse)(ep);
         const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
-        const { flags: enqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, ep, 'path query parameters');
+        const { flags: enqueuingFlags, remainder: pathQueryParameters, handle } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, ep, 'path query parameters');
         const fakeEntrypointInfo = {
             blockJsonOrigin: args.entrypointJsonOrigin,
             entrypointField,
             originalValue: ep,
             entrypointName: parsedEntrypoint.name,
-            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(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
@@ -228,19 +229,44 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         a[entry.entrypointName] = (a[entry.entrypointName] !== undefined);
                         return a;
                     }, {});
+                    const getDefaultHandle = (presentEntrypoint) => {
+                        const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
+                        let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
+                        while (((deduplicatedEntrypointName = (presentEntrypoint.entrypointName + suffix)) in allocatedDestinations)
+                            && allocatedDestinations[deduplicatedEntrypointName] !== presentEntrypoint.originalValue) {
+                            suffix = baseSuffix + "_" + (++count);
+                        }
+                        return { count, suffix, deduplicatedEntrypointName };
+                    };
                     const handlePrefix = blockJson['name']?.toString() ?? `__UNKNOWN_PREFIX__/${dirent.name}`;
                     const allocatedDestinations = {};
                     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.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
+                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandleSuffix)(dest.locations.handle, overallSourceRelativeName);
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
+                        let explicitlySetHandle;
                         if (presentEntrypoint.handle) {
-                            (seenExplicitHandles[handleGroup][presentEntrypoint.handle] ??= []).push(overallSource);
+                            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: presentEntrypoint.handle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: explicitlySetHandle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -255,7 +281,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: presentEntrypoint.handle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
+                            handle: explicitlySetHandle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            handleGroup,
                             dest
                         };
                     });

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

@@ -4,14 +4,19 @@ export type ParsedLocationEncodingFilename = {
     type: 'script' | 'style' | 'script-module';
     locations: RealUsageLocations & {
         register?: boolean | number;
+    } & {
+        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

@@ -78,17 +78,22 @@ function parseLocationEncodingFilename(filename) {
     if (Object.values(locations).length === 0) {
         return undefined;
     }
+    if (niceName !== undefined) {
+        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/utils/path-query-and-related-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Compilation } from "webpack";
-import { type InlinedAsset, type PathQueryParameters, type ScriptArgsObject } from "../shared";
+import { type InlinedAsset, type PathQueryParameters, type ScriptArgsObject, type UsageLocations } from "../shared";
 export declare function getAssetFileContents(compilation: Compilation, name: string): string;
 export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [string, PathQueryParameters | undefined];
 /**
@@ -39,7 +39,7 @@ export type NormalizedEnqueuingControlFlags = {
 export declare function mergeTwoEnqueuingControlFlagSets(file: string, ...argsBlocks: (NormalizedEnqueuingControlFlags | undefined)[]): NormalizedEnqueuingControlFlags | undefined;
 export declare function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters: PathQueryParameters | undefined, file: string, sourceType: 'registerScriptArgs' | 'path query parameters'): {
     flags?: NormalizedEnqueuingControlFlags;
-    handle?: string;
+    handle?: UsageLocations['handle'];
     remainder?: PathQueryParameters;
 };
 /**

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.11.0",
+  "version": "3.12.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/dist",
@@ -48,7 +48,7 @@
     "@plaudit/postcss-variables": "^2.0.1",
     "@wordpress/dependency-extraction-webpack-plugin": "^6.48.1",
     "@wordpress/scripts": "^32.4.1",
-    "autoprefixer": "^10.5.0",
+    "autoprefixer": "^10.5.1",
     "browser-sync": "^3.0.4",
     "copy-webpack-plugin": "10.2.4",
     "css-minimizer-webpack-plugin": "^8.0.0",