npm - @plaudit/webpack-extensions - Versions diffs - 2.63.0 → 2.63.2 - Mend

@plaudit/webpack-extensions 2.63.0 → 2.63.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.d.ts ADDED Viewed

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

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.js ADDED Viewed

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMultiPhaseLibraryAndEntryPlugin = void 0;
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const webpack_1 = require("webpack");
+class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+    context;
+    entry;
+    entryMetadataRecord = {};
+    constructor(libraryType, semaphores, context, entry) {
+        super(libraryType, semaphores);
+        this.context = context;
+        this.entry = entry;
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        compiler.hooks.compilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
+            const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
+            compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
+        });
+        compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
+            const entry = await this.entry();
+            const promises = [];
+            for (const [name, { plauditMetadata, ...desc }] of Object.entries(entry)) {
+                const options = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, name, desc);
+                this.entryMetadataRecord[name] = plauditMetadata;
+                for (const entry of desc.import) {
+                    promises.push(new Promise((resolve, reject) => {
+                        compilation.addEntry(this.context, webpack_1.EntryPlugin.createDependency(entry, options), options, err => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve();
+                        });
+                    }));
+                }
+            }
+            await Promise.all(promises);
+        });
+    }
+    getRelevantEntrypoints(compilation) {
+        return compilation.entrypoints.values()
+            .map(entrypoint => {
+            const name = entrypoint.name;
+            if (!name) {
+                return undefined;
+            }
+            const metadata = this.entryMetadataRecord[name];
+            if (metadata === undefined) {
+                return undefined;
+            }
+            const srcPath = entrypoint.origins[0]?.request;
+            if (!srcPath) {
+                return undefined;
+            }
+            return { entrypoint, srcPath, metadata };
+        })
+            .filter(item => item !== undefined)
+            .toArray();
+    }
+}
+exports.AbstractMultiPhaseLibraryAndEntryPlugin = AbstractMultiPhaseLibraryAndEntryPlugin;

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts CHANGED Viewed

@@ -11,10 +11,4 @@ export declare abstract class AbstractMultiPhaseLibraryPlugin implements Webpack
     apply(compiler: Compiler): void;
     protected resetSemaphores(): void;
     protected abstract attachSecondPhase(compilation: Compilation): void;
-    protected getRelevantEntrypoints(compilation: Compilation): {
-        entrypoint: import("webpack").Entrypoint;
-        entrypointChunk: import("webpack").Chunk;
-        entrypointLibrary: import("webpack").LibraryOptions;
-        srcPath: string;
-    }[];
 }

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js CHANGED Viewed

@@ -27,79 +27,11 @@ class AbstractMultiPhaseLibraryPlugin {
                 }
             });
         });
-        // compiler.hooks.compilation.tap(
-        // 	this.constructor.name,
-        // 	(compilation, { normalModuleFactory }) => {
-        // 		const dummyEntry = EntryPlugin.createDependency("", "");
-        // 		compilation.dependencyFactories.set(
-        // 			dummyEntry.constructor as any,
-        // 			normalModuleFactory
-        // 		);
-        // 	}
-        // );
-        //
-        // compiler.hooks.make.tapPromise(this.constructor.name, (compilation) =>
-        // 	Promise.resolve(this.entry())
-        // 		.then((entry) => {
-        // 			const promises = [];
-        // 			for (const name of Object.keys(entry)) {
-        // 				const desc = entry[name];
-        // 				const options = EntryOptionPlugin.entryDescriptionToOptions(
-        // 					compiler,
-        // 					name,
-        // 					desc
-        // 				);
-        // 				for (const entry of /** @type {NonNullable<EntryDescriptionNormalized["import"]>} */ (
-        // 					desc.import
-        // 				)) {
-        // 					promises.push(
-        // 						new Promise(
-        // 							/**
-        // 							 * @param {(value?: undefined) => void} resolve resolve
-        // 							 * @param {(reason?: Error) => void} reject reject
-        // 							 */
-        // 							(resolve, reject) => {
-        // 								compilation.addEntry(
-        // 									this.context,
-        // 									EntryPlugin.createDependency(entry, options),
-        // 									options,
-        // 									(err) => {
-        // 										if (err) return reject(err);
-        // 										resolve();
-        // 									}
-        // 								);
-        // 							}
-        // 						)
-        // 					);
-        // 				}
-        // 			}
-        // 			return Promise.all(promises);
-        // 		})
-        // 		.then(() => {})
-        // );
     }
-    // protected abstract generateEntries(compiler: Compiler, context: string, entry: EntryStaticNormalized): void;
     resetSemaphores() {
         for (const semaphore of this.semaphores) {
             semaphore.reset(this.id);
         }
     }
