@plaudit/webpack-extensions 2.64.0 → 2.65.1

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -0,0 +1,33 @@
+import { ParsedAssetsJson, VerifiedAdvancedOutputConfig } from "../shared";
+import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
+import { Compilation, Compiler, Entrypoint } from "webpack";
+export type EntryProvider<M extends {
+    dest: VerifiedAdvancedOutputConfig;
+} = {
+    dest: VerifiedAdvancedOutputConfig;
+}> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
+export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M extends {
+    dest: VerifiedAdvancedOutputConfig;
+} = {
+    dest: VerifiedAdvancedOutputConfig;
+}> extends AbstractBiPhasicGroupPlugin {
+    private readonly context;
+    private readonly entry;
+    private static readonly configuredCompilations;
+    private readonly entryMetadataRecord;
+    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, group: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
+    apply(compiler: Compiler): void;
+    protected attachStandardPhase(compilation: Compilation): void;
+    /**
+     * NOTE: This function returns an ITERATOR. Call .toArray() on it if you need to use the result multiple times
+     */
+    getRelevantEntrypoints(compilation: Compilation): IteratorObject<{
+        entrypoint: Entrypoint;
+        srcPath: string;
+        metadata: M;
+    }, undefined, unknown>;
+    protected abstract processAssets(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): Promise<void> | void;
+    protected extractRelevantAssetData(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): ParsedAssetsJson;
+}

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBiPhasicGroupAndEntryPlugin = void 0;
+const shared_1 = require("../shared");
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
+const webpack_1 = require("webpack");
+class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    context;
+    entry;
+    static configuredCompilations = new WeakSet();
+    entryMetadataRecord = {};
+    constructor(config, group, semaphores, context, entry) {
+        super(config, group, semaphores);
+        this.context = context;
+        this.entry = entry;
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        compiler.hooks.compilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
+            if (!AbstractBiPhasicGroupAndEntryPlugin.configuredCompilations.has(compilation)) {
+                AbstractBiPhasicGroupAndEntryPlugin.configuredCompilations.add(compilation);
+                const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
+                compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
+            }
+        });
+        compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
+            const entry = await this.entry();
+            const promises = [];
+            for (const [name, { plauditMetadata, ...desc }] of Object.entries(entry)) {
+                const options = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, name, desc);
+                this.entryMetadataRecord[name] = plauditMetadata;
+                for (const entry of desc.import) {
+                    promises.push(new Promise((resolve, reject) => {
+                        compilation.addEntry(this.context, webpack_1.EntryPlugin.createDependency(entry, options), options, err => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve();
+                        });
+                    }));
+                }
+            }
+            await Promise.all(promises);
+        });
+    }
+    attachStandardPhase(compilation) {
+        this.tapWithParsedAssetsJson(compilation, async (parsedAssetsJson) => {
+            await this.processAssets(compilation, parsedAssetsJson);
+        });
+    }
+    /**
+     * NOTE: This function returns an ITERATOR. Call .toArray() on it if you need to use the result multiple times
+     */
+    getRelevantEntrypoints(compilation) {
+        return compilation.entrypoints.values()
+            .map(entrypoint => {
+            const name = entrypoint.name;
+            if (!name) {
+                return undefined;
+            }
+            const metadata = this.entryMetadataRecord[name];
+            if (metadata === undefined) {
+                return undefined;
+            }
+            const srcPath = entrypoint.origins[0]?.request;
+            if (!srcPath) {
+                return undefined;
+            }
+            return { entrypoint, srcPath, metadata };
+        })
+            .filter(item => item !== undefined);
+    }
+    extractRelevantAssetData(compilation, parsedAssetsJson) {
+        const relevantAssetData = {};
+        for (const { entrypoint, srcPath } of this.getRelevantEntrypoints(compilation)) {
+            const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => parsedAssetsJson[file]);
+            if (!fileWithAssetData) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                continue;
+            }
+            relevantAssetData[fileWithAssetData] = parsedAssetsJson[fileWithAssetData];
+        }
+        return relevantAssetData;
+    }
+}
+exports.AbstractBiPhasicGroupAndEntryPlugin = AbstractBiPhasicGroupAndEntryPlugin;

package/build/plugins/AbstractBiPhasicGroupPlugin.d.ts

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

package/build/plugins/AbstractBiPhasicGroupPlugin.js

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

package/build/plugins/AdditionalDependencyInjectorPlugin.d.ts

