@plaudit/webpack-extensions 2.63.2 → 2.65.0

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -0,0 +1,22 @@
+import { ParsedAssetsJson } from "../shared";
+import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
+import { Compilation, Compiler, Entrypoint } from "webpack";
+export type EntryProvider<M> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
+export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M> extends AbstractBiPhasicGroupPlugin {
+    private readonly context;
+    private readonly entry;
+    private static readonly configuredCompilations;
+    private readonly entryMetadataRecord;
+    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, group: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
+    apply(compiler: Compiler): void;
+    protected attachStandardPhase(compilation: Compilation): void;
+    getRelevantEntrypoints(compilation: Compilation): {
+        entrypoint: Entrypoint;
+        srcPath: string;
+        metadata: M;
+    }[];
+    protected abstract processAssets(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): Promise<void> | void;
+    protected extractRelevantAssetData(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): ParsedAssetsJson;
+}

package/build/plugins/{AbstractMultiPhaseLibraryAndEntryPlugin.js → AbstractBiPhasicGroupAndEntryPlugin.js}

@@ -1,22 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractMultiPhaseLibraryAndEntryPlugin = void 0;
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+exports.AbstractBiPhasicGroupAndEntryPlugin = void 0;
+const shared_1 = require("../shared");
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const webpack_1 = require("webpack");
-class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
     context;
     entry;
+    static configuredCompilations = new WeakSet();
     entryMetadataRecord = {};
-    constructor(libraryType, semaphores, context, entry) {
-        super(libraryType, semaphores);
+    constructor(config, group, semaphores, context, entry) {
+        super(config, group, semaphores);
         this.context = context;
         this.entry = entry;
     }
     apply(compiler) {
         super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
-            const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
-            compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
+            if (!AbstractBiPhasicGroupAndEntryPlugin.configuredCompilations.has(compilation)) {
+                AbstractBiPhasicGroupAndEntryPlugin.configuredCompilations.add(compilation);
+                const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
+                compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
+            }
         });
         compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
             const entry = await this.entry();
@@ -38,6 +43,11 @@ class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryP
             await Promise.all(promises);
         });
     }
+    attachStandardPhase(compilation) {
+        this.tapWithParsedAssetsJson(compilation, async (parsedAssetsJson) => {
+            await this.processAssets(compilation, parsedAssetsJson);
+        });
+    }
     getRelevantEntrypoints(compilation) {
         return compilation.entrypoints.values()
             .map(entrypoint => {
@@ -58,5 +68,18 @@ class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryP
             .filter(item => item !== undefined)
             .toArray();
     }
+    extractRelevantAssetData(compilation, parsedAssetsJson) {
+        const relevantAssetData = {};
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        for (const { entrypoint, srcPath } of relevantEntrypoints) {
+            const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => parsedAssetsJson[file]);
+            if (!fileWithAssetData) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                continue;
+            }
+            relevantAssetData[fileWithAssetData] = parsedAssetsJson[fileWithAssetData];
+        }
+        return relevantAssetData;
+    }
 }
-exports.AbstractMultiPhaseLibraryAndEntryPlugin = AbstractMultiPhaseLibraryAndEntryPlugin;
+exports.AbstractBiPhasicGroupAndEntryPlugin = AbstractBiPhasicGroupAndEntryPlugin;

package/build/plugins/AbstractBiPhasicGroupPlugin.d.ts

@@ -0,0 +1,33 @@
+import { Compilation, Compiler, type WebpackPluginInstance } from "webpack";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { ParsedAssetsJson } from "../shared";
+type TapWithAssetsJsonOptions = {
+    name?: string;
+    stage?: (typeof Compilation.PROCESS_ASSETS_STAGE_REPORT) | (typeof Compilation.PROCESS_ASSETS_STAGE_ANALYSE);
+    additionalAssets?: any;
+};
+type TapWithAssetsJsonFn = Parameters<Compilation['hooks']['processAssets']['tapPromise']>[1];
+type TapWithParsedAssetsJsonFn = (parsedAssetsJson: ParsedAssetsJson, assets: Parameters<TapWithAssetsJsonFn>[0]) => Promise<void> | void;
+export declare abstract class AbstractBiPhasicGroupPlugin implements WebpackPluginInstance {
+    protected readonly config: VerifiedPlauditWordpressWebpackConfig;
+    readonly group: string;
+    private readonly semaphores;
+    protected static readonly uniquePhaseAttached: {
+        [key in string]: any;
+    };
+    protected readonly id: string;
+    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, group: string, semaphores: PseudoSemaphore<any>[]);
+    apply(compiler: Compiler): void;
+    protected resetSemaphores(): void;
+    protected rejectSemaphores(): void;
+    protected abstract attachStandardPhase(compilation: Compilation): void;
+    protected abstract attachUniquePhase(compilation: Compilation): void;
+    protected tapRequiringAssetsJson(compilation: Compilation, fnOrOptions: TapWithAssetsJsonFn): void;
+    protected tapRequiringAssetsJson(compilation: Compilation, fnOrOptions: TapWithAssetsJsonOptions, fnIfOptions: TapWithAssetsJsonFn): void;
+    protected tapWithParsedAssetsJson(compilation: Compilation, fnOrOptions: TapWithParsedAssetsJsonFn): void;
+    protected tapWithParsedAssetsJson(compilation: Compilation, fnOrOptions: TapWithAssetsJsonOptions, fnIfOptions: TapWithParsedAssetsJsonFn): void;
+    private sharedTapLogicForAssetsJsonHelpers;
+    private extractTapAndFunction;
+}
+export {};