-    getRelevantEntrypoints(compilation) {
-        return compilation.entrypoints.values()
-            .map(entrypoint => {
-            const entrypointChunk = entrypoint.getEntrypointChunk();
-            const entrypointLibrary = entrypointChunk.getEntryOptions()?.library;
-            if (entrypointLibrary?.type !== this.libraryType) {
-                return undefined;
-            }
-            const srcPath = entrypoint.origins[0]?.request;
-            if (!srcPath) {
-                return undefined;
-            }
-            return { entrypoint, entrypointChunk, entrypointLibrary, srcPath };
-        })
-            .filter(item => item !== undefined)
-            .toArray();
-    }
 }
 exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts CHANGED Viewed

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js CHANGED Viewed

@@ -6,20 +6,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPlugin = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 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");
-class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
     config;
     extensionsPath;
     dest;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ libraryType: "", assets: [], setupFiles: [] }, "Extensions");
     static perLibraryTypeSetupFilePaths = {};
-    constructor(config, extensionsPath, dest) {
-        super(`extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    constructor(config, extensionsPath, dest, context, entry) {
+        super(`extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.config = config;
         this.extensionsPath = extensionsPath;
         this.dest = dest;
@@ -69,8 +69,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                     }
                     const relevantAssetData = {};
                     const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
-                    for (const { entrypointChunk, srcPath } of relevantEntrypoints) {
-                        const fileWithAssetData = entrypointChunk.files.values().find(file => assetDataSource[file]);
+                    for (const { entrypoint, srcPath } of relevantEntrypoints) {
+                        const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => assetDataSource[file]);
                         if (!fileWithAssetData) {
                             compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
                             continue;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts CHANGED Viewed

@@ -1,14 +1,14 @@
-import { UsageLocations } from "../shared";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { UnpackedBlockEntrypointInfo, UsageLocations } from "../shared";
+import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
 import { Compilation, type Compiler } from "webpack";
-export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin {
+export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
     private readonly buildRoot;
     private readonly outputDir;
     private readonly usageLocations;
     private readonly handlePrefix;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean);
+    constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string, useUnifiedLoader: boolean, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
     apply(compiler: Compiler): void;
     private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js CHANGED Viewed

@@ -8,18 +8,18 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
     buildRoot;
     outputDir;
     usageLocations;
     handlePrefix;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader) {
-        super("plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader, context, entry) {
+        super("plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
         this.usageLocations = usageLocations;
@@ -48,11 +48,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
                     }
                     const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
                     const myAssetHandles = [];
-                    for (const entrypoint of compilation.entrypoints.values()) {
-                        const srcPath = entrypoint.origins.map(origin => origin.request)[0];
-                        if (!srcPath) {
-                            continue;
-                        }
+                    for (const { entrypoint, srcPath } of this.getRelevantEntrypoints(compilation)) {
                         const entrypointChunk = entrypoint.getEntrypointChunk();
                         const assetData = entrypointChunk.files.values()
                             .map(file => assetDataSource[file]).find(v => v !== undefined);

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts CHANGED Viewed

@@ -1,13 +1,14 @@
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
+import { UnpackedBlockEntrypointInfo } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlugin {
+export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin<UnpackedBlockEntrypointInfo | string> {
     private readonly config;
     private readonly blocksDest;
     private readonly webpackRemoveEmptyScriptsPlugin;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
     apply(compiler: Compiler): void;
     private emitBlockLoaderFile;
     private transformBlocks;

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js CHANGED Viewed

@@ -7,20 +7,20 @@ exports.PlainEntrypointsStyleBlockJSONPlugin = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractMultiPhaseLibraryAndEntryPlugin_1 = require("./AbstractMultiPhaseLibraryAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 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 AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
     config;
     blocksDest;
     webpackRemoveEmptyScriptsPlugin;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ collatableWorkableBlockInfo: {}, blocksDest: "", emittingWpmlXml: false }, "Block JSON v3");
-    constructor(config, blocksDest, webpackRemoveEmptyScriptsPlugin) {
-        super(`block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    constructor(config, blocksDest, webpackRemoveEmptyScriptsPlugin, context, entry) {
+        super(`block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.config = config;
         this.blocksDest = blocksDest;
         this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
@@ -46,23 +46,18 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
                         return;
                     }
                     const applicableBlockJsonFiles = {};
-                    compilation.modules.values()
-                        .filter(mod => mod.type === 'json')
-                        .flatMap(mod => compilation.chunkGraph.getModuleChunks(mod))
-                        .filter(chunk => {
-                        const entryOptions = chunk.getEntryOptions();
-                        return entryOptions?.library?.type === this.libraryType && entryOptions.library.name === "block-json-inclusion-assurance";
-                    })
-                        .flatMap(chunk => chunk.files.values().toArray())
-                        .forEach(danglingBlockJsFile => {
-                        compilation.deleteAsset(danglingBlockJsFile);
-                    });
-                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
                     const blockJsonOriginToOutputMapping = {};
-                    for (const { entrypoint, entrypointChunk, entrypointLibrary, srcPath } of relevantEntrypoints) {
-                        if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || entrypointLibrary.name !== "block-json-inclusion-assurance") {
+                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+                    for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
+                        if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || metadata !== "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();
                         if (asset) {
                             //TODO: Can we guarantee that entrypoint.name is always non-null?
@@ -79,16 +74,13 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
                             blockJsonOriginToOutputMapping[srcPath] = epBlockJson;
                         }
                     }
-                    for (const { entrypoint, entrypointChunk, entrypointLibrary, srcPath } of relevantEntrypoints) {
-                        if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" && entrypointLibrary.name === "block-json-inclusion-assurance") {
-                            continue;
-                        }
-                        const blockEntrypointInfo = (0, shared_1.unpackSmuggledBlockEntrypointInfo)(entrypointLibrary);
-                        if (!blockEntrypointInfo) {
+                    for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
+                        if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || typeof metadata === 'string') {
                             continue;
                         }
+                        const entrypointChunk = entrypoint.getEntrypointChunk();
                         const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => node_path_1.default.basename(auxFile) === "block.json")
-                            ?? blockJsonOriginToOutputMapping[blockEntrypointInfo.blockJsonOrigin];
+                            ?? 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 => assetDataSource[file])
@@ -103,14 +95,14 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
                                 .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
                                 .filter((item) => item[1] !== '')
                                 .map(([file, assetType]) => {
-                                const wasOriginallyAStyleField = (0, shared_1.isStyleField)(blockEntrypointInfo.entrypointField);
+                                const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
                                 if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
                                     return {
-                                        ...blockEntrypointInfo, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
-                                        entrypointField: (0, shared_1.convertEntrypointFieldForAssetType)(blockEntrypointInfo.entrypointField, assetType)
+                                        ...metadata, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
+                                        entrypointField: (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType)
                                     };
                                 }
-                                return ({ ...blockEntrypointInfo, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
+                                return ({ ...metadata, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
                             });
                             if (applicableBlockJsonFiles[epBlockJson]) {
                                 applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);

package/build/plugins/SpecialAssetHandlingPlugin.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { Compilation, type Compiler } from "webpack";
 import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { Compilation, type Compiler } from "webpack";
 export declare class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly config;
     private static readonly semaphore;

package/build/plugins/SpecialAssetHandlingPlugin.js CHANGED Viewed

@@ -8,9 +8,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");

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

@@ -1,5 +1,6 @@
-import { EntrypointFields, PlauditWordpressWebpackConfig, VerifiedAdvancedOutputConfig } from "../shared";
-import type { Compiler, Configuration, EntryObject, WebpackPluginInstance } from "webpack";
+import type { EntryProvider } from "../plugins/AbstractMultiPhaseLibraryAndEntryPlugin";
+import { EntrypointFields, PlauditWordpressWebpackConfig, UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
+import type { Compiler, Configuration, DynamicEntryPlugin, EntryObject, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
     variablesFilePath?: string;
@@ -18,5 +19,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 declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig, libraryType: string | undefined): () => Promise<EntryObject>;
-export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;
+export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<UnpackedBlockEntrypointInfo | string>;
+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 commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: (() => Promise<EntryObject> | EntryObject) | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;

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

@@ -48,31 +48,30 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name)
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
-            { import: ep, library: args.libraryType ? { type: args.libraryType, name: (0, shared_1.packBlockEntrypointInfoForSmuggling)(fakeEntrypointInfo) } : undefined }];
+            { import: [ep], plauditMetadata: fakeEntrypointInfo }];
     });
 }
-function parseEntrypointsJSON(dir, dest, supportedExtensions, args) {
+function parseEntrypointsJSON(dir, dest, supportedExtensions) {
     const entrypointJsonOrigin = node_path_1.default.join(dir, 'entrypoints.json');
     const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(entrypointJsonOrigin, 'utf8'));
     if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin, ...args });
+        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin });
     }
     else {
-        return Object.entries(entrypointsJSON).map(([name, config]) => {
-            if (typeof config === 'string') {
-                return [name, joinPossiblyAbsolutePaths(dir, config)];
-            }
-            else if (Array.isArray(config)) {
-                return [name, config.map(c => joinPossiblyAbsolutePaths(dir, c))];
+        return Object.entries(entrypointsJSON).flatMap(([name, config]) => {
+            if (Array.isArray(config)) {
+                return config.flatMap(c => mapToRealEntrypoints(c, dir, supportedExtensions, { dest, entrypointJsonOrigin }));
             }
             else {
+                return [[name, config]];
+                /* TODO: Fix compat with entrypoints.json in object mode
                 if (typeof config.import === 'string') {
                     config.import = joinPossiblyAbsolutePaths(dir, config.import);
-                }
-                else {
+                } else {
                     config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
                 }
                 return [name, config];
+                */
             }
         });
     }
@@ -115,7 +114,7 @@ function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, s
     }
     entry[potentialKey] = entrypoint[1];
 }
-function resolveEntryFromDirectory(commonConfig, srcRoot, dest, libraryType) {
+function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
     const { entrypointFields, processingModules, scriptExtension } = commonConfig;
     return async () => {
         const loadingEntrypoints = [];
@@ -195,12 +194,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest, libraryType) {
                         return [
                             resolvedBlockEntrypoint.entrypointName,
                             {
-                                import: resolvedBlockEntrypoint.absoluteSrc,
-                                library: { name: (0, shared_1.packBlockEntrypointInfoForSmuggling)(resolvedBlockEntrypoint), type: `block-json-${dest.destination}` }
+                                import: [resolvedBlockEntrypoint.absoluteSrc],
+                                plauditMetadata: resolvedBlockEntrypoint
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: blockJsonOrigin, library: { name: "block-json-inclusion-assurance", type: `block-json-${dest.destination}` } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: "block-json-inclusion-assurance" }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {
@@ -208,15 +207,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest, libraryType) {
                         const packageJsonOrigin = node_path_1.default.join(dir, 'package.json');
                         const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, libraryType, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                         if (!processingModules && packageJson['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, libraryType, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep), { libraryType }));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.
@@ -254,12 +253,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest, libraryType) {
             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], library: { type: `block-json-${dest.destination}` } };
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: "wpml-config-xml" };
             }
             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, library: { type: `block-json-${dest.destination}` } };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: "wpml-config-xml" };
                 }
             }
         }
