@plaudit/webpack-extensions 2.65.0 → 2.65.2

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -1,10 +1,18 @@
-import { ParsedAssetsJson } from "../shared";
+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> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
-export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M> extends AbstractBiPhasicGroupPlugin {
+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;
@@ -12,11 +20,14 @@ export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M> extends Abs
     protected constructor(config: VerifiedPlauditWordpressWebpackConfig, group: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
     apply(compiler: Compiler): void;
     protected attachStandardPhase(compilation: Compilation): void;
-    getRelevantEntrypoints(compilation: Compilation): {
+    /**
+     * 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

@@ -48,6 +48,9 @@ class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.
             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 => {
@@ -65,13 +68,11 @@ class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.
             }
             return { entrypoint, srcPath, metadata };
         })
-            .filter(item => item !== undefined)
-            .toArray();
+            .filter(item => item !== undefined);
     }
     extractRelevantAssetData(compilation, parsedAssetsJson) {
         const relevantAssetData = {};
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
-        for (const { entrypoint, srcPath } of relevantEntrypoints) {
+        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));

package/build/plugins/AdditionalDependencyInjectorPlugin.d.ts

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -2,12 +2,12 @@ import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBi
 import { ParsedAssetsJson, VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<string> {
+export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin {
     private readonly extensionsSrcPath;
     private readonly dest;
     private static readonly semaphore;
     private setupFiles;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsSrcPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider<string>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsSrcPath: string, dest: VerifiedAdvancedOutputConfig, context: string, entry: EntryProvider);
     get extensionsDestPath(): string;
     apply(compiler: Compiler): void;
     private generateVersionTwoConfigFile;

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

@@ -2,9 +2,9 @@ import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBi
 import type { ParsedAssetsJson } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
-export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin<string> {
+export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin {
     private readonly extensionsDest;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsDest: string, context: string, entry: EntryProvider<string>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsDest: string, context: string, entry: EntryProvider);
     protected attachUniquePhase(): void;
     protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,14 +1,14 @@
-import { ParsedAssetsJson, UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
+import { ParsedAssetsJson, BlockEntrypointInfo, UsageLocations } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { Compilation } from "webpack";
-export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
+export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<BlockEntrypointInfo> {
     private readonly buildRoot;
     private readonly outputDir;
     private readonly usageLocations;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: UsageLocations, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: UsageLocations, useUnifiedLoader: boolean, context: string, entry: EntryProvider<BlockEntrypointInfo>);
     private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;
     private static appendEnqueuingHandleLists;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -166,7 +166,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
     processAssets(compilation, assetsJson) {
         const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
         const myAssetHandles = [];
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
         for (const { entrypoint, srcPath } of relevantEntrypoints) {
             const entrypointChunk = entrypoint.getEntrypointChunk();
             const assetData = entrypointChunk.files.values()
@@ -203,7 +203,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
             ? {
                 group: this.group, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';"),
-                staticallyLoadedEntrypoints: Object.keys(relevantEntrypoints)
+                staticallyLoadedEntrypoints: relevantEntrypoints.flatMap(re => re.entrypoint.getEntrypointChunk().files.values().toArray())
             }
             : undefined);
     }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts

@@ -1,13 +1,13 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetsJson, UnpackedBlockEntrypointInfo } from "../shared";
+import { ParsedAssetsJson, BlockEntrypointInfo } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
+export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin<BlockEntrypointInfo> {
     private readonly blocksDest;
     private readonly webpackRemoveEmptyScriptsPlugin;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<BlockEntrypointInfo>);
     protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): Promise<void>;
     private emitBlockLoaderFile;
     private transformBlocks;
@@ -22,4 +22,5 @@ export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhas
     private static remapReferencedPHPFilesOnKey;
     private static normalizeRenderTemplate;
     protected attachUniquePhase(compilation: Compilation): void;
+    protected attachStandardPhase(compilation: Compilation): void;
 }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlainEntrypointsStyleBlockJSONPlugin = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
@@ -13,7 +14,6 @@ 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 promises_1 = __importDefault(require("node:fs/promises"));
 class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     blocksDest;
     webpackRemoveEmptyScriptsPlugin;
@@ -26,18 +26,12 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
     async processAssets(compilation, rawAssetData) {
         const applicableBlockJsonFiles = {};
         const blockJsonOriginToOutputMapping = {};
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+        const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || metadata !== "block-json-inclusion-assurance") {
+            if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
                 continue;
             }
-            const entrypointChunk = entrypoint.getEntrypointChunk();
-            for (const danglingBlockJsFile of [...entrypointChunk.files, ...entrypointChunk.auxiliaryFiles]) {
-                if (!danglingBlockJsFile.endsWith("block.json")) {
-                    compilation.deleteAsset(danglingBlockJsFile);
-                }
-            }
-            const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypointChunk)][0]?.originalSource();
+            const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypoint.getEntrypointChunk())][0]?.originalSource();
             if (asset) {
                 //TODO: Can we guarantee that entrypoint.name is always non-null?
                 const epBlockJson = entrypoint.name + ".json";
@@ -54,7 +48,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             }
         }
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || typeof metadata === 'string') {
+            if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || 'purpose' in metadata) {
                 continue;
             }
             const entrypointChunk = entrypoint.getEntrypointChunk();
@@ -98,7 +92,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(applicableBlockJsonFiles).length ? {
             group: this.group,
             requiresBaseURI: false,
-            staticallyLoadedEntrypoints: Object.keys(relevantEntrypoints),
+            staticallyLoadedEntrypoints: relevantEntrypoints.flatMap(re => re.entrypoint.getEntrypointChunk().files.values().toArray()),
             action: writer => writer.append(`require_once __DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + node_path_1.default.join(this.blocksDest, "blockdir-loader.php"))};`)
         } : undefined);
     }
@@ -378,5 +372,22 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             this.emitBlockLoaderFile(compilation, blockData);
         });
     }
+    attachStandardPhase(compilation) {
+        super.attachStandardPhase(compilation);
+        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER }, async () => {
+            const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
+            for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
+                if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
+                    continue;
+                }
+                const entrypointChunk = entrypoint.getEntrypointChunk();
+                for (const danglingBlockJsFile of [...entrypointChunk.files, ...entrypointChunk.auxiliaryFiles]) {
+                    if (!danglingBlockJsFile.endsWith("block.json")) {
+                        compilation.deleteAsset(danglingBlockJsFile);
+                    }
+                }
+            }
+        });
+    }
 }
 exports.PlainEntrypointsStyleBlockJSONPlugin = PlainEntrypointsStyleBlockJSONPlugin;

package/build/shared.d.ts

@@ -1,6 +1,6 @@
 import { PHPWriter } from "./utils/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { Compilation, type Configuration, type EntryOptions, WebpackError } from "webpack";
+import { Compilation, type Configuration, WebpackError } from "webpack";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
@@ -75,23 +75,18 @@ export type PlauditWordpressWebpackConfig = {
     srcPrefixes?: string[];
     useUnifiedLoader?: boolean;
 };
-export type SmuggledBlockEntrypointInfo = [
-    string,
-    EntrypointFields[number],
-    string,
-    string,
-    string
-];
-export type UnpackedBlockEntrypointInfo = {
+export type FileSegmentBlockEntrypointInfo = {
     blockJsonOrigin: string;
     entrypointField: EntrypointFields[number];
     originalValue: string;
     entrypointName: string;
     handle: string;
+    dest: VerifiedAdvancedOutputConfig;
+};
+export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
+    dest: VerifiedAdvancedOutputConfig;
+    purpose: string;
 };
-export declare function packBlockEntrypointInfoForSmuggling(info: UnpackedBlockEntrypointInfo): SmuggledBlockEntrypointInfo;
-export declare function unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library'], allowedEndings?: string[] | false): UnpackedBlockEntrypointInfo | undefined;
-export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined, allowedEndings?: string[] | false): libraryName is SmuggledBlockEntrypointInfo;
 export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): string;
 export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
 export type EntrypointFields = ["viewScriptModule", "scriptModule"] | ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];

package/build/shared.js

@@ -6,9 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNames = void 0;
 exports.isParsedAssetsJson = isParsedAssetsJson;
 exports.determineCurrentSourceType = determineCurrentSourceType;
-exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
-exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
-exports.isSmuggledLibraryInfo = isSmuggledLibraryInfo;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
@@ -58,23 +55,6 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
-function packBlockEntrypointInfoForSmuggling(info) {
-    return [info.blockJsonOrigin, info.entrypointField, info.originalValue, info.entrypointName, info.handle];
-}
-const defaultAllowedEndings = ["/block.json", "/entrypoints.json", "/package.json"];
-function unpackSmuggledBlockEntrypointInfo(library, allowedEndings) {
-    const libraryName = library?.name;
-    if (!isSmuggledLibraryInfo(libraryName, allowedEndings)) {
-        return undefined;
-    }
-    return { blockJsonOrigin: libraryName[0], entrypointField: libraryName[1], originalValue: libraryName[2], entrypointName: libraryName[3], handle: libraryName[4] };
-}
-function isSmuggledLibraryInfo(libraryName, allowedEndings = defaultAllowedEndings) {
-    if (!Array.isArray(libraryName) || !arrayIsLength(libraryName, 5) || libraryName.some(item => typeof item !== 'string')) {
-        return false;
-    }
-    return (!allowedEndings || allowedEndings.some(s => libraryName[0].endsWith(s))) && exports.entrypointFields.includes(libraryName[1]);
-}
 function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
     const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
     return emittableHandle.replaceAll("{basename}", generatedHandle);

package/build/utils/common-config-helpers.d.ts

@@ -1,6 +1,6 @@
 import type { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "../plugins/AbstractBiPhasicGroupAndEntryPlugin";
 import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDependencyInjectorPlugin";
-import { EntrypointFields, PlauditWordpressWebpackConfig, UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
 import type { Compiler, Configuration, DynamicEntryPlugin, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
@@ -21,12 +21,12 @@ export type CommonConfigProcessingResult = {
 };
 export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)[]): string;
 export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
-export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<UnpackedBlockEntrypointInfo | string>;
+export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<BlockEntrypointInfo>;
 export type EntryStaticNormalized = Awaited<ReturnType<ConstructorParameters<typeof DynamicEntryPlugin>[1]>>;
 export type ExtensibleEntryObject<M> = {
     [index: string]: Omit<EntryStaticNormalized[string], 'import'> & Required<NonNullable<Pick<EntryStaticNormalized[string], 'import'>>> & {
         plauditMetadata: M;
     };
 };
-export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<UnpackedBlockEntrypointInfo | string>;
+export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<BlockEntrypointInfo>;
 export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, externalize: VerifiedAdvancedOutputConfig['externalize'], plugins: CommonPluginConfig['plugins'], canClean: boolean): Configuration;

package/build/utils/common-config-helpers.js

@@ -44,7 +44,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             entrypointField: shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'scriptModule' : 'script',
             originalValue: ep,
             entrypointName: parsedEntrypoint.name,
-            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name)
+            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
+            dest
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -168,7 +169,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
                             return {
                                 blockJsonOrigin, ...presentEntrypoint,
-                                handle: `${handlePrefix}/${handleSuffix}`
+                                handle: `${handlePrefix}/${handleSuffix}`,
+                                dest
                             };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
@@ -184,7 +186,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`
+                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            dest
                         };
                     });
                     rawEntrypoints.push(...resolvedBlockEntrypoints
@@ -197,7 +200,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: "block-json-inclusion-assurance" }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {
@@ -251,12 +254,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
             try {
                 await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
-                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: "wpml-config-xml" };
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest } };
             }
             catch (e) {
                 // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
                 if (wpmlEntrypointFiles.length) {
-                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: "wpml-config-xml" };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: { purpose: "wpml-config-xml", dest } };
                 }
             }
         }

package/build/wordpress-scripts-wrapper.js

@@ -360,7 +360,7 @@ function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins)
         }
     }
 }
-function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies) {
+function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
     const { externals } = config;
     const processingModules = webpackConfig.output?.module ?? false;
     const plugins = webpackConfig.plugins?.filter(v => !!v)
@@ -403,7 +403,7 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
     return {
         plugins, removeEmptyScriptsPlugin,
         makeAdditionalDependencyInjectorPlugin(referencePlugin) {
-            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(additionalDependencies ?? [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
+            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(config, processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
         }
     };
 }
@@ -446,7 +446,7 @@ function destToKey(dest) {
     const externalize = typeof dest.externalize === 'object' && dest.externalize !== undefined
         ? (Array.isArray(dest.externalize) ? dest.externalize.join("_") : (dest.externalize ? Object.entries(dest.externalize).flat().sort().join() : "undefined"))
         : dest.externalize?.toString() ?? "undefined";
-    return [dest.additionalDependencies.join("_"), dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize, dest.withLegacyBlocksIn].join("~");
+    return [dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
 }
 function processIndividualWebpackConfig(config, webpackConfig, sources, canClean) {
     const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
@@ -469,8 +469,8 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
     }
     const batches = Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem);
     return batches.map(currentBatch => {
-        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies } = currentBatch[0].dest;
-        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies);
+        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
+        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
         handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
         for (const { dest, src, srcIsDirectory, srcRoot } of currentBatch) {
             let plugin;
@@ -495,7 +495,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                         if (dirent.isFile() && !dirent.name.startsWith("~")) {
                             if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
                                 const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: "entrypoint-v2" }]);
+                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: { dest } }]);
                             }
                         }
                     }
@@ -517,7 +517,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 if (config.plainEntrypointsVersion > 1) {
                     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
                         ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
-                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } });
+                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest } } });
                     plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
                 }
                 else {
@@ -525,7 +525,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                         console.error("Using directory mode with legacy plain entrypoint handling is not supported");
                         continue;
                     }
-                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, webpackConfig.context ?? process.cwd(), () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } }));
+                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, webpackConfig.context ?? process.cwd(), () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest } } }));
                 }
                 plugins.push(plugin);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.65.0",
+  "version": "2.65.2",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -16,9 +16,9 @@
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.75.0",
+    "@plaudit/gutenberg-api-extensions": "^2.76.1",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.2.7",
     "@types/webpack": "^5.28.5",