@plaudit/webpack-extensions 2.63.1 → 2.64.0

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -18,87 +18,14 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
     handlePrefix;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader, context, entry) {
-        super("plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
+    constructor(config, buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader, context, entry) {
+        super(config, "plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
         this.usageLocations = usageLocations;
         this.handlePrefix = handlePrefix;
         this.useUnifiedLoader = useUnifiedLoader;
     }
-    apply(compiler) {
-        super.apply(compiler);
-        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) => {
-                if (!("assets.json" in assets)) {
-                    return;
-                }
-                try {
-                    const rawAssetDataSource = assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const assetDataSource = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
-                        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
-                    const myAssetHandles = [];
-                    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);
-                        if (!assetData) {
-                            continue;
-                        }
-                        const handles = [];
-                        const entrypointChunkIsScript = isScriptRegex.test(srcPath);
-                        const chunkFiles = entrypoint.chunks.flatMap(chunk => {
-                            return [...chunk.files].filter(file => entrypointChunkIsScript || !isScriptRegex.test(file))
-                                .map(file => [file, chunk === entrypointChunk]);
-                        });
-                        if (chunkFiles.length === 1) {
-                            chunkFiles[0][1] = true;
-                        }
-                        for (const [file, useHandleName] of chunkFiles) {
-                            const extension = node_path_1.default.extname(file).toLowerCase();
-                            const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
-                            const isScript = type !== 'style';
-                            const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
-                            const rest = isScript && this.usageLocations.registerScriptArgs !== undefined
-                                ? [dependencies, assetData.version, this.usageLocations.registerScriptArgs] : [dependencies, assetData.version];
-                            const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
-                            handles.push({
-                                src: destPath, rest, type,
-                                locations: this.usageLocations,
-                                handleName: useHandleName ? this.usageLocations.handle : undefined,
-                            });
-                        }
-                        myAssetHandles.push({
-                            handles,
-                            handlePrefix: this.handlePrefix
-                        });
-                    }
-                    PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
-                        ? { group: this.libraryType, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
-                        : undefined);
-                }
-                catch (e) {
-                    PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    throw e;
-                }
-            });
-            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                compilation.deleteAsset("assets.json");
-            });
-        });
-    }
     generatePlainEntrypointsLoader(compilation, assets) {
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
         const handleLists = {
@@ -238,5 +165,48 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
             this.generatePlainEntrypointsLoader(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
         });
     }
+    processAssets(compilation, rawAssetData) {
+        const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
+        const myAssetHandles = [];
+        for (const { entrypoint, srcPath } of this.getRelevantEntrypoints(compilation)) {
+            const entrypointChunk = entrypoint.getEntrypointChunk();
+            const assetData = entrypointChunk.files.values()
+                .map(file => rawAssetData[file]).find(v => v !== undefined);
+            if (!assetData) {
+                continue;
+            }
+            const handles = [];
+            const entrypointChunkIsScript = isScriptRegex.test(srcPath);
+            const chunkFiles = entrypoint.chunks.flatMap(chunk => {
+                return [...chunk.files].filter(file => entrypointChunkIsScript || !isScriptRegex.test(file))
+                    .map(file => [file, chunk === entrypointChunk]);
+            });
+            if (chunkFiles.length === 1) {
+                chunkFiles[0][1] = true;
+            }
+            for (const [file, useHandleName] of chunkFiles) {
+                const extension = node_path_1.default.extname(file).toLowerCase();
+                const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
+                const isScript = type !== 'style';
+                const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
+                const rest = isScript && this.usageLocations.registerScriptArgs !== undefined
+                    ? [dependencies, assetData.version, this.usageLocations.registerScriptArgs] : [dependencies, assetData.version];
+                const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
+                handles.push({
+                    src: destPath, rest, type,
+                    locations: this.usageLocations,
+                    handleName: useHandleName ? this.usageLocations.handle : undefined,
+                });
+            }
+            myAssetHandles.push({
+                handles,
+                handlePrefix: this.handlePrefix
+            });
+        }
+        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
+        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
+            ? { group: this.libraryType, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
+            : undefined);
+    }
 }
 exports.PlainEntrypointsConfigFileGeneratorPlugin = PlainEntrypointsConfigFileGeneratorPlugin;

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts

