@plaudit/webpack-extensions 2.64.0 → 2.65.1

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -6,32 +6,36 @@ 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 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");
-class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
-    extensionsPath;
+class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
+    extensionsSrcPath;
     dest;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ libraryType: "", assets: [], setupFiles: [] }, "Extensions");
-    static perLibraryTypeSetupFilePaths = {};
-    constructor(config, extensionsPath, dest, context, entry) {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Extensions");
+    setupFiles = [];
+    constructor(config, extensionsSrcPath, dest, context, entry) {
         super(config, `extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
-        this.extensionsPath = extensionsPath;
+        this.extensionsSrcPath = extensionsSrcPath;
         this.dest = dest;
     }
+    get extensionsDestPath() {
+        let extensionsDestPath = this.dest.destination.endsWith("/") ? this.dest.destination : this.dest.destination + "/";
+        return !extensionsDestPath.startsWith("/") ? "/" + extensionsDestPath : extensionsDestPath;
+    }
     apply(compiler) {
         super.apply(compiler);
         compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
-            if (!compilation.contextDependencies.has(this.extensionsPath)) {
-                compilation.contextDependencies.add(this.extensionsPath);
+            if (!compilation.contextDependencies.has(this.extensionsSrcPath)) {
+                compilation.contextDependencies.add(this.extensionsSrcPath);
             }
             const emissionPromises = [];
-            for await (const { name: setupFilePath } of await promises_1.default.opendir(this.extensionsPath, { encoding: 'utf-8' })) {
+            for await (const { name: setupFilePath } of await promises_1.default.opendir(this.extensionsSrcPath, { encoding: 'utf-8' })) {
                 if (setupFilePath.endsWith("-setup.php")) {
-                    const setupFileSourcePath = node_path_1.default.join(this.extensionsPath, setupFilePath);
+                    const setupFileSourcePath = node_path_1.default.join(this.extensionsSrcPath, setupFilePath);
                     compilation.fileDependencies.add(setupFileSourcePath);
                     emissionPromises.push(promises_1.default.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) });
@@ -40,47 +44,45 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEn
                     }));
                 }
             }
-            ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] = (await Promise.all(emissionPromises))
+            this.setupFiles = (await Promise.all(emissionPromises))
                 .filter((item) => item[0] !== undefined).sort((a, b) => a[0].localeCompare(b[0]));
         });
     }
-    generateVersionTwoConfigFile(compilation, combinedExtensionData) {
+    generateVersionTwoConfigFile(compilation, relevantAssetData, setupFilePaths) {
         const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
         const blockExtensionsConfig = {
             metadata: { version: this.config.extensionsVersion }, scriptHandles: {}, scriptModuleHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {}
         };
-        for (const assetDataSource of combinedExtensionData.assets) {
-            const normalizedAssetData = Object.entries(assetDataSource)
-                .map(entry => {
-                const assetPath = this.dest.destination && entry[0].startsWith(this.dest.destination + "/")
-                    ? entry[0].substring(this.dest.destination.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 = (0, shared_1.isStyleField)(assetType);
-                    const handleGroup = isCss ? 'styleHandles'
-                        : ((0, shared_1.isScriptModuleField)(assetType) ? 'scriptModuleHandles' : 'scriptHandles');
-                    blockExtensionsConfig[handleGroup][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;
-                }
+        const normalizedAssetData = Object.entries(relevantAssetData)
+            .map(entry => {
+            const assetPath = this.dest.destination && entry[0].startsWith(this.dest.destination + "/")
+                ? entry[0].substring(this.dest.destination.length + 1) : entry[0];
+            return [assetPath, entry[1]];
+        });
+        for (const [assetPath, assetData] of normalizedAssetData) {
+            const match = regex.exec(assetPath);
+            if (!match) {
+                continue;
             }
-            for (const [blockSlug, asset] of combinedExtensionData.setupFiles) {
-                blockExtensionsConfig.setupFiles[blockSlug] = asset;
+            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 = (0, shared_1.isStyleField)(assetType);
+                const handleGroup = isCss ? 'styleHandles'
+                    : ((0, shared_1.isScriptModuleField)(assetType) ? 'scriptModuleHandles' : 'scriptHandles');
+                blockExtensionsConfig[handleGroup][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 setupFilePaths) {
+            blockExtensionsConfig.setupFiles[blockSlug] = asset;
+        }
         blockExtensionsConfig.scriptHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)));
         blockExtensionsConfig.scriptModuleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptModuleHandles)
@@ -96,63 +98,71 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEn
             .toSorted(([a], [b]) => a.localeCompare(b)));
         compilation.emitAsset(node_path_1.default.join(this.dest.destination, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
     }
-    attachSecondPhase(compilation) {
-        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: [], libraryType: "" });
-            if (combinedExtensionData.assets.length > 0 || combinedExtensionData.setupFiles.length > 0 || !this.config.useUnifiedLoader) {
-                this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
+    attachUniquePhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            const plugins = Object.values((await ExtensionsConfigFileGeneratorPlugin.semaphore.wait())
+                .reduce((acc, cur) => {
+                const accValue = acc[cur.plugin.group];
+                if (accValue === undefined) {
+                    acc[cur.plugin.group] = { ...cur, setupFiles: cur.setupFiles?.length ? [...cur.setupFiles] : [] };
+                    return acc;
+                }
+                if (cur.relevantAssetData) {
+                    accValue.relevantAssetData = { ...accValue.relevantAssetData, ...cur.relevantAssetData };
+                }
+                if (cur.setupFiles?.length) {
+                    accValue.setupFiles.push(...cur.setupFiles);
+                }
+                return acc;
+            }, {}))
+                .sort((a, b) => a.plugin.group.localeCompare(b.plugin.group));
+            for (const { plugin, relevantAssetData, setupFiles } of plugins) {
+                plugin.generateVersionTwoConfigFile(compilation, relevantAssetData, setupFiles);
             }
         });
     }
     processAssets(compilation, rawAssetData) {
-        const myCacheData = { libraryType: this.libraryType, assets: [],
-            setupFiles: ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] ?? [] };
-        myCacheData.assets.push(this.extractRelevantAssetData(compilation, rawAssetData));
-        ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myCacheData.setupFiles.length > 0 || myCacheData.assets.length > 0 ? {
-            group: this.libraryType,
-            requiresBaseURI: true,
-            action: writer => {
-                const generateLoader = (writer) => {
-                    let finalExtensionsDest = this.dest.destination.endsWith("/") ? this.dest.destination : this.dest.destination + "/";
-                    if (!finalExtensionsDest.startsWith("/")) {
-                        finalExtensionsDest = "/" + finalExtensionsDest;
-                    }
-                    const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
-                    const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
-                    writer
-                        .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                        .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
-                        .call("GutenbergUtils::loadExtensionsV2", [
-                        new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                        filePathPrefixVar, fileUriPrefixVar,
-                        `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
-                    ]);
-                };
-                writer.use("Plaudit\\Common\\Lib\\GutenbergUtils");
-                const potentialHandle = this.dest.locations?.handle;
-                if (potentialHandle) {
-                    if (typeof potentialHandle === 'string') {
-                        try {
-                            writer.function(potentialHandle, [], generateLoader, { returnType: 'void' });
-                            return;
-                        }
-                        catch (e) {
-                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for dynamically loading extensions", { cause: e }], this.extensionsPath));
-                        }
-                    }
-                    else {
-                        compilation.errors.push(new Error("The extensions directoryLayout's handle support is limited to static strings"));
-                    }
+        const relevantAssetData = this.extractRelevantAssetData(compilation, rawAssetData);
+        const staticallyLoadedEntrypoints = Object.keys(relevantAssetData);
+        const generateLoader = (writer) => {
+            const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
+            const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
+            writer
+                .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(this.extensionsDestPath)}`))
+                .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
+                .call("GutenbergUtils::loadExtensionsV2", [
+                new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(this.extensionsDestPath + "mapping.config.php")}`),
+                filePathPrefixVar, fileUriPrefixVar,
+                `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
+            ]);
+        };
+        let action;
+        const potentialHandle = this.dest.locations?.handle;
+        if (potentialHandle) {
+            if (typeof potentialHandle === 'string') {
+                try {
+                    action = writer => writer.use("Plaudit\\Common\\Lib\\GutenbergUtils").function(potentialHandle, [], generateLoader, { returnType: 'void' });
+                }
+                catch (e) {
+                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for dynamically loading extensions", { cause: e }], this.extensionsSrcPath));
+                    this.rejectSemaphores();
+                    return;
                 }
-                writer.withScope(generateLoader);
             }
-        } : undefined);
+            else {
+                compilation.errors.push(new Error("The extensions directoryLayout's handle support is limited to static strings"));
+                this.rejectSemaphores();
+                return;
+            }
+        }
+        else {
+            action = writer => writer.use("Plaudit\\Common\\Lib\\GutenbergUtils").withScope(generateLoader);
+        }
+        const myCacheData = { plugin: this, setupFiles: this.setupFiles, relevantAssetData };
+        ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
+        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, this.setupFiles.length > 0 || staticallyLoadedEntrypoints.length > 0
+            ? { group: this.group, requiresBaseURI: true, action, staticallyLoadedEntrypoints }
+            : undefined);
     }
 }
 exports.ExtensionsConfigFileGeneratorPlugin = ExtensionsConfigFileGeneratorPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

@@ -1,11 +1,10 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { RawAssetData } from "../shared";
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import type { ParsedAssetsJson } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { Compilation, type Compiler } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryAndEntryPlugin<string> {
+import { Compilation } from "webpack";
+export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin {
     private readonly extensionsDest;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsDest: string, context: string, entry: EntryProvider<string>);
-    apply(compiler: Compiler): void;
-    protected attachSecondPhase(): void;
-    protected processAssets(compilation: Compilation, rawAssetData: RawAssetData): void;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsDest: string, context: string, entry: EntryProvider);
+    protected attachUniquePhase(): void;
+    protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
 }

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, BlockEntrypointInfo, 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<BlockEntrypointInfo> {
     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<BlockEntrypointInfo>);
     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).toArray();
+        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: relevantEntrypoints.flatMap(re => re.entrypoint.getEntrypointChunk().files.values().toArray())
+            }
             : 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, BlockEntrypointInfo } 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<BlockEntrypointInfo> {
     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>;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<BlockEntrypointInfo>);
+    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;
@@ -26,9 +26,9 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
     async processAssets(compilation, rawAssetData) {
         const applicableBlockJsonFiles = {};
         const blockJsonOriginToOutputMapping = {};
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || metadata !== "block-json-inclusion-assurance") {
+            if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
                 continue;
             }
             const entrypointChunk = entrypoint.getEntrypointChunk();
@@ -54,7 +54,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndE
             }
         }
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || typeof metadata === 'string') {
+            if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || 'purpose' in metadata) {
                 continue;
             }
             const entrypointChunk = entrypoint.getEntrypointChunk();
@@ -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: relevantEntrypoints.flatMap(re => re.entrypoint.getEntrypointChunk().files.values().toArray()),
             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;
 }