@plaudit/webpack-extensions 2.63.2 → 2.64.0

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.d.ts

@@ -1,19 +1,21 @@
+import { RawAssetData } from "../shared";
+import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-import type { ExtensibleEntryObject } from "../utils/common-config-helpers";
 import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
 import { Compilation, Compiler, Entrypoint } from "webpack";
 export type EntryProvider<M> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
 export declare abstract class AbstractMultiPhaseLibraryAndEntryPlugin<M> extends AbstractMultiPhaseLibraryPlugin {
     private readonly context;
     private readonly entry;
-    protected readonly entryMetadataRecord: {
-        [entryName: string]: M;
-    };
-    protected constructor(libraryType: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
+    private static readonly configuredCompilations;
+    private readonly entryMetadataRecord;
+    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, libraryType: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
     apply(compiler: Compiler): void;
-    protected getRelevantEntrypoints(compilation: Compilation): {
+    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;
 }

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.js

@@ -1,20 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractMultiPhaseLibraryAndEntryPlugin = void 0;
+const shared_1 = require("../shared");
 const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 const webpack_1 = require("webpack");
 class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     context;
     entry;
+    static configuredCompilations = new WeakSet();
     entryMetadataRecord = {};
-    constructor(libraryType, semaphores, context, entry) {
-        super(libraryType, semaphores);
+    constructor(config, libraryType, semaphores, context, entry) {
+        super(config, libraryType, semaphores);
         this.context = context;
         this.entry = entry;
     }
     apply(compiler) {
         super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
+            if (AbstractMultiPhaseLibraryAndEntryPlugin.configuredCompilations.has(compilation)) {
+                return;
+            }
+            AbstractMultiPhaseLibraryAndEntryPlugin.configuredCompilations.add(compilation);
             const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
             compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
         });
@@ -37,6 +43,38 @@ class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryP
             }
             await Promise.all(promises);
         });
+        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 rawAssetDataSource = assets["assets.json"]?.source();
+                    if (typeof rawAssetDataSource !== 'string') {
+                        this.rejectSemaphores();
+                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
+                        return;
+                    }
+                    const rawAssetData = JSON.parse(rawAssetDataSource);
+                    if (!(0, shared_1.isRawAssetData)(rawAssetData)) {
+                        this.rejectSemaphores();
+                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
+                        return;
+                    }
+                    await this.processAssets(compilation, rawAssetData);
+                }
+                catch (e) {
+                    this.rejectSemaphores();
+                    if (e instanceof Error) {
+                        compilation.errors.push(e);
+                        return;
+                    }
+                    throw e;
+                }
+            });
+        });
     }
     getRelevantEntrypoints(compilation) {
         return compilation.entrypoints.values()
@@ -58,5 +96,18 @@ class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryP
             .filter(item => item !== undefined)
             .toArray();
     }
+    extractRelevantAssetData(compilation, rawAssetData) {
+        const relevantAssetData = {};
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        for (const { entrypoint, srcPath } of relevantEntrypoints) {
+            const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => rawAssetData[file]);
+            if (!fileWithAssetData) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                continue;
+            }
+            relevantAssetData[fileWithAssetData] = rawAssetData[fileWithAssetData];
+        }
+        return relevantAssetData;
+    }
 }
 exports.AbstractMultiPhaseLibraryAndEntryPlugin = AbstractMultiPhaseLibraryAndEntryPlugin;

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts

@@ -1,14 +1,17 @@
 import { Compilation, Compiler, type WebpackPluginInstance } from "webpack";
 import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 export declare abstract class AbstractMultiPhaseLibraryPlugin implements WebpackPluginInstance {
+    protected readonly config: VerifiedPlauditWordpressWebpackConfig;
     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>[]);
+    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, libraryType: string, semaphores: PseudoSemaphore<any>[]);
     apply(compiler: Compiler): void;
     protected resetSemaphores(): void;
