@plaudit/webpack-extensions 2.75.0 → 2.76.1

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.d.ts

@@ -1,18 +1,10 @@
-import { ParsedAssetsJson, VerifiedAdvancedOutputConfig } from "../shared";
+import { MinimumViableMetadata, ParsedAssetJsonProvider, ParsedAssetsJson } 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 {
+export type EntryProvider<M extends MinimumViableMetadata = MinimumViableMetadata> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
+export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M extends MinimumViableMetadata = MinimumViableMetadata> extends AbstractBiPhasicGroupPlugin {
     private readonly context;
     private readonly entry;
     private static readonly configuredCompilations;
@@ -28,6 +20,6 @@ export declare abstract class AbstractBiPhasicGroupAndEntryPlugin<M extends {
         srcPath: string;
         metadata: M;
     }, undefined, unknown>;
-    protected abstract processAssets(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): Promise<void> | void;
-    protected extractRelevantAssetData(compilation: Compilation, parsedAssetsJson: ParsedAssetsJson): ParsedAssetsJson;
+    protected abstract processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): Promise<void> | void;
+    protected extractRelevantAssetData(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): ParsedAssetsJson;
 }

package/build/plugins/AbstractBiPhasicGroupAndEntryPlugin.js

@@ -70,15 +70,15 @@ class AbstractBiPhasicGroupAndEntryPlugin extends AbstractBiPhasicGroupPlugin_1.
         })
             .filter(item => item !== undefined);
     }