@@ -348,7 +347,8 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             path: outPath,
             chunkFilename: 'webpack-chunks/[id].js',
             publicPath: publicPath,
-            library: outputLibrary
+            library: outputLibrary,
+            clean: false
         },
         optimization: {
             ...webpackConfig.optimization,
@@ -388,7 +388,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
                 delete require.cache[require.resolve(variablesFilePath)];
                 updateCurrentVariables(require(variablesFilePath));
             }
-            return entry();
+            return typeof entry === 'function' ? entry() : entry;
         },
         performance: {
             ...webpackConfig.performance,

package/build/wordpress-scripts-wrapper.js CHANGED Viewed

@@ -484,47 +484,63 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
 }
 function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
     const { processingModules } = commonConfig;
-    const blockJSONManagingPlugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, plugins.find(p => p instanceof webpack_remove_empty_scripts_1.default));
+    const blockJSONManagingPlugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, plugins.find(p => p instanceof webpack_remove_empty_scripts_1.default), webpackConfig.context ?? process.cwd(), (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest));
     plugins.push(blockJSONManagingPlugin);
     if (config.processTranslationConfigs && !processingModules) {
         plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination));
     }
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, blockJSONManagingPlugin.libraryType), plugins);
+    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, {}, plugins);
 }
 function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