@@ -1,15 +1,14 @@
 import { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
-import { UnpackedBlockEntrypointInfo } from "../shared";
+import { RawAssetData, UnpackedBlockEntrypointInfo } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { Compilation, type Compiler } from "webpack";
+import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 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, context: string, entry: EntryProvider<UnpackedBlockEntrypointInfo | string>);
-    apply(compiler: Compiler): void;
+    protected processAssets(compilation: Compilation, rawAssetData: RawAssetData): Promise<void>;
     private emitBlockLoaderFile;
     private transformBlocks;
     private static extractAssetSource;

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -15,121 +15,91 @@ const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 const promises_1 = __importDefault(require("node:fs/promises"));
 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, context, entry) {
-        super(`block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
-        this.config = config;
+        super(config, `block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.blocksDest = blocksDest;
         this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
     }
-    apply(compiler) {
-        super.apply(compiler);
-        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) => {
-                if (!("assets.json" in assets)) {
-                    return;
+    async processAssets(compilation, rawAssetData) {
+        const applicableBlockJsonFiles = {};
+        const blockJsonOriginToOutputMapping = {};
+        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);
                 }
-                try {
-                    const rawAssetDataSource = assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        PlainEntrypointsStyleBlockJSONPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const assetDataSource = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
-                        PlainEntrypointsStyleBlockJSONPlugin.semaphore.reject(this.id);
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    const applicableBlockJsonFiles = {};
-                    const blockJsonOriginToOutputMapping = {};
-                    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?
-                            const epBlockJson = entrypoint.name + ".json";
-                            if (!applicableBlockJsonFiles[epBlockJson]) {
-                                const blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
-                                    ?? await promises_1.default.readFile(srcPath, 'utf-8');
-                                if (!blockJsonText) {
-                                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${epBlockJson}`, srcPath));
-                                    continue;
-                                }
-                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: srcPath, workableBlockEntrypointsInfo: [], blockJsonText };
-                            }
-                            blockJsonOriginToOutputMapping[srcPath] = epBlockJson;
-                        }
+            }
+            const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypointChunk)][0]?.originalSource();
+            if (asset) {
+                //TODO: Can we guarantee that entrypoint.name is always non-null?
+                const epBlockJson = entrypoint.name + ".json";
+                if (!applicableBlockJsonFiles[epBlockJson]) {
+                    const blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
+                        ?? await promises_1.default.readFile(srcPath, 'utf-8');
+                    if (!blockJsonText) {
+                        compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${epBlockJson}`, srcPath));
+                        continue;
                     }
-                    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[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])
-                                .find(assetData => assetData !== undefined);
-                            if (!assetData) {
-                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
-                                continue;
-                            }
-                            const workableBlockEntrypointsInfo = entrypoint.getFiles()
-                                .map(file => this.stripOffBlocksDestPrefix(file))
-                                .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(node_path_1.default.join(this.blocksDest, file)))
-                                .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
-                                .filter((item) => item[1] !== '')
-                                .map(([file, assetType]) => {
-                                const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
-                                if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
-                                    return {
-                                        ...metadata, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
-                                        entrypointField: (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType)
-                                    };
-                                }
-                                return ({ ...metadata, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
-                            });
-                            if (applicableBlockJsonFiles[epBlockJson]) {
-                                applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
-                            }
-                            else {
-                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo };
-                            }
-                        }
+                    applicableBlockJsonFiles[epBlockJson] = { sourcePath: srcPath, workableBlockEntrypointsInfo: [], blockJsonText };
+                }
+                blockJsonOriginToOutputMapping[srcPath] = epBlockJson;
+            }
+        }
+        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[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);
+                if (!assetData) {
+                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                    continue;
+                }
+                const workableBlockEntrypointsInfo = entrypoint.getFiles()
+                    .map(file => this.stripOffBlocksDestPrefix(file))
+                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(node_path_1.default.join(this.blocksDest, file)))
+                    .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
+                    .filter((item) => item[1] !== '')
+                    .map(([file, assetType]) => {
+                    const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
+                    if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
+                        return {
+                            ...metadata, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
+                            entrypointField: (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType)
+                        };
                     }
-                    compilation.deleteAsset("assets.json");
-                    PlainEntrypointsStyleBlockJSONPlugin.semaphore.resolve(this.id, {
-                        collatableWorkableBlockInfo: applicableBlockJsonFiles, blocksDest: this.blocksDest,
-                        emittingWpmlXml: compilation.getAsset(node_path_1.default.join(this.blocksDest, "wpml-config.xml")) !== undefined
-                    });
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(applicableBlockJsonFiles).length ? {
-                        group: this.libraryType,
-                        requiresBaseURI: false,
-                        action: writer => writer.append(`require_once __DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + node_path_1.default.join(this.blocksDest, "blockdir-loader.php"))};`)
-                    } : undefined);
+                    return ({ ...metadata, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
+                });
+                if (applicableBlockJsonFiles[epBlockJson]) {
+                    applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
                 }
