@plaudit/webpack-extensions 2.74.0 → 2.76.0

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/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/PlainEntrypointsStyleBlockJSONPlugin.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";
@@ -18,7 +18,7 @@ export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhas
     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

@@ -24,7 +24,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractBiPhasicGroupAndEntry
         this.dest = dest;
         this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
     }
-    async processAssets(compilation, rawAssetData) {
+    async processAssets(compilation, parsedAssetJsonProvider) {
         const applicableBlockJsonFiles = {};
         const blockJsonOriginToOutputMapping = {};
         const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
@@ -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;

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,7 +47,7 @@ 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;
                 }

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 }];
@@ -121,7 +122,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
     return async () => {
         const loadingEntrypoints = [];
         for await (const dirent of await promises_1.default.opendir(srcRoot)) {
-            if (!dirent.isDirectory()) {
+            if (!dirent.isDirectory() || dirent.name.startsWith("~")) {
                 continue;
             }
             const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
@@ -155,10 +156,9 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         });
                     }))).filter(pe => pe !== undefined);
                     const entrypointNamesWithEffectiveDuplicates = presentEntrypoints
-                        .map(entry => entry.entrypointName)
-                        .reduce((a, dest) => {
+                        .reduce((a, entry) => {
                         // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
-                        a[dest] = (a[dest] !== undefined);
+                        a[entry.entrypointName] = (a[entry.entrypointName] !== undefined);
                         return a;
                     }, {});
                     const handlePrefix = blockJson['name']?.toString() ?? `__UNKNOWN_PREFIX__/${dirent.name}`;
@@ -199,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) {
@@ -251,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

@@ -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.74.0",
+  "version": "2.76.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -20,7 +20,7 @@
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.80.0",
+    "@plaudit/gutenberg-api-extensions": "^2.80.1",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
     "@types/node": "^24.10.1",
     "@types/postcss-functions": "^4.0.4",
@@ -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",