package/build/plugins/AbstractBiPhasicGroupPlugin.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBiPhasicGroupPlugin = void 0;
+const webpack_1 = require("webpack");
+const shared_1 = require("../shared");
+class AbstractBiPhasicGroupPlugin {
+    config;
+    group;
+    semaphores;
+    static uniquePhaseAttached = {};
+    id;
+    constructor(config, group, semaphores) {
+        this.config = config;
+        this.group = group;
+        this.semaphores = semaphores;
+        this.id = Math.random().toString();
+    }
+    apply(compiler) {
+        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.group);
+        for (const semaphore of this.semaphores) {
+            semaphore.register(this.id);
+        }
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            AbstractBiPhasicGroupPlugin.uniquePhaseAttached[this.group] = false;
+            this.resetSemaphores();
+            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                if (!AbstractBiPhasicGroupPlugin.uniquePhaseAttached[this.group]) {
+                    AbstractBiPhasicGroupPlugin.uniquePhaseAttached[this.group] = this;
+                    this.attachUniquePhase(compilation);
+                }
+            });
+            this.attachStandardPhase(compilation);
+        });
+    }
+    resetSemaphores() {
+        for (const semaphore of this.semaphores) {
+            semaphore.reset(this.id);
+        }
+    }
+    rejectSemaphores() {
+        for (const semaphore of this.semaphores) {
+            semaphore.reject(this.id);
+        }
+    }
+    tapRequiringAssetsJson(compilation, fnOrOptions, fnIfOptions) {
+        this.sharedTapLogicForAssetsJsonHelpers(compilation, this.extractTapAndFunction(fnOrOptions, fnIfOptions));
+    }
+    tapWithParsedAssetsJson(compilation, fnOrOptions, fnIfOptions) {
+        const { tap, earlyStage, fn } = this.extractTapAndFunction(fnOrOptions, fnIfOptions);
+        this.sharedTapLogicForAssetsJsonHelpers(compilation, { tap, earlyStage, fn: async (assets) => {
+                try {
+                    await fn((0, shared_1.getAssetsJson)(compilation), assets);
+                }
+                catch (e) {
+                    console.error(e);
+                    this.rejectSemaphores();
+                    if (e instanceof Error) {
+                        compilation.errors.push(e);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            } });
+    }
+    sharedTapLogicForAssetsJsonHelpers(compilation, { tap, earlyStage, fn }) {
+        compilation.hooks.processAssets.tapPromise({ ...tap, additionalAssets: true }, async (assets, ...args) => {
+            if (!earlyStage || "assets.json" in assets) {
+                await fn(assets, ...args);
+            }
+        });
+    }
+    extractTapAndFunction(fnOrOptions, fnIfOptions) {
+        let tap = { name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE };
+        let fn;
+        if (typeof fnOrOptions === 'function') {
+            fn = fnOrOptions;
+        }
+        else if (!fnIfOptions) {
+            throw new Error("Somehow reached an impossible state. Make sure that you're using TypeScript.");
+        }
+        else {
+            tap = { ...tap, ...fnOrOptions };
+            fn = fnIfOptions;
+        }
+        const earlyStage = tap.stage === webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE;
+        if (earlyStage && tap.additionalAssets === undefined) {
+            tap.additionalAssets = true;
+        }
+        return { tap, earlyStage, fn };
+    }
+}
+exports.AbstractBiPhasicGroupPlugin = AbstractBiPhasicGroupPlugin;

package/build/plugins/AdditionalDependencyInjectorPlugin.d.ts

@@ -1,8 +1,10 @@
 import { type Compiler, type WebpackPluginInstance } from "webpack";
+import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
 export declare class AdditionalDependencyInjectorPlugin implements WebpackPluginInstance {
     private readonly entrypointAdditionalDependencies;
     private readonly processingModules;
     private readonly addExternalizedDep;
-    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void);
+    private readonly referencePlugin;
+    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
 }

package/build/plugins/AdditionalDependencyInjectorPlugin.js

