@plaudit/webpack-extensions 2.86.0 → 2.87.1

package/CHANGELOG.md

@@ -5,6 +5,73 @@ 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.3.0] - 2026-03-16
+### Added
+- A few helper methods for tools that reference this package and care about the entrypoint resolution logic
+
+## [3.2.2] - 2026-03-16
+### Changed
+- Exposed additional aspects of the entrypoint resolution logic to tools that reference this package
+
+## [3.2.1] - 2026-03-16
+### Added
+- A function to expose standard flag sets to tools that reference this package
+
+## [3.2.0] - 2026-03-16
+### Added
+- Support for `Location-Encoding Filenames`
+  - This comes from version `2.86.0`
+- Support for standardized flag sets
+  - This comes from version `2.86.0`
+
+## [3.1.2] - 2026-03-06
+### Fixed
+- `defer` and `async` not being supported strategies in some pipelines
+  - This comes from version `2.85.3`
+
+## [3.1.1] - 2026-03-06
+### Fixed
+- Inlined scripts without any other path query parameters not being placed in the footer by default
+  - This comes from version `2.85.2`
+
+## [3.1.0] - 2026-03-05
+### Added
+- Support for inlining (and otherwise controlling the enqueuing of) assets
+  - This only applies to plain entrypoints and assets declared within block.json files at present
+  - This comes from version `2.85.0`
+
+## [3.0.1] - 2026-02-12
+### Added
+- Release version!
+
+## [3.0.0-rc.3] - 2026-02-12
+### Fixed
+- A missing dependency
+
+## [3.0.0-rc.2] - 2026-02-12
+### Fixed
+- A missing dependency
+
+## [3.0.0-rc.1] - 2026-02-12
+### Changed
+- Updated all postcss plugins to their latest available versions
+
+### Removed
+- Legacy PostCSS features that have been integrated into modern CSS
+- `@extends` support
+
+## [2.87.1] - 2026-03-17
+### Changed
+- The `blockdir-loader.php` generation logic to use static wp_register_* calls like `plain-entrypoints-loader.php`
+
+## [2.87.0] - 2026-03-16
+### Added
+- Support for a directory-based `extensions` layout
+  - This only applies to sites using extensions v2 and higher
+
+### Internals
+- Backported the features from `3.2.x` and `3.3.0`
+
 ## [2.86.0] - 2026-03-16
 ### Added
 - Support for `Location-Encoding Filenames`

package/USER-GUIDE.md

