npm - @plaudit/webpack-extensions - Versions diffs - 2.62.3 → 2.63.1 - Mend

@plaudit/webpack-extensions 2.62.3 → 2.63.1

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

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js CHANGED Viewed

@@ -6,22 +6,23 @@ 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 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 AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
-class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
+class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryAndEntryPlugin_1.AbstractMultiPhaseLibraryAndEntryPlugin {
     config;
     extensionsPath;
-    extensionsDest;
+    dest;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ libraryType: "", assets: [], setupFiles: [] }, "Extensions");
-    constructor(config, extensionsPath, extensionsDest) {
-        super(`extensions-v2-${extensionsDest}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    static perLibraryTypeSetupFilePaths = {};
+    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.extensionsDest = extensionsDest;
+        this.dest = dest;
     }
     apply(compiler) {
         super.apply(compiler);
@@ -30,16 +31,19 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                 compilation.contextDependencies.add(this.extensionsPath);
             }
             const emissionPromises = [];
-            for (const setupFilePath of await promises_1.default.readdir(this.extensionsPath)) {
+            for await (const { name: setupFilePath } of await promises_1.default.opendir(this.extensionsPath, { encoding: 'utf-8' })) {
                 if (setupFilePath.endsWith("-setup.php")) {
                     const setupFileSourcePath = node_path_1.default.join(this.extensionsPath, setupFilePath);
                     compilation.fileDependencies.add(setupFileSourcePath);
                     emissionPromises.push(promises_1.default.readFile(setupFileSourcePath).then(contents => {
-                        return compilation.emitAsset(node_path_1.default.join(this.extensionsDest, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                        compilation.emitAsset(node_path_1.default.join(this.dest.destination, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                        const blockSlug = /^(.+?)-setup.php$/i.exec(setupFilePath)?.[1];
+                        return [blockSlug, setupFilePath];
                     }));
                 }
             }
-            await Promise.all(emissionPromises);
+            ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] = (await Promise.all(emissionPromises))
+                .filter((item) => item[0] !== undefined).sort((a, b) => a[0].localeCompare(b[0]));
         });
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
             compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
@@ -49,15 +53,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                 try {
                     //TODO: It should be possible to use EntryPoints to determine the "original" file
                     //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
-                    const myCacheData = { libraryType: this.libraryType, assets: [], setupFiles: [] };
-                    //TODO: Load up the -setup.php files as "entrypoints" in the same way that we're loading up block.json files
-                    // That way, we'll be able to distinguish which ones go where
-                    for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
-                        const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
-                        if (blockSlug) {
-                            myCacheData.setupFiles.push([blockSlug, asset]);
-                        }
-                    }
+                    const myCacheData = { libraryType: this.libraryType, assets: [],
+                        setupFiles: ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] ?? [] };
                     const rawAssetDataSource = assets["assets.json"]?.source();
                     if (typeof rawAssetDataSource !== 'string') {
                         ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
@@ -72,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;
@@ -87,22 +84,40 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                         group: this.libraryType,
                         requiresBaseURI: true,
                         action: writer => {
-                            let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
-                            if (!finalExtensionsDest.startsWith("/")) {
-                                finalExtensionsDest = "/" + finalExtensionsDest;
+                            const generateLoader = (writer) => {
+                                let finalExtensionsDest = this.dest.destination.endsWith("/") ? this.dest.destination : this.dest.destination + "/";
+                                if (!finalExtensionsDest.startsWith("/")) {
+                                    finalExtensionsDest = "/" + finalExtensionsDest;
+                                }
+                                const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
+                                const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
+                                writer
+                                    .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
+                                    .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
+                                    .call("GutenbergUtils::loadExtensionsV2", [
+                                    new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
+                                    filePathPrefixVar, fileUriPrefixVar,
+                                    `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
+                                ]);
+                            };
+                            writer.use("Plaudit\\Common\\Lib\\GutenbergUtils");
+                            const potentialHandle = this.dest.locations?.handle;
+                            if (potentialHandle) {
+                                if (typeof potentialHandle === 'string') {
+                                    try {
+                                        //TODO: Generate a function
+                                        writer.function(potentialHandle, [], generateLoader, { returnType: 'void' });
+                                        return;
+                                    }
+                                    catch (e) {
+                                        compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for dynamically loading extensions", { cause: e }], this.extensionsPath));
+                                    }
+                                }
+                                else {
+                                    compilation.errors.push(new Error("The extensions directoryLayout's handle support is limited to static strings"));
+                                }
                             }
-                            const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
-                            const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
-                            writer
-                                .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                                .withScope(writer => writer
-                                .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                                .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
-                                .call("GutenbergUtils::loadExtensionsV2", [
-                                new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                                filePathPrefixVar, fileUriPrefixVar,
-                                `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
-                            ]));
+                            writer.withScope(generateLoader);
                         }
                     } : undefined);
                 }
@@ -126,8 +141,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
         for (const assetDataSource of combinedExtensionData.assets) {
             const normalizedAssetData = Object.entries(assetDataSource)
                 .map(entry => {
-                const assetPath = this.extensionsDest && entry[0].startsWith(this.extensionsDest + "/")
-                    ? entry[0].substring(this.extensionsDest.length + 1) : entry[0];
+                const assetPath = this.dest.destination && entry[0].startsWith(this.dest.destination + "/")
+                    ? entry[0].substring(this.dest.destination.length + 1) : entry[0];
                 return [assetPath, entry[1]];
             });
             for (const [assetPath, assetData] of normalizedAssetData) {
@@ -168,10 +183,7 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
             return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
         })
             .toSorted(([a], [b]) => a.localeCompare(b)));
-        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
-    }
-    stripExtensionsDest(item) {
-        return this.extensionsDest && item.startsWith(this.extensionsDest + "/") ? item.substring(this.extensionsDest.length + 1 /* we also need to drop the "/" */) : item;
+        compilation.emitAsset(node_path_1.default.join(this.dest.destination, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
     }
     attachSecondPhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_GenerateConfigFile`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {

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);
@@ -84,7 +80,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
                         }
                         myAssetHandles.push({
                             handles,
-                            usageLocations: this.usageLocations,
                             handlePrefix: this.handlePrefix
                         });
                     }
@@ -126,15 +121,15 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
             for (const { src, rest, locations, type, handleName } of handles) {
+                const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
-                if (handleName) {
-                    finalHandleName = handleName;
+                if (typeof handleName === 'string') {
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
                 }
                 else {
-                    const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                     const baseFinalHandleName = `${handlePrefix}.${(0, shared_1.kebabCase)(basename)}`;
                     const handleNameMap = usedHandleNames[type];
-                    finalHandleName = baseFinalHandleName;
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
                     for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                         finalHandleName = `${baseFinalHandleName}-${++count}`;
                     }

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);
@@ -255,7 +247,6 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
         return blockJson;
     }
     stripOffBlocksDestPrefix(file) {
-        file = node_path_1.default.normalize(file);
         return this.blocksDest && file.startsWith(this.blocksDest + "/") ? file.substring(this.blocksDest.length + 1 /* we also need to drop the "/" */) : file;
     }
     static hashThingForAsset(thing) {

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");