@plaudit/webpack-extensions 2.61.2 → 2.62.1

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Compilation, Compiler, type WebpackPluginInstance } from "webpack";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+export declare abstract class AbstractMultiPhaseLibraryPlugin implements WebpackPluginInstance {
+    readonly libraryType: string;
+    private readonly semaphores;
+    protected static readonly phaseTwoAttached: {
+        [key in string]: any;
+    };
+    protected readonly id: string;
+    protected constructor(libraryType: string, semaphores: PseudoSemaphore<any>[]);
+    apply(compiler: Compiler): void;
+    protected resetSemaphores(): void;
+    protected abstract attachSecondPhase(compilation: Compilation): void;
+}

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMultiPhaseLibraryPlugin = void 0;
+const webpack_1 = require("webpack");
+class AbstractMultiPhaseLibraryPlugin {
+    libraryType;
+    semaphores;
+    static phaseTwoAttached = {};
+    id;
+    constructor(libraryType, semaphores) {
+        this.libraryType = libraryType;
+        this.semaphores = semaphores;
+        this.id = Math.random().toString();
+    }
+    apply(compiler) {
+        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.libraryType);
+        for (const semaphore of this.semaphores) {
+            semaphore.register(this.id);
+        }
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = false;
+            this.resetSemaphores();
+            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                if (!AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType]) {
+                    AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = this;
+                    this.attachSecondPhase(compilation);
+                }
+            });
+        });
+        // compiler.hooks.compilation.tap(
+        // 	this.constructor.name,
+        // 	(compilation, { normalModuleFactory }) => {
+        // 		const dummyEntry = EntryPlugin.createDependency("", "");
+        // 		compilation.dependencyFactories.set(
+        // 			dummyEntry.constructor as any,
+        // 			normalModuleFactory
+        // 		);
+        // 	}
+        // );
+        //
+        // compiler.hooks.make.tapPromise(this.constructor.name, (compilation) =>
+        // 	Promise.resolve(this.entry())
+        // 		.then((entry) => {
+        // 			const promises = [];
+        // 			for (const name of Object.keys(entry)) {
+        // 				const desc = entry[name];
+        // 				const options = EntryOptionPlugin.entryDescriptionToOptions(
+        // 					compiler,
+        // 					name,
+        // 					desc
+        // 				);
+        // 				for (const entry of /** @type {NonNullable<EntryDescriptionNormalized["import"]>} */ (
+        // 					desc.import
+        // 				)) {
+        // 					promises.push(
+        // 						new Promise(
+        // 							/**
+        // 							 * @param {(value?: undefined) => void} resolve resolve
+        // 							 * @param {(reason?: Error) => void} reject reject
+        // 							 */
+        // 							(resolve, reject) => {
+        // 								compilation.addEntry(
+        // 									this.context,
+        // 									EntryPlugin.createDependency(entry, options),
+        // 									options,
+        // 									(err) => {
+        // 										if (err) return reject(err);
+        // 										resolve();
+        // 									}
+        // 								);
+        // 							}
+        // 						)
+        // 					);
+        // 				}
+        // 			}
+        // 			return Promise.all(promises);
+        // 		})
+        // 		.then(() => {})
+        // );
+    }
+    // protected abstract generateEntries(compiler: Compiler, context: string, entry: EntryStaticNormalized): void;
+    resetSemaphores() {
+        for (const semaphore of this.semaphores) {
+            semaphore.reset(this.id);
+        }
+    }
+}
+exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -8,26 +8,23 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
-const php_serializer_1 = require("../utils/php-serializer");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-class ExtensionsConfigFileGeneratorPlugin {
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     extensionsPath;
     extensionsDest;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ assets: [], setupFiles: [] }, "Extensions");
