@plaudit/webpack-extensions 2.61.2 → 2.62.1

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -0,0 +1,434 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 {
+    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]);
+        this.config = config;
+        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;
+                }
+                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 = {};
+                    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 = 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();
+                    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") {
+                            continue;
+                        }
+                        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;
+                        }
+                    }
+                    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) {
+                            continue;
+                        }
+                        const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => node_path_1.default.basename(auxFile) === "block.json")
+                            ?? blockJsonOriginToOutputMapping[blockEntrypointInfo.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)(blockEntrypointInfo.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)
+                                    };
+                                }
+                                return ({ ...blockEntrypointInfo, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
+                            });
+                            if (applicableBlockJsonFiles[epBlockJson]) {
+                                applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
+                            }
+                            else {
+                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo: workableBlockEntrypointsInfo };
+                            }
+                        }
+                    }
+                    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);
+                }
+                catch (e) {
+                    PlainEntrypointsStyleBlockJSONPlugin.semaphore.reject(this.id);
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
+                    throw e;
+                }
+            });
+        });
+    }
+    emitBlockLoaderFile(compilation, blockData) {
+        if (this.config.useUnifiedLoader) {
+            const metadata = blockData['__metadata'];
+            delete blockData['__metadata'];
+            new php_writer_1.PHPWriter()
+                .action("init", writer => {
+                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [php_writer_1.Constants.__DIR__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
+                    php_writer_1.Constants.__FILE__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
+            }, { accountForAlreadyDoing: true })
+                .emitAsset(compilation, node_path_1.default.join(this.blocksDest, "blockdir-loader.php"));
+        }
+        else {
+            compilation.emitAsset(node_path_1.default.join(this.blocksDest, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockData, true)));
+        }
+    }
+    transformBlocks(compilation, collatedWorkableBlockInfo, emittingWpmlXml) {
+        const handleData = Object.values(collatedWorkableBlockInfo)
+            .flatMap(bi => bi.workableBlockEntrypointsInfo)
+            .sort((a, b) => a.handle.localeCompare(b.handle) || a.entrypointField.localeCompare(b.entrypointField));
+        const blockData = {};
+        for (const [blockJsonAssetName, { sourcePath: blockJsonSourcePath, workableBlockEntrypointsInfo, blockJsonText }] of Object.entries(collatedWorkableBlockInfo)) {
+            if (!blockJsonSourcePath) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have a source path`, blockJsonAssetName));
+                continue;
+            }
+            if (!blockJsonText) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have recorded text`, blockJsonAssetName));
+                continue;
+            }
+            const sourceDir = node_path_1.default.dirname(blockJsonSourcePath);
+            const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(blockJsonAssetName));
+            const blockJson = JSON.parse(blockJsonText);
+            const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
+            PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
+            PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
+            PlainEntrypointsStyleBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
+            const hashForVersion = PlainEntrypointsStyleBlockJSONPlugin
+                .hashThingForAsset([blockJsonText, ...workableBlockEntrypointsInfo.map(bi => bi.hash)].join("~"));
+            if (blockJson["version"]) {
+                blockJson["version"] = `${blockJson["version"]}-${hashForVersion}`;
+            }
+            else {
+                blockJson["version"] = hashForVersion;
+            }
+            const blockDirName = node_path_1.default.dirname(node_path_1.default.relative(this.blocksDest, blockJsonAssetName));
+            blockData[blockDirName] = PlainEntrypointsStyleBlockJSONPlugin
+                .doFileOrHandleReplacements(compilation, Object.fromEntries(Object.entries(blockJson).filter(([k]) => k !== '$schema')), workableBlockEntrypointsInfo, epi => epi.handle);
+            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(PlainEntrypointsStyleBlockJSONPlugin
+                .doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, epi => "file:./" + node_path_1.default.relative(blockDirName, epi.outputPath)), undefined, "  ")));
+        }
+        return {
+            __metadata: {
+                version: 3,
+                "wpml-config": emittingWpmlXml,
+                scriptHandles: Object.fromEntries(PlainEntrypointsStyleBlockJSONPlugin
+                    .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && !(0, shared_1.isScriptModuleField)(hd.entrypointField)))),
+                scriptModuleHandles: Object.fromEntries(PlainEntrypointsStyleBlockJSONPlugin
+                    .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && (0, shared_1.isScriptModuleField)(hd.entrypointField)))),
+                styleHandles: Object.fromEntries(handleData.filter(hd => (0, shared_1.isStyleField)(hd.entrypointField))
+                    .map(hd => [hd.handle, { src: hd.outputPath, rest: [hd.assetData.dependencies, hd.assetData.version] }]))
+            },
+            ...Object.fromEntries(Object.entries(blockData).sort((a, b) => a[0].localeCompare(b[0])))
+        };
+    }
+    static extractAssetSource(compilation, assetName) {
+        const assetSource = compilation.getAsset(assetName)?.source.source();
+        return typeof assetSource === 'string' ? assetSource : assetSource?.toString('utf-8');
+    }
+    static convertToScriptHandles(handleData) {
+        return handleData.map(hd => {
+            return [hd.handle, { src: hd.outputPath, rest: hd.entrypointField.startsWith("editor")
+                        ? [hd.assetData.dependencies, hd.assetData.version] : [hd.assetData.dependencies, hd.assetData.version, { strategy: "defer" }] }];
+        });
+    }
+    static doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, getter) {
+        for (const entrypointInfo of workableBlockEntrypointsInfo) {
+            const fieldValue = blockJson[entrypointInfo.entrypointField];
+            if (!fieldValue) {
+                blockJson[entrypointInfo.entrypointField] = getter(entrypointInfo);
+            }
+            else if (entrypointInfo.originalValue) {
+                if (entrypointInfo.originalValue === fieldValue) {
+                    blockJson[entrypointInfo.entrypointField] = getter(entrypointInfo);
+                }
+                else if (typeof fieldValue === 'string') {
+                    blockJson[entrypointInfo.entrypointField] = [fieldValue, getter(entrypointInfo)];
+                }
+                else if (Array.isArray(fieldValue)) {
+                    const replacementPos = fieldValue.indexOf(entrypointInfo.originalValue);
+                    if (replacementPos === -1) {
+                        compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`Unable to find ${entrypointInfo.originalValue} in ${entrypointInfo.entrypointField}`, entrypointInfo.blockJsonOrigin));
+                        blockJson[entrypointInfo.entrypointField] = fieldValue.concat(getter(entrypointInfo));
+                    }
+                    else {
+                        blockJson[entrypointInfo.entrypointField] = fieldValue.toSpliced(replacementPos, 1, getter(entrypointInfo));
+                    }
+                }
+                else {
+                    blockJson[entrypointInfo.entrypointField] = getter(entrypointInfo);
+                }
+            }
+            else {
+                if (typeof fieldValue === 'string') {
+                    blockJson[entrypointInfo.entrypointField] = [fieldValue, getter(entrypointInfo)];
+                }
+                else if (Array.isArray(fieldValue)) {
+                    blockJson[entrypointInfo.entrypointField] = fieldValue.concat(getter(entrypointInfo));
+                }
+                else {
+                    blockJson[entrypointInfo.entrypointField] = getter(entrypointInfo);
+                }
+            }
+        }
+        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) {
+        return node_crypto_1.default.createHash('md5').update(thing).digest("hex").substring(0, 20).toLowerCase();
+    }
+    static stripFilePrefix(file) {
+        return file.startsWith("file:./") ? file.substring(7) : file;
+    }
+    static findCommonAncestor(...paths) {
+        return paths.map(p => node_path_1.default.normalize(p).split(node_path_1.default.sep)).reduce((prior, current) => {
+            for (let i = 0, limit = Math.min(prior.length, current.length); i < limit; i++) {
+                if (prior[i] !== current[i]) {
+                    return prior.slice(0, i);
+                }
+            }
+            return current.length < prior.length ? current : prior;
+        });
+    }
+    static findRelativeRouteBetween(path1, path2) {
+        const commonAncestor = PlainEntrypointsStyleBlockJSONPlugin.findCommonAncestor(path1, path2);
+        const route = Array(path1.split(node_path_1.default.sep).length - commonAncestor.length).fill("..");
+        route.push(node_path_1.default.relative(commonAncestor.join(node_path_1.default.sep), path2));
+        return route.join(node_path_1.default.sep);
+    }
+    static remapReferencedPHPFilesOnKey(blockJson, key, pathsNeedRemapping, sourceDir, outputDir, compilation, inPlaudit) {
+        const rawValue = (inPlaudit ? blockJson["plaudit"] : blockJson)?.[key];
+        let rawFiles;
+        let deleteOnEmpty = true;
+        if (typeof rawValue === 'string') {
+            rawFiles = [rawValue];
+        }
+        else if (Array.isArray(rawValue) && rawValue.length > 0) {
+            const fileReferences = rawValue.filter((value) => typeof value === 'string' && value.startsWith("file:./"));
+            if (fileReferences.length === rawValue.length) {
+                rawFiles = fileReferences;
+            }
+            else {
+                if (fileReferences.length !== 0) {
+                    compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`Encountered a block with a mixture of file-reference and non-file-reference elements in the "${inPlaudit ? 'plaudit.' : ''}${key}" property`, node_path_1.default.join(sourceDir, 'block.json')));
+                    rawFiles = fileReferences;
+                }
+                else {
+                    rawFiles = [`${key}.php`]; // We want to emit an error if both an appropriately-named file AND an incompatible value exist, so we still need to do the check
+                }
+                deleteOnEmpty = false;
+            }
+        }
+        else {
+            if (rawValue && (!Array.isArray(rawValue) || rawValue.length === 0)) {
+                deleteOnEmpty = false;
+            }
+            rawFiles = [`${key}.php`];
+        }
+        const mappedFiles = pathsNeedRemapping
+            ? rawFiles
+                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p))))
+                .filter(p => node_fs_1.default.existsSync(p))
+                .map(p => `file:./${PlainEntrypointsStyleBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
+            : rawFiles
+                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p)))));
+        if (mappedFiles.length === 0) {
+            if (deleteOnEmpty && rawValue !== undefined) {
+                delete (inPlaudit ? blockJson["plaudit"] : blockJson)[key];
+            }
+        }
+        else {
+            if (inPlaudit && typeof blockJson["plaudit"] !== 'object') {
+                if (blockJson["plaudit"] === "native") {
+                    blockJson["plaudit"] = { type: "native" };
+                }
+                else {
+                    blockJson["plaudit"] = {};
+                }
+            }
+            (inPlaudit ? blockJson["plaudit"] : blockJson)[key] = mappedFiles.length === 1 ? mappedFiles[0] : mappedFiles;
+        }
+    }
+    static normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation) {
+        if (blockJson["acf"]) {
+            if (blockJson["acf"]["renderTemplate"]) {
+                blockJson["render_template"] = blockJson["acf"]["renderTemplate"];
+                delete blockJson["acf"]["renderTemplate"];
+            }
+            else if (blockJson["acf"]["render_template"]) {
+                blockJson["render_template"] = blockJson["acf"]["render_template"];
+                delete blockJson["acf"]["render_template"];
+            }
+        }
+        const blockName = blockJson["name"]?.toString() || "non-existent/block-name";
+        let rawRenderTemplate = blockJson["render"] ?? blockJson["render_template"];
+        rawRenderTemplate = (rawRenderTemplate
+            ? (typeof rawRenderTemplate === 'string' ? [rawRenderTemplate] : rawRenderTemplate)
+            : [`${blockName.substring(blockName.indexOf('/') + 1)}.php`, "template.php", "template.twig"]);
+        const renderTemplate = pathsNeedRemapping
+            ? rawRenderTemplate
+                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p))))
+                .filter(p => node_fs_1.default.existsSync(p))
+                .map(p => `file:./${PlainEntrypointsStyleBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
+            : rawRenderTemplate
+                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, PlainEntrypointsStyleBlockJSONPlugin.stripFilePrefix(p)))));
+        if (renderTemplate.length === 0) {
+            delete blockJson["render_template"];
+            delete blockJson["render"];
+        }
+        else {
+            let validTemplateLocation, invalidTemplateLocation;
+            if (blockJson["acf"] || (blockJson["plaudit"] && (blockJson["plaudit"] !== "native" && (typeof blockJson["plaudit"] !== 'object' || blockJson["plaudit"]?.["type"] !== "native")))) {
+                // ACF-like blocks need to have the template stored in render_template.
+                // Because we can statically detect ACF-like blocks, we can make the move here instead of at run-time.
+                validTemplateLocation = "render_template";
+                invalidTemplateLocation = "render";
+            }
+            else {
+                validTemplateLocation = "render";
+                invalidTemplateLocation = "render_template";
+            }
+            delete blockJson[invalidTemplateLocation];
+            if (renderTemplate.length > 1) {
+                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Encountered a block with multiple possible render files", node_path_1.default.join(sourceDir, 'block.json')));
+                blockJson[validTemplateLocation] = renderTemplate.find(p => p.endsWith(".php")) ?? renderTemplate[0];
+            }
+            else {
+                blockJson[validTemplateLocation] = renderTemplate[0];
+            }
+        }
+    }
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            const allSemaphoreData = (await PlainEntrypointsStyleBlockJSONPlugin.semaphore.wait())
+                .reduce((acc, cur) => {
+                (acc[cur.blocksDest] ?? (acc[cur.blocksDest] = [])).push(cur);
+                return acc;
+            }, {});
+            const semaphoreData = allSemaphoreData[this.blocksDest];
+            if (semaphoreData === undefined) {
+                compilation.errors.push(new Error(`Semaphore data missing for ${this.blocksDest}`));
+                return;
+            }
+            const workableBlockInfo = semaphoreData.map(sd => sd.collatableWorkableBlockInfo)
+                .reduce((acc, cur) => {
+                for (const [k, v] of Object.entries(cur)) {
+                    if (acc[k]) {
+                        acc[k].workableBlockEntrypointsInfo.push(...v.workableBlockEntrypointsInfo);
+                        if (!acc[k].sourcePath && v.sourcePath) {
+                            acc[k].sourcePath = v.sourcePath;
+                        }
+                    }
+                    else {
+                        acc[k] = { ...v, workableBlockEntrypointsInfo: [...v.workableBlockEntrypointsInfo] };
+                    }
+                    acc[k].workableBlockEntrypointsInfo.sort((a, b) => {
+                        return a.handle.localeCompare(b.handle) || a.entrypointField.localeCompare(b.entrypointField);
+                    });
+                }
+                return acc;
+            }, {});
+            const blockData = this.transformBlocks(compilation, workableBlockInfo, semaphoreData.some(sd => sd.emittingWpmlXml));
+            this.emitBlockLoaderFile(compilation, blockData);
+        });
+    }
+}
+exports.PlainEntrypointsStyleBlockJSONPlugin = PlainEntrypointsStyleBlockJSONPlugin;

