@plaudit/webpack-extensions 2.58.0 → 2.58.2

package/build/plugins/BlockJSONManagingPlugin.js

@@ -321,13 +321,16 @@ class BlockJSONManagingPlugin {
     registerBlockJsonProcessor(compilation) {
         const blockDirConfigData = {};
         compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, ['block.json', writer => {
+            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, {
+                group: 'block.json',
+                action: writer => {
                     writer
                         .use("Plaudit\\Common\\ACF\\BlockManager")
                         .action("init", writer => {
                         writer.call("BlockManager::autoloadSubfolders", [new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + this.blocksDest)}`)]);
                     });
-                }]);
+                }
+            });
         });
         compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_GenerateMetadata`, compilationAssets => {
             const currentBlockJSONAssets = BlockJSONManagingPlugin.blockJSONAssetSourceDirs.entries()

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,14 +1,15 @@
+import { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class ExtensionsConfigFileGeneratorPlugin implements WebpackPluginInstance {
+    private readonly config;
     private readonly extensionsPath;
-    private readonly version;
     private readonly extensionsDest;
-    private readonly handlePrefix;
     private static readonly semaphore;
-    private static cache;
+    private static phaseTwoAttached;
     private readonly id;
-    constructor(extensionsPath: string, version: 1 | 2, extensionsDest: string, handlePrefix: string);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsPath: string, extensionsDest: string);
     apply(compiler: Compiler): void;
+    private generateVersionTwoConfigFile;
     private makeVersionOneAfterProcessAssets;
     private stripExtensionsDest;
 }

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -6,25 +6,23 @@ 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 UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
 const php_serializer_1 = require("../utils/php-serializer");
+const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-const php_writer_1 = require("../utils/php-writer");
 class ExtensionsConfigFileGeneratorPlugin {
+    config;
     extensionsPath;
-    version;
     extensionsDest;
-    handlePrefix;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ assets: [], setupFiles: [] }, "Extensions");
-    static cache = undefined;
+    static phaseTwoAttached = false;
     id;
-    constructor(extensionsPath, version, extensionsDest, handlePrefix) {
+    constructor(config, extensionsPath, extensionsDest) {
+        this.config = config;
         this.extensionsPath = extensionsPath;
-        this.version = version;
         this.extensionsDest = extensionsDest;
-        this.handlePrefix = handlePrefix;
         this.id = Math.random().toString();
         ExtensionsConfigFileGeneratorPlugin.semaphore.register(this.id);
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
@@ -46,86 +44,60 @@ class ExtensionsConfigFileGeneratorPlugin {
             }
             await Promise.all(emissionPromises);
         });
-        if (this.version === 2) {
-            const tapName = { name: `${this.constructor.name}_ProcessBlockJSONFiles`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
+        if (this.config.extensionsVersion === 2) {
             compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-                ExtensionsConfigFileGeneratorPlugin.cache = undefined;
+                ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached = false;
                 ExtensionsConfigFileGeneratorPlugin.semaphore.reset(this.id);
                 UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-                compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, ['extensions-config-v2', writer => {
-                            let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
-                            if (!finalExtensionsDest.startsWith("/")) {
-                                finalExtensionsDest = "/" + finalExtensionsDest;
+                compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                    if (!ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached) {
+                        ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached = true;
+                        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_GenerateConfigFile`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+                            const combinedExtensionData = (await ExtensionsConfigFileGeneratorPlugin.semaphore.wait())
+                                .reduce((main, { assets, setupFiles }) => {
+                                main.assets.push(...assets);
+                                main.setupFiles.push(...setupFiles);
+                                return main;
+                            }, { assets: [], setupFiles: [] });
+                            if (combinedExtensionData.assets.length > 0 || combinedExtensionData.setupFiles.length > 0) {
+                                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, {
+                                    group: 'extensions-config-v2',
+                                    action: writer => {
+                                        let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
+                                        if (!finalExtensionsDest.startsWith("/")) {
+                                            finalExtensionsDest = "/" + finalExtensionsDest;
+                                        }
+                                        writer
+                                            .use("Plaudit\\Base\\API\\ThemeUtils")
+                                            .withScope(writer => writer
+                                            .assign("$filePathPrefix", new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
+                                            .call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr("$filePathPrefix")], { assignTo: "$fileUriPrefix" })
+                                            .call("ThemeUtils::loadExtensionsV2", [
+                                            new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
+                                            new php_writer_1.Expr(`$filePathPrefix`), new php_writer_1.Expr("$fileUriPrefix"),
+                                            `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
+                                        ]));
+                                    }
+                                });
+                                this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
                             }
-                            writer
-                                .use("Plaudit\\Base\\API\\ThemeUtils")
-                                .assign("$filePathPrefix", new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                                .call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr("$filePathPrefix")], { assignTo: "$fileUriPrefix" })
-                                .call("ThemeUtils::loadExtensionsV2", [
-                                new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                                new php_writer_1.Expr(`$filePathPrefix`), new php_writer_1.Expr("$fileUriPrefix"),
-                                `${this.handlePrefix ? this.handlePrefix : node_path_1.default.basename(process.cwd())}_extension_`
-                            ])
-                                .call("unset", [new php_writer_1.Expr("$filePathPrefix"), new php_writer_1.Expr("$fileUriPrefix")]);
-                        }]);
+                            else {
+                                if (!this.config.useUnifiedLoader) {
+                                    this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
+                                }
+                                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, undefined);
+                            }
+                        });
+                    }
                 });