-    extractRelevantAssetData(compilation, parsedAssetsJson) {
+    extractRelevantAssetData(compilation, parsedAssetJsonProvider) {
         const relevantAssetData = {};
-        for (const { entrypoint, srcPath } of this.getRelevantEntrypoints(compilation)) {
-            const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => parsedAssetsJson[file]);
-            if (!fileWithAssetData) {
+        for (const { entrypoint, srcPath, metadata } of this.getRelevantEntrypoints(compilation)) {
+            const providedData = parsedAssetJsonProvider(entrypoint, metadata);
+            if (providedData === undefined) {
                 compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
                 continue;
             }
-            relevantAssetData[fileWithAssetData] = parsedAssetsJson[fileWithAssetData];
+            relevantAssetData[providedData.assetName] = providedData.assetData;
         }
         return relevantAssetData;
     }

package/build/plugins/AbstractBiPhasicGroupPlugin.d.ts

@@ -1,14 +1,14 @@
 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";
+import { type ParsedAssetJsonProvider } 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;
+type TapWithParsedAssetsJsonFn = (parsedAssetJsonProvider: ParsedAssetJsonProvider, assets: Parameters<TapWithAssetsJsonFn>[0]) => Promise<void> | void;
 export declare abstract class AbstractBiPhasicGroupPlugin implements WebpackPluginInstance {
     protected readonly config: VerifiedPlauditWordpressWebpackConfig;
     readonly group: string;

package/build/plugins/AbstractBiPhasicGroupPlugin.js

@@ -49,7 +49,7 @@ class AbstractBiPhasicGroupPlugin {
         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);
+                    await fn((entrypoint, dest) => (0, shared_1.getParsedAssetsJsonDataForEntrypoint)(compilation, entrypoint, dest), assets);
                 }
                 catch (e) {
                     console.error(e);

package/build/plugins/{PlainEntrypointsStyleBlockJSONPlugin.d.ts → EnhancedBlockJSONPlugin.d.ts}

@@ -1,5 +1,5 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
@@ -13,12 +13,12 @@ type CollatedWorkableBlockInfo = Record<string, {
     workableBlockEntrypointsInfo: WorkableBlockEntrypointInfo[];
     blockJsonText?: string;
 }>;
-export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin<BlockEntrypointInfo> {
+export declare class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin<BlockEntrypointInfo> {
     private readonly dest;
     private readonly webpackRemoveEmptyScriptsPlugin;
     private static readonly semaphore;
     constructor(config: VerifiedPlauditWordpressWebpackConfig, dest: VerifiedAdvancedOutputConfig, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<BlockEntrypointInfo>);
-    protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): Promise<void>;
+    protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): Promise<void>;
     private emitBlockLoaderFile;
     private transformBlocks;
     private static extractAssetSource;

package/build/plugins/{PlainEntrypointsStyleBlockJSONPlugin.js → EnhancedBlockJSONPlugin.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlainEntrypointsStyleBlockJSONPlugin = void 0;
+exports.EnhancedBlockJSONPlugin = 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"));
@@ -15,16 +15,16 @@ const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
+class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     dest;
     webpackRemoveEmptyScriptsPlugin;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Block JSON v3");
     constructor(config, dest, webpackRemoveEmptyScriptsPlugin, context, entry) {
-        super(config, `block-json-${dest.destination}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
+        super(config, `block-json-${dest.destination}`, [EnhancedBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.dest = dest;
         this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
     }
-    async processAssets(compilation, rawAssetData) {
+    async processAssets(compilation, parsedAssetJsonProvider) {
         const applicableBlockJsonFiles = {};
         const blockJsonOriginToOutputMapping = {};
         const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
@@ -37,7 +37,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
                 //TODO: Can we guarantee that entrypoint.name is always non-null?
                 const epBlockJson = entrypoint.name + ".json";
                 if (!applicableBlockJsonFiles[epBlockJson]) {
-                    const blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
+                    const blockJsonText = EnhancedBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
                         ?? await promises_1.default.readFile(srcPath, 'utf-8');
                     if (!blockJsonText) {
                         compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${epBlockJson}`, srcPath));
@@ -56,9 +56,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => node_path_1.default.basename(auxFile) === "block.json")
                 ?? blockJsonOriginToOutputMapping[metadata.blockJsonOrigin];
             if (epBlockJson) {
-                //TODO: Do we need to handle a single entrypoint potentially emitting multiple primary files?
-                const assetData = entrypointChunk.files.values().map(file => rawAssetData[file])
-                    .find(assetData => assetData !== undefined);
+                const assetData = parsedAssetJsonProvider(entrypoint, metadata)?.assetData;
                 if (!assetData) {
                     compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
                     continue;
@@ -87,7 +85,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
                 }
             }
         }
-        PlainEntrypointsStyleBlockJSONPlugin.semaphore.resolve(this.id, {
+        EnhancedBlockJSONPlugin.semaphore.resolve(this.id, {
             collatableWorkableBlockInfo: applicableBlockJsonFiles, blocksDest: this.dest.destination,
             emittingWpmlXml: compilation.getAsset(node_path_1.default.join(this.dest.destination, "wpml-config.xml")) !== undefined
         });
@@ -148,9 +146,9 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(blockJsonAssetName));
             const blockJson = JSON.parse(blockJsonText);
             const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
-            PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
-            PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
-            const hashForVersion = PlainEntrypointsStyleBlockJSONPlugin
+            EnhancedBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
+            EnhancedBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
+            const hashForVersion = EnhancedBlockJSONPlugin
                 .hashThingForAsset([blockJsonText, ...workableBlockEntrypointsInfo.map(bi => bi.hash)].join("~"));
             if (blockJson["version"]) {
                 blockJson["version"] = `${blockJson["version"]}-${hashForVersion}`;
@@ -158,20 +156,20 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             else {
                 blockJson["version"] = hashForVersion;
             }
-            PlainEntrypointsStyleBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
+            EnhancedBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
             const blockDirName = node_path_1.default.dirname(node_path_1.default.relative(this.dest.destination, blockJsonAssetName));
-            blockData[blockDirName] = PlainEntrypointsStyleBlockJSONPlugin
+            blockData[blockDirName] = EnhancedBlockJSONPlugin
                 .doFileOrHandleReplacements(compilation, Object.fromEntries(Object.entries(blockJson).filter(([k]) => k !== '$schema')), workableBlockEntrypointsInfo, epi => epi.handle);
-            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(PlainEntrypointsStyleBlockJSONPlugin
+            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(EnhancedBlockJSONPlugin
                 .doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, epi => "file:./" + node_path_1.default.relative(blockDirName, epi.outputPath)), undefined, "  ")));
         }
         return {
             __metadata: {
                 version: 3,
                 "wpml-config": emittingWpmlXml,
-                scriptHandles: Object.fromEntries(PlainEntrypointsStyleBlockJSONPlugin
+                scriptHandles: Object.fromEntries(EnhancedBlockJSONPlugin
                     .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && !(0, shared_1.isScriptModuleField)(hd.entrypointField)))),
-                scriptModuleHandles: Object.fromEntries(PlainEntrypointsStyleBlockJSONPlugin
+                scriptModuleHandles: Object.fromEntries(EnhancedBlockJSONPlugin
                     .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && (0, shared_1.isScriptModuleField)(hd.entrypointField)))),
                 styleHandles: Object.fromEntries(handleData.filter(hd => (0, shared_1.isStyleField)(hd.entrypointField))
                     .map(hd => {
@@ -252,7 +250,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         });
     }
     static findRelativeRouteBetween(path1, path2) {
-        const commonAncestor = PlainEntrypointsStyleBlockJSONPlugin.findCommonAncestor(path1, path2);
+        const commonAncestor = EnhancedBlockJSONPlugin.findCommonAncestor(path1, path2);
         const route = Array(path1.split(node_path_1.default.sep).length - commonAncestor.length).fill("..");
         route.push(node_path_1.default.relative(commonAncestor.join(node_path_1.default.sep), path2));
         return route.join(node_path_1.default.sep);
@@ -288,11 +286,11 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         }
         const mappedFiles = pathsNeedRemapping
             ? rawFiles
-                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p))))
+                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
                 .filter(p => node_fs_1.default.existsSync(p))