package/build/plugins/SpecialAssetHandlingPlugin.d.ts

@@ -1,12 +1,12 @@
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class SpecialAssetHandlingPlugin implements WebpackPluginInstance {
+import { Compilation, type Compiler } from "webpack";
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+export declare class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly config;
     private static readonly semaphore;
-    private static hasAttachedAssetCollatorForCurrentBatch;
     private static validPathname?;
-    private readonly id;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
     apply(compiler: Compiler): void;
     private collateAssets;
+    protected attachSecondPhase(compilation: Compilation): void;
 }

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -5,37 +5,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpecialAssetHandlingPlugin = void 0;
 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 PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./PlainEntrypointsConfigFileGeneratorPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class SpecialAssetHandlingPlugin {
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");
-    static hasAttachedAssetCollatorForCurrentBatch = false;
     static validPathname = undefined;
-    id;
     constructor(config) {
+        super("special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.config = config;
-        this.id = Math.random().toString();
     }
     apply(compiler) {
         if (!this.config.useWebpackResourceFiltering) {
             return;
         }
-        SpecialAssetHandlingPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
+        super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = false;
-            SpecialAssetHandlingPlugin.semaphore.reset(this.id);
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch) {
-                    SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = true;
-                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
-                }
-            });
             compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE }, async (assets) => {
                 try {
                     const specialAssetData = {};
@@ -71,6 +60,7 @@ class SpecialAssetHandlingPlugin {
                 }
                 catch (e) {
                     SpecialAssetHandlingPlugin.semaphore.reject(this.id);
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
                     throw e;
                 }
             });
