@plaudit/webpack-extensions 2.62.0 → 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 type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPlugin implements WebpackPluginInstance {
+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,102 +41,70 @@ 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
-                        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;
@@ -193,26 +158,21 @@ class ExtensionsConfigFileGeneratorPlugin {
             .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, true)));
     }
-    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)));
-        };
-    }
     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,18 +1,18 @@
 import { UsageLocations } from "../shared";
-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;
+    protected attachSecondPhase(compilation: Compilation): void;
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -8,40 +8,27 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const webpack_1 = require("webpack");
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-class PlainEntrypointsConfigFileGeneratorPlugin {
+const webpack_1 = require("webpack");
+class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     buildRoot;
     outputDir;
     usageLocations;
     handlePrefix;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    static phaseTwoAttached = false;
-    id;
     constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader) {
+        super("plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
         this.usageLocations = usageLocations;
         this.handlePrefix = handlePrefix;
         this.useUnifiedLoader = useUnifiedLoader;
-        this.id = Math.random().toString();
-        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
     }
     apply(compiler) {
+        super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = false;
-            PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reset(this.id);
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached) {
-                    PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = true;
-                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-                        this.afterProcessAssets(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
-                    });
-                }
-            });
             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;
@@ -101,10 +88,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                             handlePrefix: this.handlePrefix
                         });
                     }
-                    compilation.deleteAsset("assets.json");
                     PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
                     UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
-                        ? { group: 'plain-entrypoints-v2', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
+                        ? { group: this.libraryType, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
                         : undefined);
                 }
                 catch (e) {
@@ -113,9 +99,12 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                     throw e;
                 }
             });
+            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                compilation.deleteAsset("assets.json");
+            });
         });
     }
-    afterProcessAssets(compilation, assets) {
+    generatePlainEntrypointsLoader(compilation, assets) {
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
         const handleLists = {
             register: [],
@@ -175,11 +164,12 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             if (!this.useUnifiedLoader) {
                 (0, shared_1.emitResolveBaseUriFunction)(writer);
             }
+            const baseUriVar = new php_writer_1.Var("base_uri");
             for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.register)) {
                 writer.action("init", writer => {
-                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Expr.__DIR__], { assignTo: "$base_uri" });
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar });
                     for (const { handle, type, data } of prioritizedHandleList) {
-                        writer.call(`wp_register_${type}`, [handle, new php_writer_1.Expr(`$base_uri.${php_writer_1.Expr.jsonToPHPConverter(node_path_1.default.relative(emitDir, data.src))}`), ...data.rest]);
+                        writer.call(`wp_register_${type}`, [handle, php_writer_1.Op.join(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
                     }
                 }, { priority, accountForAlreadyDoing: true });
             }
@@ -248,5 +238,10 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
         }
         return lists.entries().toArray().sort((a, b) => a[0] - b[0]);
     }
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            this.generatePlainEntrypointsLoader(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
+        });
+    }
 }
 exports.PlainEntrypointsConfigFileGeneratorPlugin = PlainEntrypointsConfigFileGeneratorPlugin;

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts

@@ -1,14 +1,12 @@
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
+import { Compilation, type Compiler } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export declare class PlainEntrypointsStyleBlockJSONPlugin implements WebpackPluginInstance {
+export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly config;
     private readonly blocksDest;
     private readonly webpackRemoveEmptyScriptsPlugin;
     private static readonly semaphore;
-    private static readonly phaseTwoAttached;
-    private readonly id;
-    private readonly libraryType;
     constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin);
     apply(compiler: Compiler): void;
     private emitBlockLoaderFile;
@@ -23,4 +21,5 @@ export declare class PlainEntrypointsStyleBlockJSONPlugin implements WebpackPlug
     static findRelativeRouteBetween(path1: string, path2: string): string;
     private static remapReferencedPHPFilesOnKey;
     private static normalizeRenderTemplate;
+    protected attachSecondPhase(compilation: Compilation): void;
 }