@@ -1,10 +1,12 @@
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-import { AbstractMultiPhaseLibraryAndEntryPlugin } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-export declare class AdditionalDependencyInjectorPlugin implements WebpackPluginInstance {
-    private readonly entrypointAdditionalDependencies;
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
+import type { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
+import { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { Compilation } from "webpack";
+export declare class AdditionalDependencyInjectorPlugin extends AbstractBiPhasicGroupPlugin {
     private readonly processingModules;
     private readonly addExternalizedDep;
     private readonly referencePlugin;
-    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void, referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>);
-    apply(compiler: Compiler): void;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, processingModules: boolean, addExternalizedDep: (dep: string) => void, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
+    protected attachStandardPhase(compilation: Compilation): void;
+    protected attachUniquePhase(): void;
 }

package/build/plugins/AdditionalDependencyInjectorPlugin.js

@@ -4,57 +4,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdditionalDependencyInjectorPlugin = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
+const shared_1 = require("../shared");
 const webpack_1 = require("webpack");
-class AdditionalDependencyInjectorPlugin {
-    entrypointAdditionalDependencies;
+class AdditionalDependencyInjectorPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
     processingModules;
     addExternalizedDep;
     referencePlugin;
-    constructor(entrypointAdditionalDependencies, processingModules, addExternalizedDep, referencePlugin) {
-        this.entrypointAdditionalDependencies = entrypointAdditionalDependencies;
+    constructor(config, processingModules, addExternalizedDep, referencePlugin) {
+        super(config, "additional-dependency-injector-plugin", []);
         this.processingModules = processingModules;
         this.addExternalizedDep = addExternalizedDep;
         this.referencePlugin = referencePlugin;
     }
-    apply(compiler) {
-        compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.processAssets.tap({
-                name: `${this.constructor.name}_ProcessAssets_AddFakeModules`,
-                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-            }, () => {
-                const usableEntrypointTest = this.processingModules ? /\.m[jt]sx?$/i : /\.[jt]sx?$/i;
-                for (const { entrypoint } of this.referencePlugin.getRelevantEntrypoints(compilation)) {
-                    const req = entrypoint.origins.filter(origin => usableEntrypointTest.test(origin.request))[0]?.request;
-                    if (!req) {
-                        continue;
-                    }
-                    const additionalDependencies = [...this.entrypointAdditionalDependencies];
-                    const firstLine = node_fs_1.default.readFileSync(req, 'utf8').trim().split(/\r?\n/)[0];
-                    if (firstLine?.startsWith("//ADDITIONAL_DEPENDENCIES:")) {
-                        additionalDependencies.push(...firstLine.substring(26).trim().split(',').map(dep => dep.trim()));
-                    }
-                    const chunk = entrypoint.getEntrypointChunk();
-                    for (const additionalDep of additionalDependencies) {
-                        this.addExternalizedDep(additionalDep);
-                        compilation.chunkGraph.connectChunkAndModule(chunk, new webpack_1.ExternalModule("__REMOVE_ME__", "", additionalDep));
-                    }
+    attachStandardPhase(compilation) {
+        const usableEntrypointTest = this.processingModules ? shared_1.scriptWithModuleExtension : shared_1.scriptWithoutModuleExtension;
+        compilation.hooks.processAssets.tapPromise({
+            name: `${this.constructor.name}_ProcessAssets_AddFakeModules`,
+            stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+        }, async () => {
+            await Promise.all(this.referencePlugin.getRelevantEntrypoints(compilation)
+                .filter(re => usableEntrypointTest.test(re.srcPath))
+                .map(async ({ entrypoint, metadata, srcPath }) => {
+                const additionalDependencies = [...metadata.dest.additionalDependencies];
+                const firstLine = (await promises_1.default.readFile(srcPath, 'utf-8')).trim().split(/\r?\n/)[0];
+                if (firstLine?.startsWith("//ADDITIONAL_DEPENDENCIES:")) {
+                    additionalDependencies.push(...firstLine.substring(26).trim().split(',').map(dep => dep.trim()));
                 }
-            });
-            compilation.hooks.processAssets.tap({
-                name: `${this.constructor.name}_ProcessAssets_RemoveFakeModules`,
-                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT
-            }, () => {
-                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__') {
-                            compilation.chunkGraph.disconnectChunkAndModule(entrypointChunk, module);
-                        }
+                const chunk = entrypoint.getEntrypointChunk();
+                for (const additionalDep of additionalDependencies) {
+                    this.addExternalizedDep(additionalDep);
+                    compilation.chunkGraph.connectChunkAndModule(chunk, new webpack_1.ExternalModule("__REMOVE_ME__", "", additionalDep));
+                }
+            }));
+        });
+        compilation.hooks.processAssets.tap({
+            name: `${this.constructor.name}_ProcessAssets_RemoveFakeModules`,
+            stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT
+        }, () => {
+            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__') {
+                        compilation.chunkGraph.disconnectChunkAndModule(entrypointChunk, module);
                     }
                 }
-            });
+            }
         });
     }
+    attachUniquePhase() { }
 }
 exports.AdditionalDependencyInjectorPlugin = AdditionalDependencyInjectorPlugin;

package/build/plugins/EnhancedDynamicEntryPlugin.d.ts

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

package/build/plugins/EnhancedDynamicEntryPlugin.js

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

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