@@ -91,10 +81,11 @@ class SpecialAssetHandlingPlugin {
             return;
         }
         if (!this.config.useUnifiedLoader) {
-            PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin.emitResolveBaseUriFunction(writer);
+            (0, shared_1.emitResolveBaseUriFunction)(writer);
         }
         writer.action("wp_head", writer => {
-            writer.call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr('__DIR__')], { assignTo: "$base_uri" }).closePHP();
+            const baseUriVar = new php_writer_1.Var("base_uri");
+            writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar }).closePHP();
             for (let [filename, { preload, fetchpriority, crossorigin }] of preloadedAssets) {
                 if (!preload) {
                     continue;
@@ -133,11 +124,14 @@ class SpecialAssetHandlingPlugin {
                     attributes.push(["crossorigin", crossorigin]);
                 }
                 const dynamicAttrs = attributes.map(([k, v]) => v ? `${k}="${v}"` : k).join(" ");
-                writer.append(`<link rel="preload" href="<?= esc_url($base_uri.'${filename}') ?>" ${dynamicAttrs}>`);
+                writer.append(`<link rel="preload" href="<?= ${php_writer_1.Expr.call("esc_url", [php_writer_1.Op.join(baseUriVar, filename)])} ?>" ${dynamicAttrs}>`);
             }
             writer.openPHP();
         });
         writer.emitAsset(compilation, outputFile);
     }
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
+    }
 }
 exports.SpecialAssetHandlingPlugin = SpecialAssetHandlingPlugin;

package/build/plugins/UnifiedLoaderGenerator.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedLoaderGenerator = void 0;
+const shared_1 = require("../shared");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const php_writer_1 = require("../utils/php-writer");
-const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./PlainEntrypointsConfigFileGeneratorPlugin");
 const webpack_1 = require("webpack");
 class UnifiedLoaderGenerator {
     config;
@@ -40,7 +40,7 @@ class UnifiedLoaderGenerator {
                             compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
                                 const writer = new php_writer_1.PHPWriter();
                                 if (writerCallbacks.some(wc => wc.requiresBaseURI)) {
-                                    PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin.emitResolveBaseUriFunction(writer);
+                                    (0, shared_1.emitResolveBaseUriFunction)(writer);
                                 }
                                 for (const writerCallback of writerCallbacks) {
                                     writerCallback.action(writer);

package/build/plugins/WPMLConfigBuilder.d.ts

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