-                compilation.hooks.processAssets.tapPromise(tapName, async (assets) => {
+                compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
+                    if (!("assets.json" in assets)) {
+                        return;
+                    }
                     try {
-                        //TODO: Add handling of extracted CSS from JS
                         //TODO: It should be possible to use EntryPoints to determine the "original" file
-                        //TODO: Use the version hash of the original file, but not its dependencies for the additional file's "rest" parameter (see BlockJSONManagingPlugin.ts for how to do so)
                         //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
                         //TODO: BlockJSONManagingPlugin should be rewritten from scratch to use this method instead of its 15 layers of tracking + syncing
-                        if (ExtensionsConfigFileGeneratorPlugin.cache === undefined) {
-                            ExtensionsConfigFileGeneratorPlugin.cache = { assets: [], setupFiles: [] };
-                            compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_GenerateConfigFile`, () => {
-                                const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
-                                const blockExtensionsConfig = { metadata: { version: this.version }, scriptHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {} };
-                                for (const assetDataSource of ExtensionsConfigFileGeneratorPlugin.cache?.assets ?? []) {
-                                    const normalizedAssetData = Object.entries(assetDataSource)
-                                        .map(entry => {
-                                        const assetPath = this.extensionsDest && entry[0].startsWith(this.extensionsDest + "/")
-                                            ? entry[0].substring(this.extensionsDest.length + 1) : entry[0];
-                                        return [assetPath, entry[1]];
-                                    });
-                                    for (const [assetPath, assetData] of normalizedAssetData) {
-                                        const match = regex.exec(assetPath);
-                                        if (!match) {
-                                            continue;
-                                        }
-                                        const blockSlug = match[1], assetType = match[2];
-                                        if (blockSlug && assetType) {
-                                            const key = assetType.replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
-                                            const handle = `plaudit_block-extension_${blockSlug}-${assetType}`;
-                                            const isCss = assetType.endsWith("tyle");
-                                            blockExtensionsConfig[isCss ? 'styleHandles' : 'scriptHandles'][handle] = {
-                                                src: isCss ? assetPath.replace(/\.js$/, ".css") : assetPath,
-                                                rest: isCss || key.startsWith("editor")
-                                                    ? [assetData.dependencies, assetData.version]
-                                                    : [assetData.dependencies, assetData.version, { strategy: 'defer' }]
-                                            };
-                                            (blockExtensionsConfig.blocks[blockSlug] ?? (blockExtensionsConfig.blocks[blockSlug] = {}))[key] = handle;
-                                        }
-                                    }
-                                    for (const [blockSlug, asset] of ExtensionsConfigFileGeneratorPlugin.cache?.setupFiles ?? []) {
-                                        blockExtensionsConfig.setupFiles[blockSlug] = asset;
-                                    }
-                                }
-                                blockExtensionsConfig.scriptHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptHandles)
-                                    .toSorted(([a], [b]) => a.localeCompare(b)));
-                                blockExtensionsConfig.styleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.styleHandles)
-                                    .toSorted(([a], [b]) => a.localeCompare(b)));
-                                blockExtensionsConfig.setupFiles = Object.fromEntries(Object.entries(blockExtensionsConfig.setupFiles)
-                                    .toSorted(([a], [b]) => a.localeCompare(b)));
-                                blockExtensionsConfig.blocks = Object.fromEntries(Object.entries(blockExtensionsConfig.blocks)
-                                    .map(block => {
-                                    return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
-                                })
-                                    .toSorted(([a], [b]) => a.localeCompare(b)));
-                                compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig)));
-                            });
-                        }
                         const myCacheData = { assets: [], setupFiles: [] };
                         for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
                             const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
@@ -148,12 +120,6 @@ class ExtensionsConfigFileGeneratorPlugin {
                         myCacheData.assets.push(assetDataSource);
                         compilation.deleteAsset("assets.json");
                         ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
-                        ExtensionsConfigFileGeneratorPlugin.cache = (await ExtensionsConfigFileGeneratorPlugin.semaphore.wait())
-                            .reduce((main, { assets, setupFiles }) => {
-                            main.assets.push(...assets);
-                            main.setupFiles.push(...setupFiles);
-                            return main;
-                        }, { assets: [], setupFiles: [] });
                     }
                     catch (e) {
                         ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
@@ -170,16 +136,62 @@ class ExtensionsConfigFileGeneratorPlugin {
             compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
                 UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
                 compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, ['extensions-config-v1', writer => {
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, { group: 'extensions-config-v1', action: writer => {
                             writer
                                 .use("Plaudit\\Base\\API\\ThemeUtils")
                                 .call("ThemeUtils::installExtensionSupport", [new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(this.extensionsDest)}`)]);
-                        }]);
+                        } });
                 });
                 compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_AfterProcessAssets`, this.makeVersionOneAfterProcessAssets(compilation));
             });
         }
     }
+    generateVersionTwoConfigFile(compilation, combinedExtensionData) {
+        const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+        const blockExtensionsConfig = { metadata: { version: this.config.extensionsVersion }, scriptHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {} };
+        for (const assetDataSource of combinedExtensionData.assets) {
+            const normalizedAssetData = Object.entries(assetDataSource)
+                .map(entry => {
+                const assetPath = this.extensionsDest && entry[0].startsWith(this.extensionsDest + "/")
+                    ? entry[0].substring(this.extensionsDest.length + 1) : entry[0];
+                return [assetPath, entry[1]];
+            });
+            for (const [assetPath, assetData] of normalizedAssetData) {
+                const match = regex.exec(assetPath);
+                if (!match) {
+                    continue;
+                }
+                const blockSlug = match[1], assetType = match[2];
+                if (blockSlug && assetType) {
+                    const key = assetType.replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
+                    const handle = `plaudit_block-extension_${blockSlug}-${assetType}`;
+                    const isCss = assetType.endsWith("tyle");
+                    blockExtensionsConfig[isCss ? 'styleHandles' : 'scriptHandles'][handle] = {
+                        src: isCss ? assetPath.replace(/\.js$/, ".css") : assetPath,
+                        rest: isCss || key.startsWith("editor")
+                            ? [assetData.dependencies, assetData.version]
+                            : [assetData.dependencies, assetData.version, { strategy: 'defer' }]
+                    };
+                    (blockExtensionsConfig.blocks[blockSlug] ?? (blockExtensionsConfig.blocks[blockSlug] = {}))[key] = handle;
+                }
+            }
+            for (const [blockSlug, asset] of combinedExtensionData.setupFiles) {
+                blockExtensionsConfig.setupFiles[blockSlug] = asset;
+            }
+        }
+        blockExtensionsConfig.scriptHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b)));
+        blockExtensionsConfig.styleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.styleHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b)));
+        blockExtensionsConfig.setupFiles = Object.fromEntries(Object.entries(blockExtensionsConfig.setupFiles)
+            .toSorted(([a], [b]) => a.localeCompare(b)));
+        blockExtensionsConfig.blocks = Object.fromEntries(Object.entries(blockExtensionsConfig.blocks)
+            .map(block => {
+            return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
+        })
+            .toSorted(([a], [b]) => a.localeCompare(b)));
+        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig)));
+    }
     makeVersionOneAfterProcessAssets(compilation) {
         return compilationAssets => {
             const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -8,7 +8,7 @@ export declare class PlainEntrypointsConfigFileGeneratorPlugin implements Webpac
     private readonly handlePrefix;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    private static cache?;
+    private static phaseTwoAttached;
     private readonly id;
     constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean);
     apply(compiler: Compiler): void;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -17,7 +17,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
     handlePrefix;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    static cache = undefined;
+    static phaseTwoAttached = false;
     id;
     constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader) {
         this.buildRoot = buildRoot;
@@ -30,24 +30,23 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
     }
     apply(compiler) {
-        const tapName = { name: `${this.constructor.name}_ProcessPlainEntrypointFiles`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            PlainEntrypointsConfigFileGeneratorPlugin.cache = undefined;
+            PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = false;
             PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reset(this.id);
             UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, ['plain-entrypoints-v2', writer => {
-                        writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';");
-                    }]);
+            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                if (!PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached) {
+                    PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = true;
+                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+                        this.afterProcessAssets(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
+                    });
+                }
             });
-            compilation.hooks.processAssets.tapPromise(tapName, async (assets) => {
+            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
+                if (!("assets.json" in assets)) {
+                    return;
+                }
                 try {
-                    if (PlainEntrypointsConfigFileGeneratorPlugin.cache === undefined) {
-                        PlainEntrypointsConfigFileGeneratorPlugin.cache = { assets: [] };
-                        compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_CompileLoader`, () => {
-                            this.afterProcessAssets(compilation);
-                        });
-                    }
                     const rawAssetDataSource = assets["assets.json"]?.source();
                     if (typeof rawAssetDataSource !== 'string') {
                         PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
@@ -104,7 +103,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                     }
                     compilation.deleteAsset("assets.json");
                     PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