-    static phaseTwoAttached = false;
-    id;
     constructor(config, extensionsPath, extensionsDest) {
+        super(`extensions-v2-${extensionsDest}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.config = config;
         this.extensionsPath = extensionsPath;
         this.extensionsDest = extensionsDest;
-        this.id = Math.random().toString();
-        ExtensionsConfigFileGeneratorPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
     }
     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);
@@ -44,107 +41,76 @@ class ExtensionsConfigFileGeneratorPlugin {
             }
             await Promise.all(emissionPromises);
         });
-        if (this.config.extensionsVersion === 2) {
-            compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-                ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached = false;
-                ExtensionsConfigFileGeneratorPlugin.semaphore.reset(this.id);
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-                compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                    if (!ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached) {
-                        ExtensionsConfigFileGeneratorPlugin.phaseTwoAttached = true;
-                        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_GenerateConfigFile`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-                            const combinedExtensionData = (await ExtensionsConfigFileGeneratorPlugin.semaphore.wait())
-                                .reduce((main, { assets, setupFiles }) => {
-                                main.assets.push(...assets);
-                                main.setupFiles.push(...setupFiles);
-                                return main;
-                            }, { assets: [], setupFiles: [] });
-                            if (combinedExtensionData.assets.length > 0 || combinedExtensionData.setupFiles.length > 0 || !this.config.useUnifiedLoader) {
-                                this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
-                            }
-                        });
+        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 = { assets: [], setupFiles: [] };
+                    for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
+                        const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
+                        if (blockSlug) {
+                            myCacheData.setupFiles.push([blockSlug, asset]);
+                        }
                     }
-                });
-                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)) {
+                    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;
                     }
-                    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
-                        //TODO: BlockJSONManagingPlugin should be rewritten from scratch to use this method instead of its 15 layers of tracking + syncing
-                        const myCacheData = { assets: [], setupFiles: [] };
-                        for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
-                            const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
-                            if (blockSlug) {
-                                myCacheData.setupFiles.push([blockSlug, asset]);
-                            }
-                        }
-                        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;
-                        }
-                        myCacheData.assets.push(assetDataSource);
-                        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: `extensions-config-v2-${this.extensionsDest}`,
-                            requiresBaseURI: true,
-                            action: writer => {
-                                let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
-                                if (!finalExtensionsDest.startsWith("/")) {
-                                    finalExtensionsDest = "/" + finalExtensionsDest;
-                                }
-                                writer
-                                    .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                                    .withScope(writer => writer
-                                    .assign("$filePathPrefix", new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                                    .call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr("$filePathPrefix")], { assignTo: "$fileUriPrefix" })
-                                    .call("GutenbergUtils::loadExtensionsV2", [
-                                    new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                                    new php_writer_1.Expr(`$filePathPrefix`), new php_writer_1.Expr("$fileUriPrefix"),
-                                    `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
-                                ]));
-                            }
-                        } : undefined);
-                    }
-                    catch (e) {
+                    const assetDataSource = JSON.parse(rawAssetDataSource);
+                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
                         ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                        if (e instanceof Error) {
-                            compilation.errors.push(e);
-                            return;
-                        }
-                        throw e;
+                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
+                        return;
                     }
-                });
-            });
-        }
-        else {
-            compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-                compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, { group: `extensions-config-v1-${this.extensionsDest}`, requiresBaseURI: false, action: writer => {
+                    myCacheData.assets.push(assetDataSource);
+                    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 => {
+                            let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
+                            if (!finalExtensionsDest.startsWith("/")) {
+                                finalExtensionsDest = "/" + finalExtensionsDest;
+                            }
+                            const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
+                            const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
                             writer
                                 .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                                .call("GutenbergUtils::installExtensionsSupport", [new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(this.extensionsDest)}`)]);
-                        } });
-                });
-                compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_AfterProcessAssets`, this.makeVersionOneAfterProcessAssets(compilation));
+                                .withScope(writer => 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_`
+                            ]));
+                        }
+                    } : 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) {
         const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
-        const blockExtensionsConfig = { metadata: { version: this.config.extensionsVersion }, scriptHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {} };
+        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 => {
@@ -161,8 +127,10 @@ class ExtensionsConfigFileGeneratorPlugin {
                 if (blockSlug && assetType) {
                     const key = assetType.replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
                     const handle = `plaudit_block-extension_${blockSlug}-${assetType}`;
-                    const isCss = assetType.endsWith("tyle");
-                    blockExtensionsConfig[isCss ? 'styleHandles' : 'scriptHandles'][handle] = {
+                    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]
@@ -177,6 +145,8 @@ class ExtensionsConfigFileGeneratorPlugin {
         }
         blockExtensionsConfig.scriptHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)));
+        blockExtensionsConfig.scriptModuleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptModuleHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b)));
         blockExtensionsConfig.styleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.styleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)));
         blockExtensionsConfig.setupFiles = Object.fromEntries(Object.entries(blockExtensionsConfig.setupFiles)
@@ -186,28 +156,23 @@ class ExtensionsConfigFileGeneratorPlugin {
             return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
         })
             .toSorted(([a], [b]) => a.localeCompare(b)));
