@plaudit/webpack-extensions 2.64.0 → 2.65.0

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.js

@@ -5,34 +5,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPluginV1 = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
+const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const php_serializer_1 = require("../utils/php-serializer");
 const php_writer_1 = require("../utils/php-writer");
 const webpack_1 = require("webpack");
-class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
+class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     extensionsDest;
     constructor(config, extensionsDest, context, entry) {
         super(config, `extensions-v1-${extensionsDest}`, [UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.extensionsDest = extensionsDest;
     }
-    apply(compiler) {
-        super.apply(compiler);
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, { group: `extensions-config-v1-${this.extensionsDest}`, requiresBaseURI: false, action: writer => {
-                        writer
-                            .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                            .call("GutenbergUtils::installExtensionsSupport", [php_writer_1.Op.join(php_writer_1.Constants.__DIR__, this.extensionsDest)]);
-                    } });
-            });
-        });
-    }
-    attachSecondPhase() { }
-    processAssets(compilation, rawAssetData) {
+    attachUniquePhase() { }
+    processAssets(compilation, assetsJson) {
         const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
         const mapping = {};
-        for (const fileWithAssetData of Object.keys(this.extractRelevantAssetData(compilation, rawAssetData))) {
+        for (const fileWithAssetData of Object.keys(this.extractRelevantAssetData(compilation, assetsJson))) {
             let match;
             if ((match = regex.exec(fileWithAssetData)) && match[1] && match[2]) {
                 const resourceInfo = (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[0];
@@ -41,6 +29,11 @@ class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryAnd
             }
         }
         compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
+        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, { group: `extensions-config-v1-${this.extensionsDest}`, requiresBaseURI: false, action: writer => {
+                writer
+                    .use("Plaudit\\Common\\Lib\\GutenbergUtils")
+                    .call("GutenbergUtils::installExtensionsSupport", [php_writer_1.Op.join(php_writer_1.Constants.__DIR__, this.extensionsDest)]);
+            } });
     }
 }
 exports.ExtensionsConfigFileGeneratorPluginV1 = ExtensionsConfigFileGeneratorPluginV1;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,19 +1,18 @@
-import { RawAssetData, UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
+import { ParsedAssetsJson, UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { Compilation } from "webpack";
-export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
+export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
     private readonly buildRoot;
     private readonly outputDir;
     private readonly usageLocations;
-    private readonly handlePrefix;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: UsageLocations, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
     private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;
     private static appendEnqueuingHandleLists;
     private static separateHandleListByPriority;
-    protected attachSecondPhase(compilation: Compilation): void;
-    protected processAssets(compilation: Compilation, rawAssetData: RawAssetData): void;
+    protected attachUniquePhase(compilation: Compilation): void;
+    protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -8,22 +8,20 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
+const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
+class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     buildRoot;
     outputDir;
     usageLocations;
-    handlePrefix;
     useUnifiedLoader;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    constructor(config, buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader, context, entry) {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Plain");
+    constructor(config, buildRoot, outputDir, usageLocations, useUnifiedLoader, context, entry) {
         super(config, "plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
         this.usageLocations = usageLocations;
-        this.handlePrefix = handlePrefix;
         this.useUnifiedLoader = useUnifiedLoader;
     }
     generatePlainEntrypointsLoader(compilation, assets) {
@@ -160,18 +158,19 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
         }
         return lists.entries().toArray().sort((a, b) => a[0] - b[0]);
     }
-    attachSecondPhase(compilation) {
-        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+    attachUniquePhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
             this.generatePlainEntrypointsLoader(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
         });
     }
-    processAssets(compilation, rawAssetData) {
+    processAssets(compilation, assetsJson) {
         const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
         const myAssetHandles = [];
-        for (const { entrypoint, srcPath } of this.getRelevantEntrypoints(compilation)) {
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        for (const { entrypoint, srcPath } of relevantEntrypoints) {
             const entrypointChunk = entrypoint.getEntrypointChunk();
             const assetData = entrypointChunk.files.values()
-                .map(file => rawAssetData[file]).find(v => v !== undefined);
+                .map(file => assetsJson[file]).find(v => v !== undefined);
             if (!assetData) {
                 continue;
             }
@@ -198,14 +197,14 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
                     handleName: useHandleName ? this.usageLocations.handle : undefined,
                 });
             }
-            myAssetHandles.push({
-                handles,
-                handlePrefix: this.handlePrefix
-            });
+            myAssetHandles.push({ handles, handlePrefix: this.config.plainEntrypointsHandlePrefix });
         }
         PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
-            ? { group: this.libraryType, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
+            ? {
+                group: this.group, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';"),
+                staticallyLoadedEntrypoints: Object.keys(relevantEntrypoints)
+            }
             : undefined);
     }
 }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts

@@ -1,14 +1,14 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { RawAssetData, UnpackedBlockEntrypointInfo } from "../shared";
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import { ParsedAssetsJson, UnpackedBlockEntrypointInfo } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
+export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
     private readonly blocksDest;
     private readonly webpackRemoveEmptyScriptsPlugin;
     private static readonly semaphore;
     constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
-    protected processAssets(compilation: Compilation, rawAssetData: RawAssetData): Promise<void>;
+    protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): Promise<void>;
     private emitBlockLoaderFile;
     private transformBlocks;
     private static extractAssetSource;