@@ -501,8 +501,10 @@ This is used to associate additional assets with blocks that are not in control
 [Specially named files](#file-naming) in a single subdirectory of `src`
 ```
 src/extensions/
-├── core-paragraph-view-script.ts
-└── core-paragraph-editor-style.pcss
+├─ core/paragraph/
+│  ├─ view.ts
+│  └─ editor.pcss
+└─ plaudit/block-library/accordion/style.pcss
 ```
 
 #### File Naming
@@ -513,6 +515,9 @@ Filenames **must** follow the pattern: `{kebab-case-block-name}-{type}.{ext}`
   - `script-module`, `view-script-module`
   - `setup` (this allows for PHP code to be loaded only when certain blocks are enabled and is intended for use in plugins, not themes)
 - `ext` **must** be for a [supported file type](#supported-file-types) and **should** correspond with the extension type (basically, don't enqueue a `.css` file as a script)
+- For convenience, everything before the `{type}` can be split into directories on the hyphens
+  - When using this format, the filenames must be [Location-Encoding Filenames](#location-encoding-filenames) or `setup.php`
+  - This is only available in extensions v2 and up
 
 #### Notes
 - In order to have a directory be treated as `extensions`, the config **must** include `directoryLayout: 'extensions'`

package/build/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -22,6 +22,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 callRegisterFunction;
     private transformBlocks;
     private static extractAssetSource;
     private static convertToScriptHandles;

package/build/plugins/EnhancedBlockJSONPlugin.js

@@ -136,15 +136,23 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             const finalizedMetadata = Object.fromEntries(Object.entries(metadata)
                 .map(([key, value]) => {
                 if (key === 'scriptHandles') {
-                    return [key, finalizedScriptHandles];
+                    return [key, []];
                 }
                 if (key === 'styleHandles') {
-                    return [key, finalizedStyleHandles];
+                    return [key, []];
+                }
+                if (key === 'scriptModuleHandles') {
+                    return [key, []];
                 }
                 return [key, value];
             }));
             const writer = new php_writer_1.PHPWriter()
                 .action("init", writer => {
+                const baseUriVar = new expressions_1.Var("base_uri");
+                writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
+                this.callRegisterFunction('script', writer, baseUriVar, Object.entries(finalizedScriptHandles));
+                this.callRegisterFunction('style', writer, baseUriVar, Object.entries(finalizedStyleHandles));
+                this.callRegisterFunction('script_module', writer, baseUriVar, Object.entries(metadata.scriptModuleHandles));
                 writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [
                     expressions_1.Constants.__DIR__, // string $dir
                     new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")), // array $blockdirConfig
@@ -165,6 +173,11 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
+    callRegisterFunction(type, writer, baseUriVar, handles) {
+        for (const [name, { src, rest }] of handles) {
+            writer.call(`wp_register_${type}`, [name, src === false ? false : expressions_1.Op.concat(baseUriVar, src), ...rest]);
+        }
+    }
     transformBlocks(compilation, collatedWorkableBlockInfo, emittingWpmlXml) {
         const handleData = Object.values(collatedWorkableBlockInfo)
             .flatMap(bi => bi.workableBlockEntrypointsInfo)

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,15 +1,19 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetJsonProvider, VerifiedAdvancedOutputConfig } from "../shared";
+import { MinimumViableMetadata, ParsedAssetJsonProvider, VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin {
+export type ExtensionConfigFileGeneratorMetadata = MinimumViableMetadata & {
+    extensionId: string;
+};
+export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<ExtensionConfigFileGeneratorMetadata> {
     private readonly extensionsSrcPath;
     private readonly dest;
     private static readonly semaphore;
     private setupFiles;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsSrcPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsSrcPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider<ExtensionConfigFileGeneratorMetadata>);
     get extensionsDestPath(): string;
     apply(compiler: Compiler): void;
+    private walkSubtreeForMetaInfo;
     private generateVersionThreeConfigFile;
     protected attachUniquePhase(compilation: Compilation): void;
     protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): void;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -1,11 +1,41 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPlugin = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importStar(require("node:path"));
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
@@ -34,24 +64,49 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryP
                 compilation.contextDependencies.add(this.extensionsSrcPath);
             }
             const emissionPromises = [];
-            for await (const { name: setupFilePath } of await promises_1.default.opendir(this.extensionsSrcPath, { encoding: 'utf-8' })) {
+            for await (const { name: setupFilePath } of await (0, promises_1.opendir)(this.extensionsSrcPath, { encoding: 'utf-8' })) {
                 if (setupFilePath.endsWith("-setup.php")) {
                     const setupFileSourcePath = node_path_1.default.join(this.extensionsSrcPath, setupFilePath);
                     compilation.fileDependencies.add(setupFileSourcePath);
-                    emissionPromises.push(promises_1.default.readFile(setupFileSourcePath).then(contents => {
+                    emissionPromises.push((0, promises_1.readFile)(setupFileSourcePath).then(contents => {
                         compilation.emitAsset(node_path_1.default.join(this.dest.destination, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
                         const blockSlug = /^(.+?)-setup.php$/i.exec(setupFilePath)?.[1];
                         return [blockSlug, setupFilePath];
                     }));
                 }
             }
+            await this.walkSubtreeForMetaInfo(compilation, this.extensionsSrcPath, this.dest, [], emissionPromises);
             this.setupFiles = (await Promise.all(emissionPromises))
                 .filter((item) => item[0] !== undefined).sort((a, b) => a[0].localeCompare(b[0]));
         });
     }
+    async walkSubtreeForMetaInfo(compilation, srcRoot, dest, parents, emissionPromises) {
+        if (!compilation.contextDependencies.has(srcRoot)) {
+            compilation.contextDependencies.add(srcRoot);
+        }
+        for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
+            if (dirent.name.startsWith("~")) {
+                continue;
+            }
+            if (dirent.isFile()) {
+                if (dirent.name === "setup.php") {
+                    const setupFilePath = (0, node_path_1.join)(...parents, dirent.name);
+                    const setupFileSourcePath = node_path_1.default.join(this.extensionsSrcPath, setupFilePath);
+                    compilation.fileDependencies.add(setupFileSourcePath);
+                    emissionPromises.push((0, promises_1.readFile)(setupFileSourcePath).then(contents => {
+                        compilation.emitAsset(node_path_1.default.join(this.dest.destination, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                        return [parents.join("-") /* blockSlug */, setupFilePath];
+                    }));
+                }
+            }
+            else if (dirent.isDirectory()) {
+                await this.walkSubtreeForMetaInfo(compilation, (0, node_path_1.join)(srcRoot, dirent.name), dest, [...parents, dirent.name], emissionPromises);
+            }
+        }
+    }
     generateVersionThreeConfigFile(compilation, relevantAssetData, setupFilePaths) {
         const handlePrefix = `${this.config.targetHandlePrefix}_block-extensions`;
-        const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+        const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))$/i;
         const blockExtensionsConfig = {
             metadata: { version: this.config.extensionsVersion }, scriptHandles: {}, scriptModuleHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {}
         };
@@ -62,7 +117,7 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryP
             return [assetPath, entry[1]];
         });
         for (const [assetPath, assetData] of normalizedAssetData) {
-            const match = regex.exec(assetPath);
+            const match = regex.exec(assetData.extensionId);
             if (!match) {
                 continue;
             }
@@ -127,7 +182,16 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryP
         });
     }
     processAssets(compilation, parsedAssetJsonProvider) {
-        const relevantAssetData = this.extractRelevantAssetData(compilation, parsedAssetJsonProvider);
+        const relevantAssetData = Object.fromEntries(this.getRelevantEntrypoints(compilation)
+            .map(({ entrypoint, metadata, srcPath }) => {
+            const providedData = parsedAssetJsonProvider(entrypoint, metadata);
+            if (providedData === undefined) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                return undefined;
+            }
+            return [providedData.assetName, { ...providedData.assetData, extensionId: metadata.extensionId }];
+        })
+            .filter(item => item !== undefined));
         const staticallyLoadedEntrypoints = Object.keys(relevantAssetData);
         const generateLoader = (writer) => {
             writer.require(this.extensionsDestPath + "extensions-loader.php", { dirRelative: true, once: true });

package/build/shared.d.ts

@@ -1,7 +1,9 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
 import { AssetInfo, Compilation, Configuration, Entrypoint, WebpackError, Compiler } 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 ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
@@ -83,12 +85,6 @@ export declare function constantKeys<K extends string, V>(object: {
 export declare function constantEntries<K extends string, V>(object: {
     [k in K]: V;
 }): [K, V][];
-export declare const enum SourceType {
-    blocks = "blocks",
-    extensions = "extensions",
-    plain = "plain"
-}
-export declare function isSourceType(str: string): str is SourceType;
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
 export interface WebpackPlugin {
     apply(compiler: Compiler): void;
@@ -146,6 +142,41 @@ export type PlauditWordpressWebpackConfig = {
     omitDistDev?: boolean;
     onlyRunPostCSSOnPCSS?: boolean;
 };
+export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
+    readonly standard?: "2026-03-13";
+    readonly standaloneBlocks?: boolean;
+    readonly variables?: Record<string, any>;
+    readonly verbose?: boolean;
+    readonly src?: string[] | SourcesObject;
+    readonly stats?: Configuration["stats"];
+    readonly postcss?: {
+        functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions["functions"];
+    };
+    readonly externals?: Externals;
+    readonly assumeGlobalizedPlauditLibraries?: boolean;
+    readonly processTranslationConfigs?: boolean;
+    readonly combineAssetMetadata?: boolean;
+    useWebpackResourceFiltering?: boolean;
+    outputDir?: string;
+    extensionsVersion?: 1 | 2 | 3;
+    readonly targetHandlePrefix?: string;
+    plainEntrypointsVersion?: 1 | 2;
+    srcDir?: string;
+    readonly srcPrefixes?: string[];
+    useUnifiedLoader?: boolean;
+    readonly includePostInitFallback?: boolean;
+    readonly omitDistDev?: boolean;
+    onlyRunPostCSSOnPCSS?: boolean;
+};
+export declare function resolveStandard(standard: PlauditWordpressWebpackConfig['standard']): {
+    readonly useWebpackResourceFiltering: true;
+    readonly extensionsVersion: 3;
+    readonly plainEntrypointsVersion: 2;
+    readonly srcDir: "src";
+    readonly outputDir: "dist";
+    readonly useUnifiedLoader: true;
+    readonly onlyRunPostCSSOnPCSS: true;
+} | undefined;
 export type FileSegmentBlockEntrypointInfo = {
     blockJsonOrigin: string;
     entrypointField: EntrypointFields[number];
@@ -178,7 +209,7 @@ export declare const scriptExtension: RegExp;
 export declare const scriptWithoutModuleExtension: RegExp;
 export declare const scriptWithModuleExtension: RegExp;
 export declare const styleExtension: RegExp;
-export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "style" | "script" | "";
+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 getHandleGroup(field: string): 'styleHandles' | 'scriptHandles' | 'scriptModuleHandles';
@@ -217,4 +248,3 @@ export declare function resolveLegacyBlockScriptsInFolder(folder: string): strin
  * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
  */
 export declare function appendAddInlineAssetCall(compilation: Compilation, writer: PHPWriter, handle: string, type: 'script' | 'style' | 'script_module', inlinedAsset: InlinedAsset, handleData: HandleData, file: string): void;
-export {};

package/build/shared.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,8 +24,9 @@ exports.isRegisterScriptArgsShorthandName = isRegisterScriptArgsShorthandName;
 exports.isNormalizedUsageLocations = isNormalizedUsageLocations;
 exports.constantKeys = constantKeys;
 exports.constantEntries = constantEntries;
-exports.isSourceType = isSourceType;
 exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.applyStandards = applyStandards;
+exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
@@ -40,6 +55,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const webpack_1 = require("webpack");
+__exportStar(require("./utils/entrypoint-resolution-logic"), exports);
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -77,9 +93,6 @@ function constantKeys(object) {
 function constantEntries(object) {
     return Object.entries(object);
 }
-function isSourceType(str) {
-    return str === "blocks" /* SourceType.blocks */ || str === "extensions" /* SourceType.extensions */ || str === "plain" /* SourceType.plain */;
-}
 function determineCurrentSourceType(dest, srcIsDirectory) {
     if (typeof dest === 'string') {
         return srcIsDirectory ? "blocks" /* SourceType.blocks */ : "plain" /* SourceType.plain */;
@@ -96,6 +109,35 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
+function applyStandards(config) {
+    switch (config.standard) {
+        case '2026-03-13':
+            return {
+                ...resolveStandard('2026-03-13'),
+                ...config
+            };
+        case undefined:
+            return config;
+        default:
+            throw `Invalid standard: ${config.standard}`;
+    }
+}
+function resolveStandard(standard) {
+    switch (standard) {
+        case "2026-03-13":
+            return {
+                useWebpackResourceFiltering: true,
+                extensionsVersion: 3,
+                plainEntrypointsVersion: 2,
+                srcDir: "src",
+                outputDir: "dist",
+                useUnifiedLoader: true,
+                onlyRunPostCSSOnPCSS: true,
+            };
+        default:
+            return undefined;
+    }
+}
 function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
     const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
     return emittableHandle.replaceAll("{basename}", generatedHandle);

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

@@ -0,0 +1,10 @@
+import type { AdvancedOutputConfig, 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][];
+export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig, projectRoot?: string): Record<'staticEntrypoints' | 'dynamicEntrypoints', Entrypoints>;
+export {};

package/build/utils/entrypoint-resolution-logic.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSourceType = isSourceType;
+exports.resolveAllConfigLevelEntrypoints = resolveAllConfigLevelEntrypoints;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const location_encoding_filename_parser_1 = require("./location-encoding-filename-parser");
+const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
+function isSourceType(str) {
+    return str === "blocks" /* SourceType.blocks */ || str === "extensions" /* SourceType.extensions */ || str === "plain" /* SourceType.plain */;
+}
+function resolveAllConfigLevelEntrypoints(config, projectRoot = process.cwd()) {
+    const srcDir = config.srcDir ?? "";
+    const normalizeSrcAndDestination = ([rawSrc, dest]) => {
+        let [src, pathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(rawSrc);
+        if (srcDir) {
+            src = (0, node_path_1.join)(srcDir, src);
+        }
+        src = (0, node_path_1.isAbsolute)(src) ? (0, node_path_1.relative)(projectRoot, src) : src;
+        let resultObject;
+        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
+            resultObject = { ...dest, destination: (0, node_path_1.relative)(projectRoot, dest.destination) };
+        }
+        else {
+            resultObject = { ...dest };
+        }
+        return [src, pathQueryParameters ? { ...resultObject, pathQueryParameters } : resultObject];
+    };
+    if (Array.isArray(config.src)) {
+        return {
+            staticEntrypoints: config.src.map(s => normalizeSrcAndDestination([s, { destination: s }])),
+            dynamicEntrypoints: []
+        };
+    }
+    else {
+        const configSrc = config.src ?? {};
+        // We check for files with location-encoding filenames and add the pertinent ones to the sources
+        const dynamicallyIncludedEntrypoints = [];
+        if (srcDir) { // This will only work if we have a unified src root
+            const dynamicallyIncludedEntrypointsRoot = (0, node_path_1.isAbsolute)(srcDir) ? srcDir : (0, node_path_1.join)(projectRoot, srcDir);
+            using dir = (0, node_fs_1.opendirSync)(dynamicallyIncludedEntrypointsRoot);
+            for (let dirent; (dirent = dir.readSync()) !== null;) {
+                if (dirent.name in configSrc || `./${dirent.name}` in configSrc) {
+                    continue;
+                }
+                if (dirent.isDirectory()) {
+                    // If it's a directory that does not have an existing config entry, but does correspond to one of the non-plain SourceTypes, assume that it matches that source type
+                    if (isSourceType(dirent.name) && dirent.name !== "plain" /* SourceType.plain */) {
+                        dynamicallyIncludedEntrypoints.push([dirent.name, { directoryLayout: dirent.name }]);
+                        continue;
+                    }
+                    using nestedDir = (0, node_fs_1.opendirSync)((0, node_path_1.join)(dynamicallyIncludedEntrypointsRoot, dirent.name));
+                    for (let nestedDirent; (nestedDirent = nestedDir.readSync()) !== null;) {
+                        if (!nestedDirent.isFile()) {
+                            continue;
+                        }
+                        const cfgName = (0, node_path_1.join)(dirent.name, nestedDirent.name);
+                        if (cfgName in configSrc || `./${cfgName}` in configSrc) {
+                            continue;
+                        }
+                        const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(cfgName);
+                        if (parsedFilename === undefined) {
+                            continue;
+                        }
+                        dynamicallyIncludedEntrypoints.push([cfgName, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
+                    }
+                }
+                else if (dirent.isFile()) {
+                    const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
+                    if (parsedFilename === undefined) {
+                        continue;
+                    }
+                    dynamicallyIncludedEntrypoints.push([dirent.name, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
+                }
+            }
+        }
+        return {
+            staticEntrypoints: Object.entries(configSrc).map(([k, v]) => {
+                return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
+            }),
+            dynamicEntrypoints: dynamicallyIncludedEntrypoints.map(normalizeSrcAndDestination)
+        };
+    }
+}

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

@@ -6,9 +6,10 @@ export type ParsedLocationEncodingFilename = {
         register?: boolean | number;
     };
     flags: NormalizedEnqueuingControlFlags;
+    niceName?: string;
 };
 export declare function parseLocationEncodingFilename(filename: string): ParsedLocationEncodingFilename | undefined;
-export declare function parseLocationEncodingFilenameForBlock(filename: string): Omit<ParsedLocationEncodingFilename, 'locations'> & {
+export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): Omit<ParsedLocationEncodingFilename, 'locations'> & {
     locations: Pick<RealUsageLocations, 'clientEditor' | 'clientView'>;
 } | undefined;
 /**

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

@@ -19,13 +19,14 @@ function parseLocationEncodingFilename(filename) {
     const nameSegments = name.split("."); //Split always returns at least one string
     const typeOverrideMatch = /^(?<enqueuePosition>.+)-(?<typeOverride>script|style|script-module)$|^(?<typeOverride>script|style|script-module)$/.exec(nameSegments[0]);
     if (typeOverrideMatch) {
-        nameSegments[0] = typeOverrideMatch.groups?.["enqueuePosition"] ?? "both"; // We override the first segment with the version without
+        nameSegments[0] = typeOverrideMatch.groups?.["enqueuePosition"] ?? "both"; // We override the first segment with the version without the type override
         type = typeOverrideMatch.groups?.["typeOverride"];
     }
     const inlinePattern = /^(?<inline>inline)(?:[-=](?<position>before|after))?$|^strategy[-=](?<inline>inline)(?:-(?<position>before|after))?$/;
     const strategyPattern = /^strategy[-=](?<strategy>eager|lazy|defer|async)$|^(?<strategy>lazy|eager)$/;
     const fetchpriorityPattern = /^fetchpriority[-=](auto|low|high)$/;
     const bothViewAndEditorLocationPattern = /^(?:client-)?(?<both>both)(?:[-=](?<priority>-?\d+))?$/;
+    let niceName = undefined;
     for (const segment of nameSegments) {
         const { locationName, priority } = extractLocationFromPropertyEncodingFilenameSegment(segment);
         if (locationName) {
@@ -67,6 +68,9 @@ function parseLocationEncodingFilename(filename) {
                 flags.in_footer = false;
                 break;
             default:
+                if (niceName === undefined) {
+                    niceName = segment;
+                }
                 break;
         }
     }
@@ -74,16 +78,16 @@ function parseLocationEncodingFilename(filename) {
     if (Object.values(locations).length === 0) {
         return undefined;
     }
-    return { type, locations, flags };
+    return { type, locations, flags, niceName };
 }
-function parseLocationEncodingFilenameForBlock(filename) {
+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')) {
-            throw (0, shared_1.newWebpackErrorForFile)(`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).join(", ")}`, filename);
         }
         if (Object.values(parsedFilename.locations).some(value => typeof value === 'number')) {
-            throw (0, shared_1.newWebpackErrorForFile)(`Block assets cannot be enqueued with a priority`, filename);
+            throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);
         }
     }
     return parsedFilename;

package/build/wordpress-scripts-wrapper.js

@@ -6,8 +6,8 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const shared_1 = require("./shared");
+const entrypoint_resolution_logic_1 = require("./utils/entrypoint-resolution-logic");
 const common_config_helpers_1 = require("./utils/common-config-helpers");
-const location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
 const path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
 const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
@@ -27,6 +27,7 @@ const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
 const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
+const location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
 function testForDuplicatedEntryPaths(sources) {
     const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
         ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
@@ -165,7 +166,7 @@ function injectSupportForInliningSVGsAsStrings(rules) {
     });
 }
 function buildVerifiedConfig(config) {
-    config = applyStandards(config);
+    config = (0, shared_1.applyStandards)(config);
     const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false } = config;
     let outputDir = config.outputDir ?? "";
     if (outputDir && useUnifiedLoader && !omitDistDev && (process.env['SERVER_MODE'] ?? 'development') === 'development') {
@@ -191,68 +192,8 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
-    const normalizeSrcAndDestination = ([rawSrc, dest]) => {
-        let [src, pathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(rawSrc);
-        if (srcDir) {
-            src = (0, node_path_1.join)(srcDir, src);
-        }
-        src = (0, node_path_1.isAbsolute)(src) ? (0, node_path_1.relative)(process.cwd(), src) : src;
-        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
-            return [src, { ...dest, destination: (0, node_path_1.relative)(process.cwd(), dest.destination), pathQueryParameters }];
-        }
-        return [src, { ...dest, pathQueryParameters }];
-    };
-    let rawSources;
-    if (Array.isArray(config.src)) {
-        rawSources = config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]));
-    }
-    else {
-        const configSrc = config.src ?? {};
-        // We check for files with location-encoding filenames and add the pertinent ones to the sources
-        const dynamicallyIncludedEntrypoints = [];
-        if (srcDir) { // This will only work if we have a unified src root
-            const dynamicallyIncludedEntrypointsRoot = (0, node_path_1.isAbsolute)(srcDir) ? srcDir : (0, node_path_1.join)(process.cwd(), srcDir);
-            using dir = (0, node_fs_1.opendirSync)(dynamicallyIncludedEntrypointsRoot);
-            for (let dirent; (dirent = dir.readSync()) !== null;) {
-                if (dirent.name in configSrc || `./${dirent.name}` in configSrc) {
-                    continue;
-                }
-                if (dirent.isDirectory()) {
-                    // If it's a directory that does not have an existing config entry, but does correspond to one of the non-plain SourceTypes, assume that it matches that source type
-                    if ((0, shared_1.isSourceType)(dirent.name) && dirent.name !== "plain" /* SourceType.plain */) {
-                        dynamicallyIncludedEntrypoints.push([dirent.name, { directoryLayout: dirent.name }]);
-                        continue;
-                    }
-                    using nestedDir = (0, node_fs_1.opendirSync)((0, node_path_1.join)(dynamicallyIncludedEntrypointsRoot, dirent.name));
-                    for (let nestedDirent; (nestedDirent = nestedDir.readSync()) !== null;) {
-                        if (!nestedDirent.isFile()) {
-                            continue;
-                        }
-                        const cfgName = (0, node_path_1.join)(dirent.name, nestedDirent.name);
-                        if (cfgName in configSrc || `./${cfgName}` in configSrc) {
-                            continue;
-                        }
-                        const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(cfgName);
-                        if (parsedFilename === undefined) {
-                            continue;
-                        }
-                        dynamicallyIncludedEntrypoints.push([cfgName, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                    }
-                }
-                else if (dirent.isFile()) {
-                    const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-                    if (parsedFilename === undefined) {
-                        continue;
-                    }
-                    dynamicallyIncludedEntrypoints.push([dirent.name, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                }
-            }
-        }
-        rawSources = [...Object.entries(configSrc), ...dynamicallyIncludedEntrypoints]
-            .map(([k, v]) => {
-            return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
-        });
-    }
+    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
+    const rawSources = [...staticEntrypoints, ...dynamicEntrypoints];
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
@@ -302,25 +243,6 @@ function buildVerifiedConfig(config) {
     testForDuplicatedEntryPaths(sources);
     return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
 }
-function applyStandards(config) {
-    switch (config.standard) {
-        case '2026-03-13':
-            return {
-                useWebpackResourceFiltering: true,
-                extensionsVersion: 3,
-                plainEntrypointsVersion: 2,
-                srcDir: "src",
-                outputDir: "dist",
-                useUnifiedLoader: true,
-                onlyRunPostCSSOnPCSS: true,
-                ...config
-            };
-        case undefined:
-            return config;
-        default:
-            throw `Invalid standard: ${config.standard}`;
-    }
-}
 function toEffectiveWebpackDestination(destination) {
     const pathParts = (0, node_path_1.parse)(destination);
     return (0, node_path_1.join)(pathParts.dir, pathParts.name);
@@ -585,12 +507,22 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 const entry = async () => {
                     const rawEntrypoints = [];
                     for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-                        if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                            if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
+                        if (dirent.name.startsWith("~")) {
+                            continue;
+                        }
+                        if (dirent.isFile()) {
+                            if ((commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name))) {
                                 const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), { import: [absoluteSrc], plauditMetadata: { dest, absoluteSrc } }]);
+                                const extensionId = (0, node_path_1.parse)(dirent.name).name;
+                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), {
+                                        import: [absoluteSrc],
+                                        plauditMetadata: { dest, absoluteSrc, extensionId }
+                                    }]);
                             }
                         }
+                        else if (dirent.isDirectory()) {
+                            rawEntrypoints.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, [dirent.name]));
+                        }
                     }
                     return Object.fromEntries(rawEntrypoints);
                 };
@@ -631,7 +563,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
             if (canCopyFiles) {
                 plugins.push(new copy_webpack_plugin_1.default({
                     patterns: [{
-                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)',
+                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)', //TODO: I'm pretty sure that the dots need proper escaping
                             to: dest.destination,
                             context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
                         }]
@@ -642,6 +574,45 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
         return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2);
     }).filter(cfg => cfg !== undefined);
 }
+async function walkExtensionsTree(srcRoot, dest, parents) {
+    const res = [];
+    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
+        if (dirent.name.startsWith("~")) {
+            continue;
+        }
+        if (dirent.isFile()) {
+            const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
+            if (parsedFilename === undefined) {
+                continue;
+            }
+            const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
+            let destFile;
+            if (Object.keys(parsedFilename.locations).length === 1) {
+                if (parsedFilename.locations.clientView) {
+                    destFile = `view-${parsedFilename.type}`;
+                }
+                else if (parsedFilename.locations.clientEditor) {
+                    destFile = `editor-${parsedFilename.type}`;
+                }
+                else {
+                    destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
+                }
+            }
+            else {
+                destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
+            }
+            const extensionId = parents.join("-") + "-" + destFile;
+            res.push([(0, node_path_1.join)(dest.destination, ...parents, destFile), {
+                    import: [absoluteSrc],
+                    plauditMetadata: { dest, absoluteSrc, extensionId }
+                }]);
+        }
+        else if (dirent.isDirectory()) {
+            res.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, [...parents, dirent.name]));
+        }
+    }
+    return res;
+}
 function stripExtension(filepath) {
     return (0, node_path_1.join)((0, node_path_1.dirname)(filepath), (0, node_path_1.basename)(filepath, (0, node_path_1.extname)(filepath)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.86.0",
+  "version": "2.87.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build",
@@ -11,6 +11,7 @@
   ],
   "exports": {
     "./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js",
+    "./location-encoding-filename-parser": "./build/utils/location-encoding-filename-parser.js",
     "./shared": "./build/shared.js"
   },
   "typesVersions": {
@@ -18,6 +19,9 @@
       "wordpress-scripts-wrapper": [
         "build/wordpress-scripts-wrapper.d.ts"
       ],
+      "location-encoding-filename-parser": [
+        "build/location-encoding-filename-parser.d.ts"
+      ],
       "shared": [
         "build/shared.d.ts"
       ]