@plaudit/webpack-extensions 2.61.2 → 2.62.0

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -0,0 +1,440 @@
+"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 shared_1 = require("../shared");
+const php_writer_1 = require("../utils/php-writer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
+const webpack_1 = require("webpack");
+class PlainEntrypointsStyleBlockJSONPlugin {
+    config;
+    blocksDest;
+    webpackRemoveEmptyScriptsPlugin;
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ collatableWorkableBlockInfo: {}, blocksDest: "", emittingWpmlXml: false }, "Block JSON v3");
+    static phaseTwoAttached = {};
+    id;
+    libraryType;
+    constructor(config, blocksDest, webpackRemoveEmptyScriptsPlugin) {
+        this.config = config;
+        this.blocksDest = blocksDest;
+        this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
+        this.id = Math.random().toString();
+        this.libraryType = `block-json-${this.blocksDest}`;
+        PlainEntrypointsStyleBlockJSONPlugin.semaphore.register(this.id);
+        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
+    }
+    apply(compiler) {
+        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.libraryType);
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest] = false;
+            PlainEntrypointsStyleBlockJSONPlugin.semaphore.reset(this.id);
+            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
+            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
+                if (!PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest]) {
+                    PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest] = true;
+                    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);
+                    });
+                }
+            });
+            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]) {
+                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: srcPath, workableBlockEntrypointsInfo: [] };
+                            }
+                            blockJsonOriginToOutputMapping[srcPath] = epBlockJson;
+                            compilation.emitAsset(epBlockJson, asset);
+                        }
+                    }
+                    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.Expr.__DIR__, new php_writer_1.Expr((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
+                    php_writer_1.Expr.__FILE__, new php_writer_1.Expr((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 }] of Object.entries(collatedWorkableBlockInfo)) {
+            if (!blockJsonSourcePath) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have a source path`, 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 blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, blockJsonAssetName);
+            if (!blockJsonText) {
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${blockJsonAssetName}`, node_path_1.default.join(sourceDir, 'block.json')));
+                continue;
+            }
+            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];
+            }
+        }
+    }
+}
+exports.PlainEntrypointsStyleBlockJSONPlugin = PlainEntrypointsStyleBlockJSONPlugin;

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -5,9 +5,9 @@ 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 {
@@ -91,10 +91,10 @@ 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();
+            writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Expr.__DIR__], { assignTo: "$base_uri" }).closePHP();
             for (let [filename, { preload, fetchpriority, crossorigin }] of preloadedAssets) {
                 if (!preload) {
                     continue;

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;

package/build/plugins/WPMLConfigBuilder.js

@@ -6,18 +6,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WPMLConfigBuilderPlugin = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
 const jsdom_1 = require("jsdom");
 const webpack_1 = require("webpack");
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 class WPMLConfigBuilderPlugin {
-    blockJSONManagingPlugin;
     destDir;
     static jsdomInstance;
     static domParser;
     static xmlSerializer;
     parsedDocumentsCache = new Map();
-    constructor(blockJSONManagingPlugin, destDir) {
-        this.blockJSONManagingPlugin = blockJSONManagingPlugin;
+    constructor(destDir) {
         this.destDir = destDir;
     }
     apply(compiler) {
@@ -52,7 +51,7 @@ class WPMLConfigBuilderPlugin {
                     for (const category of nonMergeableCategories) {
                         for (const [key, value] of Object.entries(wpmlConfig[category])) {
                             if (key in mergedConfig[category]) {
-                                compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${category} entry named, "${key}"`, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${category} entry named, "${key}"`, file));
                             }
                             else {
                                 mergedConfig[category][key] = value;
@@ -69,7 +68,7 @@ class WPMLConfigBuilderPlugin {
                         }
                         catch (e) {
                             if (typeof e === 'string') {
-                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(e, file));
                             }
                             else {
                                 compilation.errors.push(e);
@@ -145,7 +144,6 @@ class WPMLConfigBuilderPlugin {
                 }
                 appendNamedElementsListToConfig("shortcodes", mergedConfig.shortcodes, config);
                 appendNamedElementsListToConfig("taxonomies", mergedConfig.taxonomies, config);
-                this.blockJSONManagingPlugin.additionalMetadata.set("wpml-config", true);
                 compilation[wpmlEmitPath in compilation.assets ? 'updateAsset' : 'emitAsset'](wpmlEmitPath, new webpack_1.sources.RawSource(WPMLConfigBuilderPlugin.prettyPrintXML(config)));
             });
         });
@@ -205,7 +203,7 @@ class WPMLConfigBuilderPlugin {
                         }
                         catch (e) {
                             if (typeof e === 'string') {
-                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(e, file));
                             }
                             else {
                                 compilation.errors.push(e);
@@ -225,12 +223,12 @@ class WPMLConfigBuilderPlugin {
                         const tag = child.getElementsByTagName("tag")[0];
                         const shortcodeName = tag?.textContent?.trim();
                         if (!shortcodeName) {
-                            compilation.errors.push(newWebpackErrorForFile(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
+                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
                             continue;
                         }
                         const existing = res.shortcodes[shortcodeName];
                         if (existing) {
-                            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the shortcode entry named, "${shortcodeName}"`, file));
+                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the shortcode entry named, "${shortcodeName}"`, file));
                         }
                         else {
                             res.shortcodes[shortcodeName] = child;
@@ -241,7 +239,7 @@ class WPMLConfigBuilderPlugin {
                     importStandardTranslateOptionMap(element, file, "taxonomy", res.taxonomies, compilation);
                     break;
                 default:
-                    compilation.errors.push(newWebpackErrorForFile(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
+                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
                     break;
             }
         }
@@ -254,17 +252,17 @@ function importStandardTranslateOptionMap(element, file, type, actionMap, compil
     for (const child of element.children) {
         const field = child.textContent;
         if (!field) {
-            compilation.errors.push(newWebpackErrorForFile(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
             continue;
         }
         const translate = child.getAttribute("translate");
         if (!translate) {
-            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing the translate attribute.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing the translate attribute.`, file));
             continue;
         }
         const existing = actionMap[field];
         if (existing) {
-            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
         }
         else {
             actionMap[field] = child;
@@ -275,17 +273,17 @@ function importStandardTranslateActionMap(element, file, type, actionMap, compil
     for (const child of element.children) {
         const field = child.textContent?.trim();
         if (!field) {
-            compilation.errors.push(newWebpackErrorForFile(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
             continue;
         }
         const action = child.getAttribute("action");
         if (!action) {
-            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing an action.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing an action.`, file));
             continue;
         }
         const existing = actionMap[field];
         if (existing) {
-            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
         }
         else {
             actionMap[field] = child;
@@ -433,12 +431,6 @@ function mergeGenericSettingsKeys(existing, novel) {
     }
     return { ...existing, ...novel, keys: mergeGenericSettingsKeyLists(existing.keys, novel.keys) };
 }
-function newWebpackErrorForFile(error, file) {
-    const res = new webpack_1.WebpackError(error);
-    res.hideStack = true;
-    res.file = file;
-    return res;
-}
 function writeGenericSettingsKeys(keys, parent, document) {
     parent.append(...keys.sort((a, b) => a.name.localeCompare(b.name)).map(key => {
         const element = document.createElement("key");