-    const plugin = config.extensionsVersion > 1
-        ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest)
-        : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination);
-    plugins.push(plugin);
-    const entry = async () => {
-        const rawEntrypoints = [];
-        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, library: { type: plugin.libraryType } }]);
+    if (config.extensionsVersion > 1) {
+        const entry = async () => {
+            const rawEntrypoints = [];
+            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: "entrypoint-v2" }]);
+                    }
                 }
             }
-        }
-        return Object.fromEntries(rawEntrypoints);
-    };
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, entry, plugins);
+            return Object.fromEntries(rawEntrypoints);
+        };
+        plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest, webpackConfig.context ?? process.cwd(), entry));
+        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, {}, plugins);
+    }
+    else {
+        const plugin = new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination);
+        plugins.push(plugin);
+        const entry = async () => {
+            const rawEntrypoints = [];
+            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))), file]);
+                    }
+                }
+            }
+            return Object.fromEntries(rawEntrypoints);
+        };
+        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, entry, plugins);
+    }
 }
 function makePlainV1WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
     const baseDest = stripExtension(dest.destination);
     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, undefined)
+        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
         : () => ({ [baseDest]: srcRoot });
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins);
 }
 function makePlainV2WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
-    const requester = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, dest.locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader);
-    plugins.push(requester);
     const baseDest = stripExtension(dest.destination);
     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, requester.libraryType)
-        : () => ({ [baseDest]: srcRoot });
-    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins);
+        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
+        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } });
+    const requester = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, dest.locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
+    plugins.push(requester);
+    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, {}, plugins);
 }
 function stripExtension(filepath) {
     return node_path_1.default.join(node_path_1.default.dirname(filepath), node_path_1.default.basename(filepath, node_path_1.default.extname(filepath)));

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.63.0",
+  "version": "2.63.2",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"