-                catch (e) {
-                    PlainEntrypointsStyleBlockJSONPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    throw e;
+                else {
+                    applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo };
                 }
-            });
+            }
+        }
+        PlainEntrypointsStyleBlockJSONPlugin.semaphore.resolve(this.id, {
+            collatableWorkableBlockInfo: applicableBlockJsonFiles, blocksDest: this.blocksDest,
+            emittingWpmlXml: compilation.getAsset(node_path_1.default.join(this.blocksDest, "wpml-config.xml")) !== undefined
         });
+        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(applicableBlockJsonFiles).length ? {
+            group: this.libraryType,
+            requiresBaseURI: false,
+            action: writer => writer.append(`require_once __DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + node_path_1.default.join(this.blocksDest, "blockdir-loader.php"))};`)
+        } : undefined);
     }
     emitBlockLoaderFile(compilation, blockData) {
         if (this.config.useUnifiedLoader) {

package/build/plugins/SpecialAssetHandlingPlugin.d.ts

@@ -2,7 +2,6 @@ import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-conf
 import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
 import { Compilation, type Compiler } from "webpack";
 export declare class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin {
-    private readonly config;
     private static readonly semaphore;
     private static validPathname?;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -12,12 +12,10 @@ const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPl
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
 class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
-    config;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");
     static validPathname = undefined;
     constructor(config) {
-        super("special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
-        this.config = config;
+        super(config, "special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
     }
     apply(compiler) {
         if (!this.config.useWebpackResourceFiltering) {
@@ -59,8 +57,7 @@ class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.Abstr
                         : undefined);
                 }
                 catch (e) {
-                    SpecialAssetHandlingPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
+                    this.rejectSemaphores();
                     throw e;
                 }
             });

package/build/plugins/UnifiedLoaderGenerator.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedLoaderGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const php_writer_1 = require("../utils/php-writer");
@@ -15,6 +19,30 @@ class UnifiedLoaderGenerator {
         this.id = Math.random().toString();
     }
     apply(compiler) {
+        compiler.hooks.compilation.tap(`${this.constructor.name}_Cleanup`, compilation => {
+            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                if (!this.config.useUnifiedLoader) {
+                    const rawAssetDataSource = compilation.assets["assets.json"]?.source();
+                    if (typeof rawAssetDataSource !== 'string') {
+                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
+                        return;
+                    }
+                    const rawAssetData = JSON.parse(rawAssetDataSource);
+                    if (!(0, shared_1.isRawAssetData)(rawAssetData)) {
+                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
+                        return;
+                    }
+                    for (const [file, assetData] of Object.entries(rawAssetData)) {
+                        const escapedDependencies = assetData.dependencies.map(php_writer_1.Expr.convertJsonToPHP).join(", ");
+                        const contents = `<?php return ['dependencies' => [${escapedDependencies}], 'version' => ${php_writer_1.Expr.convertJsonToPHP(assetData.version)}];\n`;
+                        const parsedPath = node_path_1.default.parse(file);
+                        const assetPHPFile = node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php";
+                        compilation.emitAsset(assetPHPFile, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                    }
+                }
+                compilation.deleteAsset("assets.json");
+            });
+        });
         if (!this.config.useUnifiedLoader) {
             return;
         }

package/build/plugins/WPMLConfigBuilder.d.ts

@@ -1,11 +1,13 @@
+import { AbstractMultiPhaseLibraryAndEntryPlugin } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private readonly destDir;
+    private readonly referencePlugin;
     private static jsdomInstance?;
     private static domParser?;
     private static xmlSerializer?;
     private readonly parsedDocumentsCache;
-    constructor(destDir: string);
+    constructor(destDir: string, referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
     private static getJSDOMInstance;
     private static getDOMParser;

package/build/plugins/WPMLConfigBuilder.js

@@ -12,26 +12,29 @@ const webpack_1 = require("webpack");
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 class WPMLConfigBuilderPlugin {
     destDir;
+    referencePlugin;
     static jsdomInstance;
     static domParser;
     static xmlSerializer;
     parsedDocumentsCache = new Map();
-    constructor(destDir) {
+    constructor(destDir, referencePlugin) {
         this.destDir = destDir;
+        this.referencePlugin = referencePlugin;
     }
     apply(compiler) {
-        //TODO: Filter by library here as well
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
             compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}__processXML`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL }, async (assets) => {
                 const entrypoint = compilation.entrypoints.get("wpml-config.xml");
                 if (!entrypoint) {
                     return;
                 }
+                const blockJsonFiles = this.referencePlugin.getRelevantEntrypoints(compilation)
+                    .map(ep => ep.srcPath)
+                    .filter(srcPath => srcPath.endsWith("block.json"));
                 const files = Promise.all([
                     Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("wpml-config.xml"))
                         .map(async (request) => this.loadWPMLConfigXML(request, compilation))),
-                    Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("block.json"))
-                        .map(async (request) => JSON.parse(await promises_1.default.readFile(request, 'utf8'))))
+                    Promise.all(blockJsonFiles.map(async (request) => JSON.parse(await promises_1.default.readFile(request, 'utf8'))))
                 ]);
                 const wpmlEmitPath = node_path_1.default.join(this.destDir, "wpml-config.xml");
                 for (const name of Object.keys(assets)) {

package/build/shared.d.ts

@@ -41,7 +41,7 @@ export type Externals = {
 };
 export type AdvancedOutputConfig = {
     destination?: string;
-    withLegacyBlocksIn?: string | undefined;
+    withLegacyBlocksIn?: string | undefined | false;
     additionalDependencies?: string[];
     directoryLayout?: SourceType;
     assumeGlobalizedPlauditLibraries?: boolean;
@@ -49,7 +49,8 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations | UsageLocations['handle'];
 };
-export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination' | 'locations'> & Required<Pick<AdvancedOutputConfig, 'destination'>> & {
+type OptionalCfgFields = 'directoryLayout' | 'externalize';
+export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     locations: UsageLocations;
 };
 export type PlauditWordpressWebpackConfig = {

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

@@ -1,6 +1,7 @@
-import type { EntryProvider } from "../plugins/AbstractMultiPhaseLibraryAndEntryPlugin";
+import type { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "../plugins/AbstractMultiPhaseLibraryAndEntryPlugin";
+import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDependencyInjectorPlugin";
 import { EntrypointFields, PlauditWordpressWebpackConfig, UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
-import type { Compiler, Configuration, DynamicEntryPlugin, EntryObject, WebpackPluginInstance } from "webpack";
+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'>> & {
     variablesFilePath?: string;
@@ -9,6 +10,7 @@ export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpre
 export type CommonPluginConfig = {
     plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
+    makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
 };
 export type CommonConfigProcessingResult = {
     entrypointFields: EntrypointFields;
@@ -27,4 +29,4 @@ export type ExtensibleEntryObject<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;
+export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, externalize: VerifiedAdvancedOutputConfig['externalize'], plugins: CommonPluginConfig['plugins']): Configuration;