-                .map(p => `file:./${PlainEntrypointsStyleBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
+                .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
             : rawFiles
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p)))));
+                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
         if (mappedFiles.length === 0) {
             if (deleteOnEmpty && rawValue !== undefined) {
                 delete (inPlaudit ? blockJson["plaudit"] : blockJson)[key];
@@ -328,11 +326,11 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
             : [`${blockName.substring(blockName.indexOf('/') + 1)}.php`, "template.php", "template.twig"]);
         const renderTemplate = pathsNeedRemapping
             ? rawRenderTemplate
-                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p))))
+                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
                 .filter(p => node_fs_1.default.existsSync(p))
-                .map(p => `file:./${PlainEntrypointsStyleBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
+                .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
             : rawRenderTemplate
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p)))));
+                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
         if (renderTemplate.length === 0) {
             delete blockJson["render_template"];
             delete blockJson["render"];
@@ -361,7 +359,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
     }
     attachUniquePhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-            const allSemaphoreData = (await PlainEntrypointsStyleBlockJSONPlugin.semaphore.wait())
+            const allSemaphoreData = (await EnhancedBlockJSONPlugin.semaphore.wait())
                 .reduce((acc, cur) => {
                 (acc[cur.blocksDest] ?? (acc[cur.blocksDest] = [])).push(cur);
                 return acc;
@@ -434,4 +432,4 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         }));
     }
 }
-exports.PlainEntrypointsStyleBlockJSONPlugin = PlainEntrypointsStyleBlockJSONPlugin;
+exports.EnhancedBlockJSONPlugin = EnhancedBlockJSONPlugin;

package/build/plugins/EnhancedDynamicEntryPlugin.d.ts

@@ -1,7 +1,9 @@
+import { Compilation } from "webpack";
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { ParsedAssetJsonProvider } from "../shared";
 export declare class EnhancedDynamicEntryPlugin extends AbstractBiPhasicGroupAndEntryPlugin {
     constructor(config: VerifiedPlauditWordpressWebpackConfig, context: string, entry: EntryProvider);
     protected attachUniquePhase(): void;
-    protected processAssets(): void;
+    protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): void;
 }

package/build/plugins/EnhancedDynamicEntryPlugin.js

@@ -7,6 +7,8 @@ class EnhancedDynamicEntryPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.A
         super(config, `enhanced-dynamic-entries`, [], context, entry);
     }
     attachUniquePhase() { }
-    processAssets() { }
+    processAssets(compilation, parsedAssetJsonProvider) {
+        this.extractRelevantAssetData(compilation, parsedAssetJsonProvider);
+    }
 }
 exports.EnhancedDynamicEntryPlugin = EnhancedDynamicEntryPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,5 +1,5 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetsJson, VerifiedAdvancedOutputConfig } from "../shared";
