@plaudit/webpack-extensions 2.64.0 → 2.65.0

package/build/plugins/{AbstractMultiPhaseLibraryAndEntryPlugin.d.ts → AbstractBiPhasicGroupAndEntryPlugin.d.ts}

@@ -1,21 +1,22 @@
-import { RawAssetData } from "../shared";
+import { ParsedAssetsJson } from "../shared";
 import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
 import { Compilation, Compiler, Entrypoint } from "webpack";
 export type EntryProvider<M> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
-export declare abstract class AbstractMultiPhaseLibraryAndEntryPlugin<M> extends AbstractMultiPhaseLibraryPlugin {
+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, libraryType: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
+    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, rawAssetData: RawAssetData): Promise<void> | void;
-    protected extractRelevantAssetData(compilation: Compilation, rawAssetData: RawAssetData): RawAssetData;
+    protected abstract processAssets(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): Promise<void> | void;
+    protected extractRelevantAssetData(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): ParsedAssetsJson;
 }

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBiPhasicGroupAndEntryPlugin = void 0;
+const shared_1 = require("../shared");
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
+const webpack_1 = require("webpack");
+class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    context;
+    entry;
+    static configuredCompilations = new WeakSet();
+    entryMetadataRecord = {};
+    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 }) => {
+            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();
+            const promises = [];
+            for (const [name, { plauditMetadata, ...desc }] of Object.entries(entry)) {
+                const options = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, name, desc);
+                this.entryMetadataRecord[name] = plauditMetadata;
+                for (const entry of desc.import) {
+                    promises.push(new Promise((resolve, reject) => {
+                        compilation.addEntry(this.context, webpack_1.EntryPlugin.createDependency(entry, options), options, err => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve();
+                        });
+                    }));
+                }
+            }
+            await Promise.all(promises);
+        });
+    }
+    attachStandardPhase(compilation) {
+        this.tapWithParsedAssetsJson(compilation, async (parsedAssetsJson) => {
+            await this.processAssets(compilation, parsedAssetsJson);
+        });
+    }
+    getRelevantEntrypoints(compilation) {
+        return compilation.entrypoints.values()
+            .map(entrypoint => {
+            const name = entrypoint.name;
+            if (!name) {
+                return undefined;
+            }
+            const metadata = this.entryMetadataRecord[name];
+            if (metadata === undefined) {
+                return undefined;
+            }
+            const srcPath = entrypoint.origins[0]?.request;
+            if (!srcPath) {
+                return undefined;
+            }
+            return { entrypoint, srcPath, metadata };
+        })
+            .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.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,10 +1,10 @@
 import { type Compiler, type WebpackPluginInstance } from "webpack";
-import { AbstractMultiPhaseLibraryAndEntryPlugin } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
+import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
 export declare class AdditionalDependencyInjectorPlugin implements WebpackPluginInstance {
     private readonly entrypointAdditionalDependencies;
     private readonly processingModules;
     private readonly addExternalizedDep;
     private readonly referencePlugin;
-    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void, referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>);
+    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
 }

package/build/plugins/EnhancedDynamicEntryPlugin.d.ts

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

package/build/plugins/EnhancedDynamicEntryPlugin.js

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,15 +1,16 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { RawAssetData, 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<string> {
-    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<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 processAssets(compilation: Compilation, rawAssetData: RawAssetData): void;
+    protected attachUniquePhase(compilation: Compilation): void;
+    protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): void;
 }

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<string> {
     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;
+    protected attachUniquePhase(): void;
+    protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
 }