-        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig)));
-    }
-    makeVersionOneAfterProcessAssets(compilation) {
-        return compilationAssets => {
-            const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
-            const mapping = {};
-            for (const asset of Object.keys(compilationAssets)) {
-                let match;
-                if ((match = /^(.+?)-setup.php$/i.exec(asset)) && match[1]) {
-                    (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[1] = `${asset}`;
-                }
-                else if ((match = regex.exec(asset)) && match[1] && match[2]) {
-                    const resourceInfo = (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[0];
-                    const key = match[2].replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
-                    (resourceInfo[key] ?? (resourceInfo[key] = [])).push([`plaudit_block-extension_${match[1]}-${match[2]}`, asset]);
-                }
-            }
-            compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
-        };
+        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
     }
     stripExtensionsDest(item) {
         return this.extensionsDest && item.startsWith(this.extensionsDest + "/") ? item.substring(this.extensionsDest.length + 1 /* we also need to drop the "/" */) : item;
     }
+    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: [] });
+            if (combinedExtensionData.assets.length > 0 || combinedExtensionData.setupFiles.length > 0 || !this.config.useUnifiedLoader) {
+                this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
+            }
+        });
+    }
 }
 exports.ExtensionsConfigFileGeneratorPlugin = ExtensionsConfigFileGeneratorPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { Compilation, type Compiler } from "webpack";
+export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryPlugin {
+    private readonly extensionsDest;
+    constructor(extensionsDest: string);
+    apply(compiler: Compiler): void;
+    protected attachSecondPhase(compilation: Compilation): void;
+}

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsConfigFileGeneratorPluginV1 = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+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 AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+    extensionsDest;
+    constructor(extensionsDest) {
+        super(`extensions-v1-${extensionsDest}`, [UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+        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)]);
+                    } });
+            });
+            compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_AfterProcessAssets`, compilationAssets => {
+                const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+                const mapping = {};
+                for (const asset of Object.keys(compilationAssets)) {
+                    let match;
+                    if ((match = /^(.+?)-setup.php$/i.exec(asset)) && match[1]) {
+                        (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[1] = `${asset}`;
+                    }
+                    else if ((match = regex.exec(asset)) && match[1] && match[2]) {
+                        const resourceInfo = (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[0];
+                        const key = match[2].replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
+                        (resourceInfo[key] ?? (resourceInfo[key] = [])).push([`plaudit_block-extension_${match[1]}-${match[2]}`, asset]);
+                    }
+                }
+                compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
+            });
+        });
+    }
+    attachSecondPhase(compilation) { }
+}
+exports.ExtensionsConfigFileGeneratorPluginV1 = ExtensionsConfigFileGeneratorPluginV1;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,23 +1,18 @@
 import { UsageLocations } from "../shared";
-import { PHPWriter } from "../utils/php-writer";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class PlainEntrypointsConfigFileGeneratorPlugin implements WebpackPluginInstance {
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { Compilation, type Compiler } from "webpack";
+export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly buildRoot;
     private readonly outputDir;
     private readonly usageLocations;
     private readonly handlePrefix;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    private static phaseTwoAttached;
-    private readonly id;
     constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean);
     apply(compiler: Compiler): void;
-    private afterProcessAssets;
+    private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;
     private static appendEnqueuingHandleLists;
     private static separateHandleListByPriority;
-    /**
-     * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times
-     */
-    static emitResolveBaseUriFunction(writer: PHPWriter): void;
+    protected attachSecondPhase(compilation: Compilation): void;
 }