+import { ParsedAssetJsonProvider, VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
 export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin {
@@ -12,5 +12,5 @@ export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasi
     apply(compiler: Compiler): void;
     private generateVersionThreeConfigFile;
     protected attachUniquePhase(compilation: Compilation): void;
-    protected processAssets(compilation: Compilation, rawAssetData: ParsedAssetsJson): void;
+    protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): void;
 }

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -126,8 +126,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryP
             }
         });
     }
-    processAssets(compilation, rawAssetData) {
-        const relevantAssetData = this.extractRelevantAssetData(compilation, rawAssetData);
+    processAssets(compilation, parsedAssetJsonProvider) {
+        const relevantAssetData = this.extractRelevantAssetData(compilation, parsedAssetJsonProvider);
         const staticallyLoadedEntrypoints = Object.keys(relevantAssetData);
         const generateLoader = (writer) => {
             writer.require(this.extensionsDestPath + "extensions-loader.php", { dirRelative: true, once: true });

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

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

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.js

@@ -17,10 +17,10 @@ class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntr
         this.extensionsDest = extensionsDest;
     }
     attachUniquePhase() { }
-    processAssets(compilation, assetsJson) {
+    processAssets(compilation, parsedAssetJsonProvider) {
         const regex = /^(.+?)-((?<prefix>editor-|view-|)(?<type>style|script|script-module))\.(?<extension>css|m?js)$/i;
         const mapping = {};
-        for (let fileWithAssetData of Object.keys(this.extractRelevantAssetData(compilation, assetsJson))) {
+        for (let fileWithAssetData of Object.keys(this.extractRelevantAssetData(compilation, parsedAssetJsonProvider))) {
             let match;
             if ((match = regex.exec(fileWithAssetData)) && match[1] && match[2]) {
                 if (match.groups?.['type'] === 'style' && match.groups['extension'] !== 'css') {

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,4 +1,4 @@
-import { ParsedAssetsJson, BlockEntrypointInfo, UsageLocations } from "../shared";
+import { BlockEntrypointInfo, UsageLocations, ParsedAssetJsonProvider } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { Compilation } from "webpack";
@@ -14,5 +14,5 @@ export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractB
     private static appendEnqueuingHandleLists;
     private static separateHandleListByPriority;
     protected attachUniquePhase(compilation: Compilation): void;
-    protected processAssets(compilation: Compilation, assetsJson: ParsedAssetsJson): void;
+    protected processAssets(compilation: Compilation, parsedAssetJsonProvider: ParsedAssetJsonProvider): void;
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -139,14 +139,13 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             this.generatePlainEntrypointsLoader(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
         });
     }
-    processAssets(compilation, assetsJson) {
+    processAssets(compilation, parsedAssetJsonProvider) {
         const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
         const myAssetHandles = [];
         const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
-        for (const { entrypoint, srcPath } of relevantEntrypoints) {
+        for (const { entrypoint, srcPath, metadata } of relevantEntrypoints) {
             const entrypointChunk = entrypoint.getEntrypointChunk();
-            const assetData = entrypointChunk.files.values()
-                .map(file => assetsJson[file]).find(v => v !== undefined);
+            const assetData = parsedAssetJsonProvider(entrypoint, metadata)?.assetData;
             if (!assetData) {
                 continue;
             }

package/build/plugins/UnifiedLoaderGenerator.js

@@ -21,7 +21,7 @@ class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPha
         });
     }
     attachUniquePhase(compilation) {
-        this.tapWithParsedAssetsJson(compilation, { stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async (parsedAssetsJson) => {
+        this.tapRequiringAssetsJson(compilation, { stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
             const groupedLoaderInfo = Object.values((await UnifiedLoaderGenerator.semaphore.wait())
                 .reduce((acc, cur) => {
                 const accValue = acc[cur.group];
@@ -47,13 +47,14 @@ class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPha
                 return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
             });
             const staticallyLoadedEntrypoints = new Set(groupedLoaderInfo.flatMap(lig => lig.staticallyLoadedEntrypoints));
-            for (const [file, assetData] of Object.entries(parsedAssetsJson)) {
+            for (const [file, assetData] of Object.entries((0, shared_1.getAssetsJson)(compilation))) {
                 if (staticallyLoadedEntrypoints.has(file)) {
                     continue;
                 }
                 const parsedPath = node_path_1.default.parse(file);
                 const contents = `<?php return ${(0, php_writer_1.json2php)(assetData)};\n`;
-                compilation.emitAsset(node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php", new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                const assetName = node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php";
+                compilation[assetName in compilation.assets ? 'updateAsset' : 'emitAsset'](assetName, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
             }
             if (this.config.useUnifiedLoader) {
                 compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {

package/build/shared.d.ts

@@ -1,6 +1,6 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { AssetInfo, Compilation, type Configuration, WebpackError } from "webpack";
+import { AssetInfo, Compilation, type Configuration, Entrypoint, WebpackError } from "webpack";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
@@ -113,10 +113,16 @@ export type FileSegmentBlockEntrypointInfo = {
     entrypointName: string;
     handle: string;
     dest: VerifiedAdvancedOutputConfig;
+    absoluteSrc: string;
 };
 export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
     dest: VerifiedAdvancedOutputConfig;
     purpose: string;
+    absoluteSrc: string;
+};
+export type MinimumViableMetadata = {
+    dest: VerifiedAdvancedOutputConfig;
+    absoluteSrc: string;
 };
 export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): string;
 export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
@@ -145,6 +151,14 @@ export declare function newWebpackErrorForFile(error: string | ConstructorParame
  */
 export declare function emitResolveBaseUriFunction(writer: PHPWriter): void;
 export declare function getAssetsJson(compilation: Compilation): ParsedAssetsJson;
+export type ParsedAssetJsonProvider = (entrypoint: Entrypoint, metadata: MinimumViableMetadata) => {
+    assetName: string;
+    assetData: ParsedAssetsJson[string];
+} | undefined;
+export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compilation, entrypoint: Entrypoint, metadata: MinimumViableMetadata): {
+    assetName: string;
+    assetData: ParsedAssetsJson[string];
+} | undefined;
 export declare function emitPHPWriterAsAsset(writer: PHPWriter, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 export declare function dedent(text: TemplateStringsArray): string;
 export declare function resolveLegacyBlockScriptsInFolder(folder: string): string[];

package/build/shared.js

@@ -24,6 +24,7 @@ exports.parseEnvFile = parseEnvFile;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
 exports.getAssetsJson = getAssetsJson;
+exports.getParsedAssetsJsonDataForEntrypoint = getParsedAssetsJsonDataForEntrypoint;
 exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 exports.dedent = dedent;
 exports.resolveLegacyBlockScriptsInFolder = resolveLegacyBlockScriptsInFolder;
@@ -183,6 +184,41 @@ function getAssetsJson(compilation) {
     compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
     return parsedAssetJson;
 }
+function getParsedAssetsJsonDataForEntrypoint(compilation, entrypoint, metadata) {
+    const dest = metadata.dest;
+    const parsedAssetJson = getAssetsJson(compilation);
+    const scriptExtension = compilation.outputOptions.module ? exports.scriptWithModuleExtension : exports.scriptWithoutModuleExtension;
+    const assetType = scriptOrStyleTest(metadata.absoluteSrc, scriptExtension);
+    const chunkFiles = [dest.destination, ...entrypoint.chunks.flatMap(chunk => Array.from(chunk.files))]
+        .filter(chunkFile => scriptOrStyleTest(chunkFile, scriptExtension) === assetType);
+    for (const chunkFile of chunkFiles) {
+        if (parsedAssetJson[chunkFile]) {
+            return { assetName: chunkFile, assetData: parsedAssetJson[chunkFile] };
+        }
+    }
+    if (assetType !== 'style' || !hasAtLeastOneItem(chunkFiles)) {
+        return undefined;
+    }
+    // The rest of this function is a modified version of the hash-computing logic from @wordpress/dependency-extraction-webpack-plugin
+    const { hashFunction, hashDigest, hashDigestLength } = compilation.outputOptions;
+    const hashBuilder = webpack_1.util.createHash(hashFunction);
+    for (const chunkFile of chunkFiles.toSorted()) {
+        const source = compilation.getAsset(chunkFile)?.source.buffer();
+        if (source !== undefined) {
+            hashBuilder.update(source);
+        }
+    }
+    // Finalise hash.
+    const contentHash = hashBuilder
+        .digest(hashDigest)
+        .slice(0, hashDigestLength);
+    const assetData = {
+        dependencies: [],
+        version: contentHash,
+    };
+    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": { ...parsedAssetJson, [chunkFiles[0]]: assetData } }));
+    return { assetName: chunkFiles[0], assetData };
+}
 function emitPHPWriterAsAsset(writer, compilation, file, assetInfo) {
     const contents = writer.toString() + "\n";
     compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });

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, BlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata } 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'>> & {
@@ -23,9 +23,9 @@ export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)
 export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
 export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<BlockEntrypointInfo>;
 export type EntryStaticNormalized = Awaited<ReturnType<ConstructorParameters<typeof DynamicEntryPlugin>[1]>>;
-export type ExtensibleEntryObject<M> = {
+export type ExtensibleEntryObject<M extends object = {}> = {
     [index: string]: Omit<EntryStaticNormalized[string], 'import'> & Required<NonNullable<Pick<EntryStaticNormalized[string], 'import'>>> & {
-        plauditMetadata: M;
+        plauditMetadata: M & MinimumViableMetadata;
     };
 };
 export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<BlockEntrypointInfo>;

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

@@ -47,7 +47,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             entrypointName: parsedEntrypoint.name,
             handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
-            dest
+            dest,
+            absoluteSrc: ep
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -198,7 +199,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {
@@ -250,14 +251,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         }
         if (!processingModules) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
+            const absoluteSrc = node_path_1.default.join(srcRoot, "wpml-config.xml");
             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: { purpose: "wpml-config-xml", dest } };
+                await promises_1.default.access(absoluteSrc);
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
             }
             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: { purpose: "wpml-config-xml", dest } };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
                 }
             }
         }

package/build/wordpress-scripts-wrapper.js

@@ -16,7 +16,7 @@ const ExtensionsConfigFileGeneratorPluginV1_1 = require("./plugins/ExtensionsCon
 const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
 const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
 const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
-const PlainEntrypointsStyleBlockJSONPlugin_1 = require("./plugins/PlainEntrypointsStyleBlockJSONPlugin");
+const EnhancedBlockJSONPlugin_1 = require("./plugins/EnhancedBlockJSONPlugin");
 const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
 const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
 const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
@@ -479,7 +479,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 if (!srcIsDirectory) {
                     continue;
                 }
-                plugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest, removeEmptyScriptsPlugin, contextPath, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
+                plugin = new EnhancedBlockJSONPlugin_1.EnhancedBlockJSONPlugin(config, dest, removeEmptyScriptsPlugin, contextPath, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
                 plugins.push(plugin);
                 if (config.processTranslationConfigs && !processingModules) {
                     plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination, plugin));
@@ -494,8 +494,8 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                     for await (const dirent of await promises_1.default.opendir(srcRoot)) {
                         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: { dest } }]);
+                                const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
+                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(absoluteSrc, node_path_1.default.extname(absoluteSrc))), { import: [absoluteSrc], plauditMetadata: { dest, absoluteSrc } }]);
                             }
                         }
                     }
@@ -507,9 +507,9 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 plugins.push(plugin);
             }
             else if (sourceType === "plain" /* SourceType.plain */) {
+                const absoluteSrc = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
                 if (!srcIsDirectory) {
-                    const primarySrcRoot = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
-                    if (!scriptExtension.test(primarySrcRoot) && !shared_1.styleExtension.test(primarySrcRoot)) {
+                    if (!scriptExtension.test(absoluteSrc) && !shared_1.styleExtension.test(absoluteSrc)) {
                         continue;
                     }
                 }
@@ -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: { purpose: "plain-entrypoint", dest } } });
+                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } });
                     plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, contextPath, 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, contextPath, () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest } } }));
+                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, contextPath, () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } }));
                 }
                 plugins.push(plugin);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.75.0",
+  "version": "2.76.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -33,7 +33,7 @@
     "webpack-bundle-analyzer": "^4.10.2"
   },
   "dependencies": {
-    "@plaudit/php-writer": "^1.3.1",
+    "@plaudit/php-writer": "^1.3.2",
     "@plaudit/postcss-color-function": "^5.0.0",
     "@plaudit/postcss-legacy-shorthand": "^1.0.0",
     "@plaudit/postcss-silent-extend": "^3.0.0",