+    protected rejectSemaphores(): void;
     protected abstract attachSecondPhase(compilation: Compilation): void;
 }

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractMultiPhaseLibraryPlugin = void 0;
 const webpack_1 = require("webpack");
 class AbstractMultiPhaseLibraryPlugin {
+    config;
     libraryType;
     semaphores;
     static phaseTwoAttached = {};
     id;
-    constructor(libraryType, semaphores) {
+    constructor(config, libraryType, semaphores) {
+        this.config = config;
         this.libraryType = libraryType;
         this.semaphores = semaphores;
         this.id = Math.random().toString();
@@ -33,5 +35,10 @@ class AbstractMultiPhaseLibraryPlugin {
             semaphore.reset(this.id);
         }
     }
+    rejectSemaphores() {
+        for (const semaphore of this.semaphores) {
+            semaphore.reject(this.id);
+        }
+    }
 }
 exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;

package/build/plugins/AdditionalDependencyInjectorPlugin.d.ts

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

package/build/plugins/AdditionalDependencyInjectorPlugin.js

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

package/build/plugins/EnhancedDynamicEntryPlugin.d.ts

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

package/build/plugins/EnhancedDynamicEntryPlugin.js

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -13,14 +13,12 @@ const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
-    config;
     extensionsPath;
     dest;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ libraryType: "", assets: [], setupFiles: [] }, "Extensions");
     static perLibraryTypeSetupFilePaths = {};
     constructor(config, extensionsPath, dest, context, entry) {
-        super(`extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
-        this.config = config;
+        super(config, `extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.extensionsPath = extensionsPath;
         this.dest = dest;
     }
@@ -45,93 +43,6 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEn
             ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] = (await Promise.all(emissionPromises))
                 .filter((item) => item[0] !== undefined).sort((a, b) => a[0].localeCompare(b[0]));
         });
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
-                if (!("assets.json" in assets)) {
-                    return;
-                }
-                try {
-                    //TODO: It should be possible to use EntryPoints to determine the "original" file
-                    //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
-                    const myCacheData = { libraryType: this.libraryType, assets: [],
-                        setupFiles: ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] ?? [] };
-                    const rawAssetDataSource = assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const assetDataSource = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
-                        ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    const relevantAssetData = {};
-                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
-                    for (const { entrypoint, srcPath } of relevantEntrypoints) {
-                        const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => assetDataSource[file]);
-                        if (!fileWithAssetData) {
-                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
-                            continue;
-                        }
-                        relevantAssetData[fileWithAssetData] = assetDataSource[fileWithAssetData];
-                    }
-                    myCacheData.assets.push(relevantAssetData);
-                    compilation.deleteAsset("assets.json");
-                    ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myCacheData.setupFiles.length > 0 || myCacheData.assets.length > 0 ? {
-                        group: this.libraryType,
-                        requiresBaseURI: true,
-                        action: writer => {
-                            const generateLoader = (writer) => {
-                                let finalExtensionsDest = this.dest.destination.endsWith("/") ? this.dest.destination : this.dest.destination + "/";
-                                if (!finalExtensionsDest.startsWith("/")) {
-                                    finalExtensionsDest = "/" + finalExtensionsDest;
-                                }
-                                const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
-                                const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
-                                writer
-                                    .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                                    .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
-                                    .call("GutenbergUtils::loadExtensionsV2", [
-                                    new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                                    filePathPrefixVar, fileUriPrefixVar,
-                                    `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
-                                ]);
-                            };
-                            writer.use("Plaudit\\Common\\Lib\\GutenbergUtils");
-                            const potentialHandle = this.dest.locations?.handle;
-                            if (potentialHandle) {
-                                if (typeof potentialHandle === 'string') {
-                                    try {
-                                        //TODO: Generate a function
-                                        writer.function(potentialHandle, [], generateLoader, { returnType: 'void' });
-                                        return;
-                                    }
-                                    catch (e) {
-                                        compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for dynamically loading extensions", { cause: e }], this.extensionsPath));
-                                    }
-                                }
-                                else {
-                                    compilation.errors.push(new Error("The extensions directoryLayout's handle support is limited to static strings"));
-                                }
-                            }
-                            writer.withScope(generateLoader);
-                        }
-                    } : undefined);
-                }
-                catch (e) {
-                    ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    if (e instanceof Error) {
-                        compilation.errors.push(e);
-                        return;
-                    }
-                    throw e;
-                }
-            });
-        });
     }
     generateVersionTwoConfigFile(compilation, combinedExtensionData) {
         const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
@@ -198,5 +109,50 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEn
             }
         });
     }
+    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"));
+                    }
+                }
+                writer.withScope(generateLoader);
+            }
+        } : undefined);
+    }
 }
 exports.ExtensionsConfigFileGeneratorPlugin = ExtensionsConfigFileGeneratorPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

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

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.js

@@ -5,15 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPluginV1 = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
 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 {
+class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
     extensionsDest;
-    constructor(extensionsDest) {
-        super(`extensions-v1-${extensionsDest}`, [UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    constructor(config, extensionsDest, context, entry) {
+        super(config, `extensions-v1-${extensionsDest}`, [UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.extensionsDest = extensionsDest;
     }
     apply(compiler) {
@@ -26,24 +26,21 @@ class ExtensionsConfigFileGeneratorPluginV1 extends AbstractMultiPhaseLibraryPlu
                             .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) { }
+    attachSecondPhase() { }
+    processAssets(compilation, rawAssetData) {
+        const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+        const mapping = {};
+        for (const fileWithAssetData of Object.keys(this.extractRelevantAssetData(compilation, rawAssetData))) {
+            let match;
+            if ((match = regex.exec(fileWithAssetData)) && 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]}`, fileWithAssetData]);
+            }
+        }
+        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
+    }
 }
 exports.ExtensionsConfigFileGeneratorPluginV1 = ExtensionsConfigFileGeneratorPluginV1;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,6 +1,7 @@
-import { UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
+import { RawAssetData, UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { Compilation, type Compiler } from "webpack";
+import { Compilation } from "webpack";
 export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
     private readonly buildRoot;
     private readonly outputDir;
@@ -8,11 +9,11 @@ export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractM
     private readonly handlePrefix;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
-    apply(compiler: Compiler): void;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
     private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;
     private static appendEnqueuingHandleLists;
     private static separateHandleListByPriority;
     protected attachSecondPhase(compilation: Compilation): void;
+    protected processAssets(compilation: Compilation, rawAssetData: RawAssetData): void;
 }