@@ -21,5 +21,5 @@ export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiP
     static findRelativeRouteBetween(path1: string, path2: string): string;
     private static remapReferencedPHPFilesOnKey;
     private static normalizeRenderTemplate;
-    protected attachSecondPhase(compilation: Compilation): void;
+    protected attachUniquePhase(compilation: Compilation): void;
 }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -7,17 +7,17 @@ exports.PlainEntrypointsStyleBlockJSONPlugin = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
+const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 const promises_1 = __importDefault(require("node:fs/promises"));
-class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
+class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     blocksDest;
     webpackRemoveEmptyScriptsPlugin;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ collatableWorkableBlockInfo: {}, blocksDest: "", emittingWpmlXml: false }, "Block JSON v3");
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Block JSON v3");
     constructor(config, blocksDest, webpackRemoveEmptyScriptsPlugin, context, entry) {
         super(config, `block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.blocksDest = blocksDest;
@@ -96,8 +96,9 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
             emittingWpmlXml: compilation.getAsset(node_path_1.default.join(this.blocksDest, "wpml-config.xml")) !== undefined
         });
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(applicableBlockJsonFiles).length ? {
-            group: this.libraryType,
+            group: this.group,
             requiresBaseURI: false,
+            staticallyLoadedEntrypoints: Object.keys(relevantEntrypoints),
             action: writer => writer.append(`require_once __DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + node_path_1.default.join(this.blocksDest, "blockdir-loader.php"))};`)
         } : undefined);
     }
@@ -136,7 +137,6 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
             const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
             PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
             PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
-            PlainEntrypointsStyleBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
             const hashForVersion = PlainEntrypointsStyleBlockJSONPlugin
                 .hashThingForAsset([blockJsonText, ...workableBlockEntrypointsInfo.map(bi => bi.hash)].join("~"));
             if (blockJson["version"]) {
@@ -145,6 +145,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
             else {
                 blockJson["version"] = hashForVersion;
             }
+            PlainEntrypointsStyleBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
             const blockDirName = node_path_1.default.dirname(node_path_1.default.relative(this.blocksDest, blockJsonAssetName));
             blockData[blockDirName] = PlainEntrypointsStyleBlockJSONPlugin
                 .doFileOrHandleReplacements(compilation, Object.fromEntries(Object.entries(blockJson).filter(([k]) => k !== '$schema')), workableBlockEntrypointsInfo, epi => epi.handle);
@@ -343,7 +344,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
             }
         }
     }
-    attachSecondPhase(compilation) {
+    attachUniquePhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
             const allSemaphoreData = (await PlainEntrypointsStyleBlockJSONPlugin.semaphore.wait())
                 .reduce((acc, cur) => {

package/build/plugins/SpecialAssetHandlingPlugin.d.ts

@@ -1,11 +1,11 @@
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
-import { Compilation, type Compiler } from "webpack";
-export declare class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin {
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
+import { Compilation } from "webpack";
+export declare class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin {
     private static readonly semaphore;
     private static validPathname?;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
-    apply(compiler: Compiler): void;
+    protected attachStandardPhase(compilation: Compilation): void;
     private collateAssets;
-    protected attachSecondPhase(compilation: Compilation): void;
+    protected attachUniquePhase(compilation: Compilation): void;
 }

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -8,59 +8,54 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");
+class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Special");
     static validPathname = undefined;
     constructor(config) {
         super(config, "special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
     }
-    apply(compiler) {
-        if (!this.config.useWebpackResourceFiltering) {
-            return;
-        }
-        super.apply(compiler);
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            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)) {
-                        if (!SpecialAssetHandlingPlugin.validPathname) {
-                            SpecialAssetHandlingPlugin.validPathname = pathname;
-                        }
-                        const assetInfo = compilation.assetsInfo.get(pathname);
-                        if (!assetInfo?.sourceFilename) {
-                            continue;
-                        }
-                        const filename = node_path_1.default.join(node_path_1.default.basename(node_path_1.default.dirname(pathname)), node_path_1.default.basename(pathname));
-                        const queryStart = assetInfo.sourceFilename.indexOf('?');
-                        if (queryStart < 0) {
-                            continue;
-                        }
-                        const params = new URLSearchParams(assetInfo.sourceFilename.substring(queryStart + 1)
-                            .replace(/(?:fetchPriority|crossOrigin)=/gi, str => str.toLowerCase()) //This ensures consistent capitalization of the fetchPriority parameter
-                        );
-                        if (params.has("preload")) {
-                            SpecialAssetHandlingPlugin.validPathname = pathname;
-                            specialAssetData[filename] = {
-                                preload: true,
-                                fetchpriority: params.get("fetchpriority"),
-                                crossorigin: params.get("crossorigin")
-                            };
-                        }
+    attachStandardPhase(compilation) {
+        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)) {
+                    if (!SpecialAssetHandlingPlugin.validPathname) {
+                        SpecialAssetHandlingPlugin.validPathname = pathname;
+                    }
+                    const assetInfo = compilation.assetsInfo.get(pathname);
+                    if (!assetInfo?.sourceFilename) {
+                        continue;
+                    }
+                    const filename = node_path_1.default.join(node_path_1.default.basename(node_path_1.default.dirname(pathname)), node_path_1.default.basename(pathname));
+                    const queryStart = assetInfo.sourceFilename.indexOf('?');
+                    if (queryStart < 0) {
+                        continue;
+                    }
+                    const params = new URLSearchParams(assetInfo.sourceFilename.substring(queryStart + 1)
+                        .replace(/(?:fetchPriority|crossOrigin)=/gi, str => str.toLowerCase()) //This ensures consistent capitalization of the fetchPriority parameter
+                    );
+                    if (params.has("preload")) {
+                        SpecialAssetHandlingPlugin.validPathname = pathname;
+                        specialAssetData[filename] = {
+                            preload: true,
+                            fetchpriority: params.get("fetchpriority"),
+                            crossorigin: params.get("crossorigin")
+                        };
                     }
-                    SpecialAssetHandlingPlugin.semaphore.resolve(this.id, specialAssetData);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(specialAssetData).length > 0
-                        ? { group: 'special-assets', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/special-assets.php';") }
-                        : undefined);
-                }
-                catch (e) {
-                    this.rejectSemaphores();
-                    throw e;
                 }
-            });
+                SpecialAssetHandlingPlugin.semaphore.resolve(this.id, specialAssetData);
+                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(specialAssetData).length > 0
+                    ? { group: 'special-assets', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/special-assets.php';") }
+                    : undefined);
+            }
+            catch (e) {
+                console.error(e);
+                this.rejectSemaphores();
+                throw e;
+            }
         });
     }
     async collateAssets(compilation) {
@@ -127,8 +122,10 @@ class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.Abstr
         });
         writer.emitAsset(compilation, outputFile);
     }
-    attachSecondPhase(compilation) {
-        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
+    attachUniquePhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            await this.collateAssets(compilation);
+        });
     }
 }
 exports.SpecialAssetHandlingPlugin = SpecialAssetHandlingPlugin;

package/build/plugins/UnifiedLoaderGenerator.d.ts

@@ -1,19 +1,19 @@
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { PHPWriter } from "../utils/php-writer";
-import { Compiler, WebpackPluginInstance } from "webpack";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import { Compilation } from "webpack";
 type LoaderInfo = {
     group: string;
     action(writer: PHPWriter): void;
     requiresBaseURI: boolean;
+    staticallyLoadedEntrypoints?: string[];
     priority?: number;
 };
-export declare class UnifiedLoaderGenerator implements WebpackPluginInstance {
-    private readonly config;
-    static readonly semaphore: PseudoSemaphore<LoaderInfo | undefined>;
-    private static attached;
-    private readonly id;
+export declare class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin {
+    static readonly semaphore: PseudoSemaphore<LoaderInfo>;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
-    apply(compiler: Compiler): void;
+    protected attachStandardPhase(compilation: Compilation): void;
+    protected attachUniquePhase(compilation: Compilation): void;
 }
 export {};

package/build/plugins/UnifiedLoaderGenerator.js

@@ -5,84 +5,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedLoaderGenerator = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const shared_1 = require("../shared");
-const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const json_to_php_but_with____injection_1 = __importDefault(require("../utils/json-to-php-but-with-__-injection"));
 const php_writer_1 = require("../utils/php-writer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-class UnifiedLoaderGenerator {
-    config;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore(undefined, "Unified");
-    static attached = false;
-    id;
+class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Unified");
     constructor(config) {
-        this.config = config;
-        this.id = Math.random().toString();
+        super(config, "unified-loader", []);
     }
-    apply(compiler) {
-        compiler.hooks.compilation.tap(`${this.constructor.name}_Cleanup`, compilation => {
-            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                if (!this.config.useUnifiedLoader) {
-                    const rawAssetDataSource = compilation.assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const rawAssetData = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(rawAssetData)) {
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    for (const [file, assetData] of Object.entries(rawAssetData)) {
-                        const escapedDependencies = assetData.dependencies.map(php_writer_1.Expr.convertJsonToPHP).join(", ");
-                        const contents = `<?php return ['dependencies' => [${escapedDependencies}], 'version' => ${php_writer_1.Expr.convertJsonToPHP(assetData.version)}];\n`;
-                        const parsedPath = node_path_1.default.parse(file);
-                        const assetPHPFile = node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php";
-                        compilation.emitAsset(assetPHPFile, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
-                    }
-                }
-                compilation.deleteAsset("assets.json");
-            });
+    attachStandardPhase(compilation) {
+        compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+            compilation.deleteAsset("assets.json");
         });
-        if (!this.config.useUnifiedLoader) {
-            return;
-        }
-        UnifiedLoaderGenerator.semaphore.register(this.id);
-        const tapName = { name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            UnifiedLoaderGenerator.attached = false;
-            UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.processAssets.tapPromise(tapName, async () => {
-                try {
-                    UnifiedLoaderGenerator.semaphore.resolve(this.id, undefined);
-                    if (!UnifiedLoaderGenerator.attached) {
-                        UnifiedLoaderGenerator.attached = true;
-                        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));
-                        if (writerCallbacks.length > 0) {
-                            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                                const writer = new php_writer_1.PHPWriter();
-                                if (writerCallbacks.some(wc => wc.requiresBaseURI)) {
-                                    (0, shared_1.emitResolveBaseUriFunction)(writer);
-                                }
-                                for (const writerCallback of writerCallbacks) {
-                                    writerCallback.action(writer);
-                                }
-                                writer.emitAsset(compilation, "unified-loader.php");
-                            });
-                        }
-                    }
+    }
+    attachUniquePhase(compilation) {
+        this.tapWithParsedAssetsJson(compilation, { stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async (parsedAssetsJson) => {
+            const groupedLoaderInfo = Object.values((await UnifiedLoaderGenerator.semaphore.wait())
+                .reduce((acc, cur) => {
+                const accValue = acc[cur.group];
+                if (accValue === undefined) {
+                    acc[cur.group] = { ...cur, priority: cur.priority ?? 0, staticallyLoadedEntrypoints: cur.staticallyLoadedEntrypoints?.length ? [...cur.staticallyLoadedEntrypoints] : [] };
+                    return acc;
+                }
+                if (cur.priority && accValue.priority < cur.priority) {
+                    accValue.priority = cur.priority;
+                    accValue.action = cur.action;
+                    accValue.requiresBaseURI = cur.requiresBaseURI;
+                }
+                else if (cur.requiresBaseURI && !accValue.requiresBaseURI) {
+                    accValue.requiresBaseURI = cur.requiresBaseURI;
                 }
-                catch (e) {
-                    UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    throw e;
+                if (cur.staticallyLoadedEntrypoints?.length) {
+                    accValue.staticallyLoadedEntrypoints.push(...cur.staticallyLoadedEntrypoints);
                 }
+                return acc;
+            }, {}))
+                .sort((a, b) => {
+                const ap = a.priority ?? 0, bp = b.priority ?? 0;
+                return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
             });
+            const staticallyLoadedEntrypoints = new Set(groupedLoaderInfo.flatMap(lig => lig.staticallyLoadedEntrypoints));
+            for (const [file, assetData] of Object.entries(parsedAssetsJson)) {
+                if (staticallyLoadedEntrypoints.has(file)) {
+                    continue;
+                }
+                const parsedPath = node_path_1.default.parse(file);
+                const contents = `<?php return ${(0, json_to_php_but_with____injection_1.default)(assetData)};\n`;
+                compilation.emitAsset(node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php", new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+            }
+            if (this.config.useUnifiedLoader) {
+                compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                    const writer = new php_writer_1.PHPWriter();
+                    if (groupedLoaderInfo.some(wc => wc.requiresBaseURI)) {
+                        (0, shared_1.emitResolveBaseUriFunction)(writer);
+                    }
+                    for (const { action } of groupedLoaderInfo) {
+                        action(writer);
+                    }
+                    writer.emitAsset(compilation, "unified-loader.php");
+                });
+            }
         });
     }
 }

package/build/plugins/WPMLConfigBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
+import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private readonly destDir;
@@ -7,7 +7,7 @@ export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private static domParser?;
     private static xmlSerializer?;
     private readonly parsedDocumentsCache;
-    constructor(destDir: string, referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>);
+    constructor(destDir: string, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
     private static getJSDOMInstance;
     private static getDOMParser;

package/build/shared.d.ts

@@ -1,11 +1,11 @@
 import { PHPWriter } from "./utils/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { type Configuration, type EntryOptions, WebpackError } from "webpack";
-export type RawAssetData = Record<string, {
+import { Compilation, type Configuration, type EntryOptions, WebpackError } from "webpack";
+export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
 }>;
-export declare function isRawAssetData(thing: any): thing is RawAssetData;
+export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
 type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
 export type HandleData = {
     src: string;
@@ -117,4 +117,5 @@ export declare function newWebpackErrorForFile(error: string | ConstructorParame
  * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times
  */
 export declare function emitResolveBaseUriFunction(writer: PHPWriter): void;
+export declare function getAssetsJson(compilation: Compilation): ParsedAssetsJson;
 export {};

package/build/shared.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNames = void 0;
-exports.isRawAssetData = isRawAssetData;
+exports.isParsedAssetsJson = isParsedAssetsJson;
 exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
 exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
@@ -23,11 +23,12 @@ exports.loadEnvFile = loadEnvFile;
 exports.parseEnvFile = parseEnvFile;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
+exports.getAssetsJson = getAssetsJson;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
 const php_writer_1 = require("./utils/php-writer");
 const webpack_1 = require("webpack");
-function isRawAssetData(thing) {
+function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
     }
@@ -110,7 +111,7 @@ function isScriptModuleField(field) {
     return field.includes("odule");
 }
 function hasAtLeastOneItem(list) {
-    return list.length > 0;
+    return list.length > 0 && list[0] !== undefined && list[0] !== null;
 }
 function arrayIsLength(arr, length) {
     return !!arr && arr.length === length;
@@ -160,3 +161,18 @@ function emitResolveBaseUriFunction(writer) {
             .call("trailingslashit", [php_writer_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
     }, { returnType: "string", includeExistenceCheck: true });
 }
+function getAssetsJson(compilation) {
+    const asset = compilation.getAsset("assets.json");
+    if (!asset) {
+        throw new Error("assets.json is unexpectedly missing");
+    }
+    if (isParsedAssetsJson(asset.info["parsed-assets-json"])) {
+        return asset.info["parsed-assets-json"];
+    }
+    const parsedAssetJson = JSON.parse(asset.source.source().toString('utf-8'));
+    if (!isParsedAssetsJson(parsedAssetJson)) {
+        throw new Error("assets.json is does not match the RawAssetData format");
+    }
+    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
+    return parsedAssetJson;
+}