@@ -10,10 +10,12 @@ class AdditionalDependencyInjectorPlugin {
     entrypointAdditionalDependencies;
     processingModules;
     addExternalizedDep;
-    constructor(entrypointAdditionalDependencies, processingModules, addExternalizedDep) {
+    referencePlugin;
+    constructor(entrypointAdditionalDependencies, processingModules, addExternalizedDep, referencePlugin) {
         this.entrypointAdditionalDependencies = entrypointAdditionalDependencies;
         this.processingModules = processingModules;
         this.addExternalizedDep = addExternalizedDep;
+        this.referencePlugin = referencePlugin;
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
@@ -22,7 +24,7 @@ class AdditionalDependencyInjectorPlugin {
                 stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, () => {
                 const usableEntrypointTest = this.processingModules ? /\.m[jt]sx?$/i : /\.[jt]sx?$/i;
-                for (const entrypoint of compilation.entrypoints.values()) {
+                for (const { entrypoint } of this.referencePlugin.getRelevantEntrypoints(compilation)) {
                     const req = entrypoint.origins.filter(origin => usableEntrypointTest.test(origin.request))[0]?.request;
                     if (!req) {
                         continue;
@@ -43,7 +45,7 @@ class AdditionalDependencyInjectorPlugin {
                 name: `${this.constructor.name}_ProcessAssets_RemoveFakeModules`,
                 stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, () => {
-                for (const entrypoint of compilation.entrypoints.values()) {
+                for (const { entrypoint } of this.referencePlugin.getRelevantEntrypoints(compilation)) {
                     const entrypointChunk = entrypoint.getEntrypointChunk();
                     for (const module of compilation.chunkGraph.getChunkModules(entrypointChunk)) {
                         if (module instanceof webpack_1.ExternalModule && module.request === '__REMOVE_ME__') {

package/build/plugins/EnhancedDynamicEntryPlugin.d.ts

@@ -0,0 +1,8 @@
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import type { UnpackedBlockEntrypointInfo } from "../shared";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+export declare class EnhancedDynamicEntryPlugin extends AbstractBiPhasicGroupAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
+    protected attachUniquePhase(): void;
+    protected processAssets(): void;
+}

package/build/plugins/EnhancedDynamicEntryPlugin.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedDynamicEntryPlugin = void 0;
+const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
+class EnhancedDynamicEntryPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
+    constructor(config, context, entry) {
+        super(config, `enhanced-dynamic-entries`, [], context, entry);
+    }
+    attachUniquePhase() { }
+    processAssets() { }
+}
+exports.EnhancedDynamicEntryPlugin = EnhancedDynamicEntryPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,15 +1,16 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import { ParsedAssetsJson, VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
-    private readonly config;
-    private readonly extensionsPath;
+export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<string> {
+    private readonly extensionsSrcPath;
     private readonly dest;
     private static readonly semaphore;
-    private static readonly perLibraryTypeSetupFilePaths;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
+    private setupFiles;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsSrcPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider<string>);
+    get extensionsDestPath(): string;
     apply(compiler: Compiler): void;
     private generateVersionTwoConfigFile;
-    protected attachSecondPhase(compilation: Compilation): void;
+    protected attachUniquePhase(compilation: Compilation): void;
+    protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): void;
 }

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -6,34 +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 {
-    config;
-    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) {
-        super(`extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
-        this.config = config;
-        this.extensionsPath = extensionsPath;
+    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.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) });
@@ -42,134 +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]));
         });
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            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: It should be possible to use EntryPoints to determine the "original" file
-                    //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
-                    const myCacheData = { libraryType: this.libraryType, assets: [],
-                        setupFiles: ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] ?? [] };
-                    const rawAssetDataSource = assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const assetDataSource = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
-                        ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    const relevantAssetData = {};
-                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
-                    for (const { entrypoint, srcPath } of relevantEntrypoints) {
-                        const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => assetDataSource[file]);
-                        if (!fileWithAssetData) {
-                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
-                            continue;
-                        }
-                        relevantAssetData[fileWithAssetData] = assetDataSource[fileWithAssetData];
-                    }
-                    myCacheData.assets.push(relevantAssetData);
-                    compilation.deleteAsset("assets.json");
-                    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 {
-                                        //TODO: Generate a function
-                                        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"));
-                                }
-                            }
-                            writer.withScope(generateLoader);
-                        }
-                    } : undefined);
-                }
-                catch (e) {
-                    ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    if (e instanceof Error) {
-                        compilation.errors.push(e);
-                        return;
-                    }
-                    throw e;
-                }
-            });
-        });
     }
-    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)
@@ -185,18 +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 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;
+                }
+            }
+            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,8 +1,10 @@
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
-import { Compilation, type Compiler } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryPlugin {
+import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import type { ParsedAssetsJson } from "../shared";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { Compilation } from "webpack";
+export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin<string> {
     private readonly extensionsDest;
-    constructor(extensionsDest: string);
-    apply(compiler: Compiler): void;
-    protected attachSecondPhase(compilation: Compilation): void;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsDest: string, context: string, entry: EntryProvider<string>);
+    protected attachUniquePhase(): void;
+    protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
 }