-                    PlainEntrypointsConfigFileGeneratorPlugin.cache.assets = (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat();
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
+                        ? { group: 'plain-entrypoints-v2', action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
+                        : undefined);
                 }
                 catch (e) {
                     PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
@@ -114,9 +115,8 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             });
         });
     }
-    afterProcessAssets(compilation) {
+    afterProcessAssets(compilation, assets) {
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
-        //TODO: Add support for editorStyles via the 'block_editor_settings_all' filter
         const handleLists = {
             register: [],
             clientView: [],
@@ -126,7 +126,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             customizer: [],
             analytics: []
         };
-        const allNamedHandles = (PlainEntrypointsConfigFileGeneratorPlugin.cache?.assets ?? [])
+        const allNamedHandles = assets
             .flatMap(({ handles }) => handles)
             .filter((handle) => !!handle.handleName)
             .sort((a, b) => a.src.localeCompare(b.src));
@@ -137,7 +137,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             .filter(handle => !handle.isScript)
             .map(handle => [handle.handleName, handle.src]));
         const plainEntrypointsConfig = { scriptHandles: {}, styleHandles: {} };
-        for (const { handles, handlePrefix } of PlainEntrypointsConfigFileGeneratorPlugin.cache?.assets ?? []) {
+        for (const { handles, handlePrefix } of assets) {
             for (const { src, rest, locations, isScript, handleName } of handles) {
                 let finalHandleName;
                 if (handleName) {

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -29,12 +29,13 @@ class SpecialAssetHandlingPlugin {
             SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = false;
             SpecialAssetHandlingPlugin.semaphore.reset(this.id);
             UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, ['special-assets', writer => {
-                        writer.append("require_once __DIR__.'/special-assets.php';");
-                    }]);
+            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                if (!SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch) {
+                    SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = true;
+                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
+                }
             });
-            compilation.hooks.processAssets.tapPromise(this.constructor.name, async (assets) => {
+            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE }, async (assets) => {
                 try {
                     const specialAssetData = {};
                     for (const pathname of Object.keys(assets)) {
@@ -63,12 +64,9 @@ class SpecialAssetHandlingPlugin {
                         }
                     }
                     SpecialAssetHandlingPlugin.semaphore.resolve(this.id, specialAssetData);
-                    if (!SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch) {
-                        SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = true;
-                        const collatedSpecialAssetData = (await SpecialAssetHandlingPlugin.semaphore.wait())
-                            .reduce((collector, current) => ({ ...collector, ...current }), {});
-                        this.collateAssets(compilation, collatedSpecialAssetData);
-                    }
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(specialAssetData).length > 0
+                        ? { group: 'special-assets', action: writer => writer.append("require_once __DIR__.'/special-assets.php';") }
+                        : undefined);
                 }
                 catch (e) {
                     SpecialAssetHandlingPlugin.semaphore.reject(this.id);
@@ -77,14 +75,18 @@ class SpecialAssetHandlingPlugin {
             });
         });
     }
-    collateAssets(compilation, collatedSpecialAssetData) {
+    async collateAssets(compilation) {
+        const collatedSpecialAssetData = (await SpecialAssetHandlingPlugin.semaphore.wait())
+            .reduce((collector, current) => ({ ...collector, ...current }), {});
         const preloadedAssets = Object.entries(collatedSpecialAssetData)
             .filter(([_, { preload }]) => preload)
             .sort(([a], [b]) => a.localeCompare(b));
         const outputFile = this.outputDir ? "special-assets.php" : node_path_1.default.join(node_path_1.default.dirname(node_path_1.default.dirname(SpecialAssetHandlingPlugin.validPathname)), "special-assets.php");
         const writer = new php_writer_1.PHPWriter();
         if (!preloadedAssets.length) {
-            writer.emitAsset(compilation, outputFile);
+            if (!this.useUnifiedLoader) {
+                writer.emitAsset(compilation, outputFile);
+            }
             return;
         }
         if (!this.useUnifiedLoader) {

package/build/plugins/UnifiedLoaderGenerator.d.ts

@@ -1,10 +1,16 @@
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { PHPWriter } from "../utils/php-writer";
 import { Compiler, WebpackPluginInstance } from "webpack";
+type LoaderInfo = {
+    group: string;
+    action(writer: PHPWriter): void;
+    priority?: number;
+};
 export declare class UnifiedLoaderGenerator implements WebpackPluginInstance {
-    static readonly semaphore: PseudoSemaphore<[string, (writer: PHPWriter) => void] | undefined>;
+    static readonly semaphore: PseudoSemaphore<LoaderInfo | undefined>;
     private static attached;
     private readonly id;
     constructor();
     apply(compiler: Compiler): void;
 }
+export {};

package/build/plugins/UnifiedLoaderGenerator.js

@@ -23,8 +23,15 @@ class UnifiedLoaderGenerator {
                     UnifiedLoaderGenerator.semaphore.resolve(this.id, undefined);
                     if (!UnifiedLoaderGenerator.attached) {
                         UnifiedLoaderGenerator.attached = true;
-                        const writerCallbacks = Object.values(Object.fromEntries((await UnifiedLoaderGenerator.semaphore.wait())
-                            .filter(a => a !== undefined))); // A simple deduplication trick
+                        const alreadyAllocatedGroups = new Set();
+                        const writerCallbacks = (await UnifiedLoaderGenerator.semaphore.wait())
+                            .filter((a) => a !== undefined)
+                            .sort((a, b) => {
+                            const ap = a.priority ?? 0, bp = b.priority ?? 0;
+                            return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
+                        })
+                            .filter(a => !alreadyAllocatedGroups.has(a.group) && alreadyAllocatedGroups.add(a.group))
+                            .map(a => a.action);
                         if (writerCallbacks.length > 0) {
                             compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
                                 const writer = new php_writer_1.PHPWriter();

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

@@ -115,6 +115,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             if (!dirent.isDirectory()) {
                 continue;
             }
+            //TODO: Instead of doing all of this in a precalc phase, add block.json "entrypoints" with their library type set to "block-json"
             const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
             loadingEntrypoints.push(new Promise(async (resolve) => {
                 const rawEntrypoints = [];

package/build/utils/php-writer.d.ts

@@ -24,11 +24,13 @@ export declare class PHPWriter {
     private printingInPHP;
     private fileNamespace;
     private useList;
+    private scopeStack;
     constructor(inlineFirstLine?: boolean);
     indent(): this;
     outdent(): this;
     append(...lines: (string | Expr)[]): this;
     assign(variable: string | string[], expression: unknown | Expr, opts?: {
+        chain?: boolean;
         return?: boolean;
     }): this;
     return(line: string | Expr): this;
@@ -39,7 +41,7 @@ export declare class PHPWriter {
     linebreak(): this;
     call(func: string, args: unknown[], opts?: {
         chain?: boolean;
-        assignTo?: string;
+        assignTo?: string | string[];
         return?: boolean;
     }): this;
     action(name: string | Expr, contents: (writer: this) => void, args?: ActionOrFilterArgs): this;
@@ -54,6 +56,24 @@ export declare class PHPWriter {
     openPHP(): this;
     namespace(namespace: string): this;
     use(...uses: string[]): this;
+    /**
+     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
+     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
+     */
+    openScope(): this;
+    /**
+     * Pops the top scope from the stack AND unsets all variables that were assigned within it
+     */
+    closeScope(): this;
+    /**
+     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
+     * This is used to allow function bodies to be safely created without disrupting their containing scope.
+     */
+    popScope(): this;
+    withScope(code: (writer: this) => void, opts?: {
+        actionDescription?: string;
+        usePopScopeInstead?: boolean;
+    }): this;
     toString(): string;
     emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 }

package/build/utils/php-writer.js

@@ -27,6 +27,7 @@ class PHPWriter {
     printingInPHP = true;
     fileNamespace = "";
     useList = [];
+    scopeStack = [];
     constructor(inlineFirstLine = false) {
         this.inlineFirstLine = inlineFirstLine;
     }
@@ -45,12 +46,24 @@ class PHPWriter {
         return this;
     }
     assign(variable, expression, opts = {}) {
-        const lineComponents = (typeof variable === 'string' ? [variable] : variable).map(v => `${v} =`);
+        let lineComponents;
+        if (typeof variable === 'string') {
+            if (this.scopeStack.length > 0) {
+                this.scopeStack[this.scopeStack.length - 1].push(variable);
+            }
+            lineComponents = [`${variable} =`];
+        }
+        else {
+            if (this.scopeStack.length > 0) {
+                this.scopeStack[this.scopeStack.length - 1].push(...variable);
+            }
+            lineComponents = variable.map(v => `${v} =`);
+        }
         if (opts.return) {
             lineComponents.splice(0, 0, "return");
         }
         lineComponents.push(Expr.convertJsonToPHP(expression));
-        return this.append(lineComponents.join(" ") + ';');
+        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
     }
     return(line) {
         return this.append(`return ${line};`);
@@ -72,15 +85,16 @@ class PHPWriter {
         return this;
     }
     call(func, args, opts = {}) {
+        const functionCall = `${func}(${args.map(Expr.convertJsonToPHP).join(", ")})`;
+        if (opts.assignTo) {
+            return this.assign(opts.assignTo, new Expr(functionCall), opts);
+        }
         const lineComponents = [];
         if (opts.return) {
             lineComponents.push("return");
         }
-        if (opts.assignTo) {
-            lineComponents.push(`${opts.assignTo} =`);
-        }
-        lineComponents.push(`${func}(${args.map(Expr.convertJsonToPHP).join(", ")})${opts.chain === true ? "" : ";"}`);
-        return this.append(lineComponents.join(" "));
+        lineComponents.push(functionCall);
+        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
     }
     action(name, contents, args = {}) {
         return this.actionOrFilter('action', name, contents, args);
@@ -98,7 +112,9 @@ class PHPWriter {
         declarationComponents.push("{");
         this.openPHP().append(`add_${type}(${declarationComponents.join(" ")}`);
         this.indent();
-        contents(this);
+        // We start a new scope here just in case this was called within an existing scope
+        // We pop the scope instead of closing it because we don't actually want to unset any variables that were created within the function
+        this.withScope(contents, { actionDescription: `closing the function call for the ${name} ${type}.`, usePopScopeInstead: true });
         this.openPHP().outdent();
         const actionOrFilterArgs = ["}"];
         const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
@@ -150,7 +166,9 @@ class PHPWriter {
         declarationComponents.push("{");
         this.append(declarationComponents.join(' '));
         this.indent();
-        body(this);
+        // We start a new scope here just in case this was called within an existing scope
+        // We pop the scope instead of closing it because we don't actually want to unset any variables that were created within the function
+        this.withScope(body, { actionDescription: `closing the "${name}" function`, usePopScopeInstead: true });
         this.openPHP().outdent().append("}");
         if (args.includeExistenceCheck) {
             return this.endIf();
@@ -183,7 +201,48 @@ class PHPWriter {
         }
         return this;
     }
+    /**
+     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
+     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
+     */
+    openScope() {
+        this.scopeStack.push([]);
+        return this;
+    }
+    /**
+     * Pops the top scope from the stack AND unsets all variables that were assigned within it
+     */
+    closeScope() {
+        const scope = this.scopeStack.pop();
+        return scope?.length ? this.call("unset", scope.map(v => new Expr(v))) : this;
+    }
+    /**
+     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
+     * This is used to allow function bodies to be safely created without disrupting their containing scope.
+     */
+    popScope() {
+        this.scopeStack.pop();
+        return this;
+    }
+    withScope(code, opts = {}) {
+        const expectedScopeCount = this.scopeStack.length;
+        this.openScope();
+        code(this);
+        if (opts.usePopScopeInstead) {
+            this.popScope();
+        }
+        else {
+            this.closeScope();
+        }
+        if (expectedScopeCount !== this.scopeStack.length) {
+            console.trace(`Encountered an unexpected number of scopes (saw: ${this.scopeStack.length}, expected: ${expectedScopeCount})`, `while ${opts.actionDescription ?? "ending an encapsulating scope"}.`);
+        }
+        return this;
+    }
     toString() {
+        if (this.scopeStack.length) {
+            console.trace("toString() was called on a PHPWriter that has a dangling scope");
+        }
         const fileContents = [];
         let canInline = true;
         if (this.fileNamespace) {

package/build/wordpress-scripts-wrapper.js

@@ -497,7 +497,7 @@ function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src,
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest), plugins);
 }
 function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
-    plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(srcRoot, config.extensionsVersion, dest.destination, config.plainEntrypointsHandlePrefix));
+    plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest.destination));
     const entry = async () => {
         const rawEntrypoints = [];
         for await (const dirent of await promises_1.default.opendir(srcRoot)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.58.0",
+  "version": "2.58.2",
   "license": "UNLICENSED",
   "files": [
     "/build"
@@ -18,7 +18,7 @@
   "devDependencies": {
     "@plaudit/gutenberg-api-extensions": "^2.75.0",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^22.17.1",
+    "@types/node": "^24.3.0",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.2.7",
     "@types/webpack": "^5.28.5",
@@ -63,7 +63,7 @@
     "postcss-url": "^10.1.3",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "webpack": "^5.101.1",
+    "webpack": "^5.101.2",
     "webpack-remove-empty-scripts": "^1.1.1",
     "xml-formatter": "^3.6.6"
   },