@plaudit/webpack-extensions 2.61.2 → 2.62.1

package/build/plugins/BlockJSONManagingPlugin.d.ts

@@ -1,40 +0,0 @@
-import { Compilation, type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
-    private readonly standaloneBlocks;
-    private readonly processingModules;
-    private readonly blocksDest;
-    static readonly mappableModuleKeys: readonly ["viewScriptModule", "scriptModule"];
-    static readonly mappableNonModuleKeys: readonly ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
-    private static readonly mappableKeys;
-    private static readonly blockJsonToEntrypointsMap;
-    private static readonly blockJsonRawDependenciesMap;
-    private static readonly blockJSONAssetSourceDirs;
-    private static readonly blockJsonAssetKeyMapping;
-    private static readonly syncsManager;
-    readonly additionalMetadata: Map<string, any>;
-    private readonly id;
-    constructor(standaloneBlocks: boolean, processingModules: boolean | undefined, blocksDest: string);
-    static recordRawDependency(entrypoint: string, dependency: string): void;
-    static recordBlockJSONAssetSourceDir(entrypoint: string, source: string): void;
-    apply(compiler: Compiler): void;
-    static resolveDestinationBySourceExtension(srcPath: string, entrypoint: Compilation['asyncEntrypoints'][number]): string | undefined;
-    static findCommonAncestor(...paths: string[]): string[];
-    static findRelativeRouteBetween(path1: string, path2: string): string;
-    private static remapReferencedPHPFilesOnKey;
-    private static hashThingForAsset;
-    private static stripFilePrefix;
-    private static buildFakeCompilationAssets;
-    private static incorporateRemappedAsset;
-    private static remapReferencedAssetFile;
-    private static getReferencedFileSlot;
-    private static addAssetToBlockJsonKey;
-    private registerAssetProcessor;
-    private static populateEntrypointsMap;
-    private registerBlockJsonProcessor;
-    private static normalizeRenderTemplate;
-    private getAssetDetails;
-    private static getAssetDataAccountingForCSS;
-    private static findFirstChunkFileWithExtension;
-    private static getChunkFilesByRuntimeName;
-    private stripBlocksDest;
-}

package/build/plugins/BlockJSONManagingPlugin.js

@@ -1,594 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlockJSONManagingPlugin = 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 webpack_1 = require("webpack");
-const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-const php_writer_1 = require("../utils/php-writer");
-class BlockJSONManagingPlugin {
-    standaloneBlocks;
-    processingModules;
-    blocksDest;
-    static mappableModuleKeys = ["viewScriptModule", "scriptModule"];
-    static mappableNonModuleKeys = ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
-    static mappableKeys = [...BlockJSONManagingPlugin.mappableNonModuleKeys, ...BlockJSONManagingPlugin.mappableModuleKeys];
-    static blockJsonToEntrypointsMap = new Map();
-    static blockJsonRawDependenciesMap = new Map();
-    static blockJSONAssetSourceDirs = new Map();
-    static blockJsonAssetKeyMapping = new Map();
-    static syncsManager = new shared_1.SyncsManager();
-    additionalMetadata = new Map();
-    id;
-    constructor(standaloneBlocks, processingModules, blocksDest) {
-        this.standaloneBlocks = standaloneBlocks;
-        this.processingModules = processingModules;
-        this.blocksDest = blocksDest;
-        this.id = Math.random().toString();
-        if (!this.processingModules) {
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
-        }
-    }
-    static recordRawDependency(entrypoint, dependency) {
-        let deps = BlockJSONManagingPlugin.blockJsonRawDependenciesMap.get(entrypoint);
-        if (deps === undefined) {
-            BlockJSONManagingPlugin.blockJsonRawDependenciesMap.set(entrypoint, deps = new Set());
-        }
-        deps.add(dependency);
-    }
-    static recordBlockJSONAssetSourceDir(entrypoint, source) {
-        BlockJSONManagingPlugin.blockJSONAssetSourceDirs.set(entrypoint, source);
-    }
-    apply(compiler) {
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            this.additionalMetadata.clear();
-            this.registerAssetProcessor(compilation);
-            if (!this.processingModules) {
-                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-                this.registerBlockJsonProcessor(compilation);
-            }
-        });
-    }
-    static resolveDestinationBySourceExtension(srcPath, entrypoint) {
-        const extensionMatch = /(m?)[jt]sx?$/i.exec(node_path_1.default.extname(srcPath));
-        if (extensionMatch === null) {
-            return entrypoint.getFiles().find(file => file.endsWith(".css"));
-        }
-        else if (extensionMatch[1]) {
-            return entrypoint.getFiles().find(file => file.endsWith(".mjs")) ?? entrypoint.getFiles().find(file => file.endsWith(".js"));
-        }
-        else {
-            return entrypoint.getFiles().find(file => file.endsWith(".js"));
-        }
-    }
-    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 = BlockJSONManagingPlugin.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(json, key, pathsNeedRemapping, sourceDir, outputDir, compilation, inPlaudit) {
-        const rawValue = (inPlaudit ? json["plaudit"] : json)?.[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) {
-                    const error = new webpack_1.WebpackError(`Encountered a block with a mixture of file-reference and non-file-reference elements in the "${inPlaudit ? 'plaudit.' : ''}${key}" property`);
-                    error.file = node_path_1.default.join(sourceDir, 'block.json');
-                    compilation.warnings.push(error);
-                    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, BlockJSONManagingPlugin.stripFilePrefix(p))))
-                .filter(p => node_fs_1.default.existsSync(p))
-                .map(p => `file:./${BlockJSONManagingPlugin.findRelativeRouteBetween(outputDir, p)}`)
-            : rawFiles
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, BlockJSONManagingPlugin.stripFilePrefix(p)))));
-        if (mappedFiles.length === 0) {
-            if (deleteOnEmpty && rawValue !== undefined) {
-                delete (inPlaudit ? json["plaudit"] : json)[key];
-            }
-        }
-        else {
-            if (inPlaudit && typeof json["plaudit"] !== 'object') {
-                if (json["plaudit"] === "native") {
-                    json["plaudit"] = { type: "native" };
-                }
-                else {
-                    json["plaudit"] = {};
-                }
-            }
-            (inPlaudit ? json["plaudit"] : json)[key] = mappedFiles.length === 1 ? mappedFiles[0] : mappedFiles;
-        }
-    }
-    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 buildFakeCompilationAssets(compilation) {
-        const res = {};
-        for (const filePath of compilation.fileDependencies.values()) {
-            if (filePath.endsWith("/block.json")) {
-                const directory = node_path_1.default.dirname(node_path_1.default.normalize(filePath));
-                res[node_path_1.default.join(node_path_1.default.basename(directory), "block.json")] = filePath;
-            }
-        }
-        return res;
-    }
-    static incorporateRemappedAsset(cacheableMappedKeys, mappableKey, remappedValue, additionalValues) {
-        if (additionalValues.length > 0) {
-            const referencedFilesSlot = BlockJSONManagingPlugin.getReferencedFileSlot(mappableKey);
-            if (!cacheableMappedKeys.referencedFiles[referencedFilesSlot]) {
-                cacheableMappedKeys.referencedFiles[referencedFilesSlot] = [...additionalValues];
-            }
-            else {
-                cacheableMappedKeys.referencedFiles[referencedFilesSlot].push(...additionalValues);
-            }
-        }
-        if (Array.isArray(cacheableMappedKeys.directMappings[mappableKey])) {
-            cacheableMappedKeys.directMappings[mappableKey].push(remappedValue[0]);
-        }
-        else if (typeof cacheableMappedKeys.directMappings[mappableKey] === 'string') {
-            cacheableMappedKeys.directMappings[mappableKey] = [cacheableMappedKeys.directMappings[mappableKey], remappedValue[0]];
-        }
-        else {
-            cacheableMappedKeys.directMappings[mappableKey] = remappedValue[0];
-        }
-        cacheableMappedKeys.compositeHash += "~" + remappedValue[1];
-    }
-    static remapReferencedAssetFile(value, name) {
-        if (value.startsWith("file:")) {
-            const sourceDir = BlockJSONManagingPlugin.blockJSONAssetSourceDirs.get(name) ?? node_path_1.default.dirname(name);
-            const inputPath = node_path_1.default.normalize(node_path_1.default.join(sourceDir, value.substring(5)));
-            const outputAndDerivedFiles = BlockJSONManagingPlugin.blockJsonToEntrypointsMap.get(name)?.get(inputPath);
-            if (outputAndDerivedFiles !== undefined) {
-                const { entryMeta, derivedFiles } = outputAndDerivedFiles;
-                const prefix = value.startsWith("./", 5) ? "./" : "";
-                const relativePath = node_path_1.default.relative(node_path_1.default.dirname(name), entryMeta.path);
-                const res = [`file:${prefix}${relativePath}`, entryMeta.hash];
-                if (shared_1.styleExtension.test(entryMeta.path)) {
-                    return [res,
-                        derivedFiles.filter(derivedFile => !shared_1.scriptExtension.test(derivedFile))
-                            .map(derivedFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), derivedFile)}`)
-                    ];
-                }
-                else {
-                    return [res, derivedFiles.map(derivedFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), derivedFile)}`)];
-                }
-            }
-        }
-        return [[value, ""], []];
-    }
-    static getReferencedFileSlot(mappableKey) {
-        if (mappableKey.startsWith("editor")) {
-            return "editor";
-        }
-        else if (mappableKey.startsWith("view")) {
-            return "view";
-        }
-        else {
-            return "both";
-        }
-    }
-    static addAssetToBlockJsonKey(json, mappableKey, asset) {
-        if (json[mappableKey] === undefined) {
-            if (Array.isArray(asset)) {
-                json[mappableKey] = [...asset];
-            }
-            else {
-                json[mappableKey] = asset;
-            }
-        }
-        else if (typeof json[mappableKey] === 'string') {
-            if (Array.isArray(asset)) {
-                json[mappableKey] = [json[mappableKey], ...asset];
-            }
-            else {
-                json[mappableKey] = [json[mappableKey], asset];
-            }
-        }
-        else {
-            if (Array.isArray(asset)) {
-                json[mappableKey].push(...asset);
-            }
-            else {
-                json[mappableKey].push(asset);
-            }
-        }
-    }
-    registerAssetProcessor(compilation) {
-        const tapName = { name: `${this.constructor.name}_ProcessBlockJSONFiles`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED };
-        compilation.hooks.processAssets.tapPromise(tapName, async (compilationAssets) => {
-            const testableCompilationAssets = this.processingModules ? BlockJSONManagingPlugin.buildFakeCompilationAssets(compilation) : compilationAssets;
-            const currentBlockJSONAssets = BlockJSONManagingPlugin.blockJSONAssetSourceDirs.entries()
-                .filter(([name]) => name in testableCompilationAssets)
-                .toArray();
-            BlockJSONManagingPlugin.populateEntrypointsMap(currentBlockJSONAssets, compilation);
-            await Promise.all(currentBlockJSONAssets.map(async ([name]) => {
-                const assetContents = this.processingModules ? node_fs_1.default.readFileSync(testableCompilationAssets[name], 'utf8') : compilation.assets[name]?.buffer().toString();
-                if (!assetContents) {
-                    return;
-                }
-                const json = JSON.parse(assetContents);
-                const currentAssetKeyMappings = { directMappings: {}, referencedFiles: {}, compositeHash: "" };
-                for (const mappableKey of BlockJSONManagingPlugin[this.processingModules ? 'mappableModuleKeys' : 'mappableNonModuleKeys']) {
-                    if (mappableKey in json) {
-                        const unmappedValue = json[mappableKey];
-                        if (Array.isArray(unmappedValue)) {
-                            for (const uv of unmappedValue) {
-                                BlockJSONManagingPlugin.incorporateRemappedAsset(currentAssetKeyMappings, mappableKey, ...BlockJSONManagingPlugin.remapReferencedAssetFile(uv, name));
-                            }
-                        }
-                        else if (typeof unmappedValue === 'string') {
-                            BlockJSONManagingPlugin.incorporateRemappedAsset(currentAssetKeyMappings, mappableKey, ...BlockJSONManagingPlugin.remapReferencedAssetFile(unmappedValue, name));
-                        }
-                    }
-                }
-                const syncs = BlockJSONManagingPlugin.syncsManager.get(name);
-                let assetKeyMappings = BlockJSONManagingPlugin.blockJsonAssetKeyMapping.get(name);
-                if (!assetKeyMappings) {
-                    BlockJSONManagingPlugin.blockJsonAssetKeyMapping.set(name, assetKeyMappings = {});
-                }
-                assetKeyMappings[this.processingModules ? 'module' : 'nonModule'] = currentAssetKeyMappings;
-                if (this.processingModules) {
-                    syncs.module.resolve();
-                    if (!BlockJSONManagingPlugin.mappableNonModuleKeys.some(key => key in json)) {
-                        syncs.nonModule.resolve();
-                    }
-                    await syncs.nonModule.sync;
-                }
-                else {
-                    syncs.nonModule.resolve();
-                    if (!BlockJSONManagingPlugin.mappableModuleKeys.some(key => key in json)) {
-                        syncs.module.resolve();
-                    }
-                    await syncs.module.sync;
-                }
-            }));
-        });
-    }
-    static populateEntrypointsMap(currentBlockJSONAssets, compilation) {
-        for (const [name] of currentBlockJSONAssets) {
-            const dependencies = BlockJSONManagingPlugin.blockJsonRawDependenciesMap.get(name);
-            if (dependencies) {
-                for (const dependency of dependencies) {
-                    const entrypoint = compilation.entrypoints.get(dependency);
-                    if (!entrypoint) {
-                        continue;
-                    }
-                    const srcPath = entrypoint.origins.map(origin => origin.request)[0];
-                    if (!srcPath) {
-                        continue;
-                    }
-                    const destPath = BlockJSONManagingPlugin.resolveDestinationBySourceExtension(srcPath, entrypoint);
-                    if (!destPath) {
-                        continue;
-                    }
-                    const entrypointChunk = entrypoint.getEntrypointChunk();
-                    const derivedFiles = entrypointChunk.name
-                        ? BlockJSONManagingPlugin.getChunkFilesByRuntimeName(entrypointChunk.name, compilation).filter(file => file !== destPath)
-                        : [...entrypointChunk.files].filter(file => !file.endsWith(".asset.php") && file !== destPath);
-                    const entryMeta = { hash: entrypointChunk.hash ?? destPath, path: destPath };
-                    const currentEntrypoints = BlockJSONManagingPlugin.blockJsonToEntrypointsMap.get(name);
-                    if (currentEntrypoints) {
-                        currentEntrypoints.set(srcPath, { entryMeta, derivedFiles });
-                    }
-                    else {
-                        BlockJSONManagingPlugin.blockJsonToEntrypointsMap.set(name, new Map([[srcPath, { entryMeta, derivedFiles }]]));
-                    }
-                }
-            }
-        }
-    }
-    registerBlockJsonProcessor(compilation) {
-        const blockDirConfigData = {};
-        compilation.hooks.processAssets.tap({ name: `${this.constructor.name}_UnifiedLoaderGeneratorIntegration`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED }, () => {
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, {
-                group: `block-json-${this.blocksDest}`,
-                requiresBaseURI: false,
-                action: writer => {
-                    writer
-                        .use("Plaudit\\Common\\ACF\\BlockManager")
-                        .action("init", writer => {
-                        writer.call("BlockManager::autoloadSubfolders", [new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP("/" + this.blocksDest)}`)]);
-                    }, { accountForAlreadyDoing: true });
-                }
-            });
-        });
-        compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_GenerateMetadata`, compilationAssets => {
-            const currentBlockJSONAssets = BlockJSONManagingPlugin.blockJSONAssetSourceDirs.entries()
-                .filter(([name]) => name in compilationAssets)
-                .toArray();
-            for (const [name, sourceDir] of currentBlockJSONAssets) {
-                const assetKeyMappings = BlockJSONManagingPlugin.blockJsonAssetKeyMapping.get(name);
-                let compositeHash = "";
-                const condensedBlockJsonAssetKeyMappings = {};
-                for (const subType of ['nonModule', 'module']) {
-                    const mappings = assetKeyMappings[subType];
-                    if (mappings) {
-                        compositeHash += mappings.compositeHash;
-                        for (const mappableKey of BlockJSONManagingPlugin.mappableKeys) {
-                            if (mappings.directMappings[mappableKey]) {
-                                BlockJSONManagingPlugin.addAssetToBlockJsonKey(condensedBlockJsonAssetKeyMappings, mappableKey, mappings.directMappings[mappableKey]);
-                            }
-                        }
-                        for (const [referenceLocation, prefix] of [["editor", "editorS"], ["both", "s"], ["view", "viewS"]]) {
-                            if (mappings.referencedFiles[referenceLocation]) {
-                                for (const referencedFile of mappings.referencedFiles[referenceLocation]) {
-                                    if (referencedFile.endsWith(".css")) {
-                                        BlockJSONManagingPlugin.addAssetToBlockJsonKey(condensedBlockJsonAssetKeyMappings, `${prefix}tyle`, referencedFile);
-                                    }
-                                    else if (referencedFile.endsWith(".js")) {
-                                        BlockJSONManagingPlugin.addAssetToBlockJsonKey(condensedBlockJsonAssetKeyMappings, `${prefix}cript`, referencedFile);
-                                    }
-                                    else if (referencedFile.endsWith(".mjs")) {
-                                        BlockJSONManagingPlugin.addAssetToBlockJsonKey(condensedBlockJsonAssetKeyMappings, `${prefix}criptModule`, referencedFile);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                const assetContents = compilation.assets[name]?.buffer().toString();
-                if (!assetContents) {
-                    continue;
-                }
-                const json = JSON.parse(assetContents);
-                for (const mappableKey of BlockJSONManagingPlugin.mappableKeys) {
-                    if (mappableKey in condensedBlockJsonAssetKeyMappings) {
-                        json[mappableKey] = condensedBlockJsonAssetKeyMappings[mappableKey];
-                    }
-                    else {
-                        delete json[mappableKey];
-                    }
-                }
-                if (json["version"]) {
-                    json["version"] = `${json["version"]}-${BlockJSONManagingPlugin.hashThingForAsset(compositeHash)}`;
-                }
-                else {
-                    json["version"] = BlockJSONManagingPlugin.hashThingForAsset(compositeHash);
-                }
-                const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(name));
-                const pathsNeedRemapping = !this.standaloneBlocks && json["plaudit"] !== "simple";
-                BlockJSONManagingPlugin.remapReferencedPHPFilesOnKey(json, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
-                BlockJSONManagingPlugin.remapReferencedPHPFilesOnKey(json, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
-                BlockJSONManagingPlugin.normalizeRenderTemplate(json, pathsNeedRemapping, sourceDir, outputDir, compilation);
-                compilation[name in compilation.assets ? 'updateAsset' : 'emitAsset'](name, new webpack_1.sources.RawSource(JSON.stringify(json, undefined, "  ")));
-                blockDirConfigData[node_path_1.default.dirname(name)] = json;
-            }
-            let sortedBlockDirConfigData;
-            const blockDirConfigs = Object.entries(blockDirConfigData).sort(([a], [b]) => a.localeCompare(b));
-            const rawAssetDataSource = compilation.assets["assets.json"]?.source();
-            if (typeof rawAssetDataSource === 'string') {
-                const derivedFilesMap = new Map();
-                for (const epMap of BlockJSONManagingPlugin.blockJsonToEntrypointsMap.values()) { // For each block.json file's entry point map
-                    for (const epMapValue of epMap.values()) { // For each recorded entry point
-                        const progenitorFile = epMapValue.entryMeta.path;
-                        for (const derivedFile of epMapValue.derivedFiles) { // For each derived (non-auxiliary) file generated by that entry point
-                            derivedFilesMap.set(derivedFile, progenitorFile); // Record a mapping from each derived file to its progenitor
-                        }
-                    }
-                }
-                const rawAssetData = JSON.parse(rawAssetDataSource);
-                for (const chunk of compilation.chunks) {
-                    if (compilation.chunkGraph.getChunkModulesIterableBySourceType(chunk, 'css/mini-extract')) {
-                        const output = BlockJSONManagingPlugin.findFirstChunkFileWithExtension(chunk, ".css");
-                        if (output) {
-                            rawAssetData[output] = { dependencies: [], version: chunk.contentHash['css/mini-extract'] ?? chunk.hash ?? "" };
-                        }
-                    }
-                }
-                const scriptHandles = {};
-                const styleHandles = {};
-                const usedHandles = { css: {}, js: {} };
-                for (const [blockFolder, config] of blockDirConfigs) {
-                    for (const mappableKey of BlockJSONManagingPlugin.mappableKeys) {
-                        const cfg = config[mappableKey];
-                        if (cfg) {
-                            if (Array.isArray(cfg)) {
-                                for (let i = 0; i < cfg.length; i++) {
-                                    const assetDetails = this
-                                        .getAssetDetails(blockFolder, config["name"], cfg[i], rawAssetData, derivedFilesMap, mappableKey, usedHandles);
-                                    if (assetDetails) {
-                                        (assetDetails.isCss ? styleHandles : scriptHandles)[assetDetails.handle] = assetDetails.handleData;
-                                        cfg[i] = assetDetails.handle;
-                                    }
-                                }
-                            }
-                            else {
-                                const assetDetails = this
-                                    .getAssetDetails(blockFolder, config["name"], cfg, rawAssetData, derivedFilesMap, mappableKey, usedHandles);
-                                if (assetDetails) {
-                                    (assetDetails.isCss ? styleHandles : scriptHandles)[assetDetails.handle] = assetDetails.handleData;
-                                    config[mappableKey] = assetDetails.handle;
-                                }
-                            }
-                        }
-                    }
-                }
-                sortedBlockDirConfigData = Object.fromEntries([
-                    ["__metadata", { version: 3, ...Object.fromEntries(this.additionalMetadata.entries()), scriptHandles, styleHandles }],
-                    ...blockDirConfigs.map(entry => [this.stripBlocksDest(entry[0]), Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
-                ]);
-                compilation.deleteAsset("assets.json");
-            }
-            else {
-                sortedBlockDirConfigData = Object.fromEntries([
-                    ["__metadata", { version: 1, ...Object.fromEntries(this.additionalMetadata.entries()) }],
-                    ...blockDirConfigs.map(entry => [this.stripBlocksDest(entry[0]), Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
-                ]);
-            }
-            compilation.emitAsset(node_path_1.default.join(this.blocksDest, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(sortedBlockDirConfigData)));
-        });
-    }
-    static normalizeRenderTemplate(json, pathsNeedRemapping, sourceDir, outputDir, compilation) {
-        if (json["acf"]) {
-            if (json["acf"]["renderTemplate"]) {
-                json["render_template"] = json["acf"]["renderTemplate"];
-                delete json["acf"]["renderTemplate"];
-            }
-            else if (json["acf"]["render_template"]) {
-                json["render_template"] = json["acf"]["render_template"];
-                delete json["acf"]["render_template"];
-            }
-        }
-        const blockName = json["name"]?.toString() || "non-existent/block-name";
-        let rawRenderTemplate = json["render"] ?? json["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, BlockJSONManagingPlugin.stripFilePrefix(p))))
-                .filter(p => node_fs_1.default.existsSync(p))
-                .map(p => `file:./${BlockJSONManagingPlugin.findRelativeRouteBetween(outputDir, p)}`)
-            : rawRenderTemplate
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, BlockJSONManagingPlugin.stripFilePrefix(p)))));
-        if (renderTemplate.length === 0) {
-            delete json["render_template"];
-            delete json["render"];
-        }
-        else {
-            let validTemplateLocation, invalidTemplateLocation;
-            if (json["acf"] || (json["plaudit"] && (json["plaudit"] !== "native" && (typeof json["plaudit"] !== 'object' || json["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 json[invalidTemplateLocation];
-            if (renderTemplate.length > 1) {
-                const error = new webpack_1.WebpackError("Encountered a block with multiple possible render files");
-                error.file = node_path_1.default.join(sourceDir, 'block.json');
-                compilation.warnings.push(error);
-                json[validTemplateLocation] = renderTemplate.find(p => p.endsWith(".php")) ?? renderTemplate[0];
-            }
-            else {
-                json[validTemplateLocation] = renderTemplate[0];
-            }
-        }
-    }
-    getAssetDetails(blockFolder, blockName, asset, rawAssetData, derivedFilesMap, mappableKey, usedHandles) {
-        if (!asset.startsWith("file:./")) {
-            return undefined;
-        }
-        const src = `${blockFolder}/${asset.substring(7)}`;
-        const isCss = src.endsWith(".css");
-        let assetData;
-        if (rawAssetData[src]) {
-            assetData = rawAssetData[src];
-        }
-        else {
-            const progenitorSrc = derivedFilesMap.get(src);
-            if (progenitorSrc) {
-                const tempAssetData = BlockJSONManagingPlugin.getAssetDataAccountingForCSS(progenitorSrc, rawAssetData);
-                if (tempAssetData) {
-                    assetData = progenitorSrc.endsWith(".css") === isCss
-                        ? tempAssetData
-                        : { ...tempAssetData, dependencies: [] }; // derived files cannot inherit dependencies from their progenitors if they are of a different type
-                }
-                else {
-                    assetData = undefined;
-                }
-                assetData = tempAssetData ? { ...tempAssetData, dependencies: [] } : undefined;
-            }
-            else {
-                assetData = BlockJSONManagingPlugin.getAssetDataAccountingForCSS(src, rawAssetData);
-            }
-        }
-        if (!assetData) {
-            return undefined;
-        }
-        let handle = this.stripBlocksDest(src.substring(0, src.length - (isCss ? 4 : 3)));
-        if (blockName && handle.startsWith(blockName.substring(blockName.indexOf("/") + 1) + "/")) {
-            handle = blockName + handle.substring(handle.indexOf("/"));
-        }
-        if (usedHandles[isCss ? 'css' : 'js'][handle] !== undefined) {
-            handle += "-" + (++usedHandles[isCss ? 'css' : 'js'][handle]);
-        }
-        else {
-            usedHandles[isCss ? 'css' : 'js'][handle] = 0;
-        }
-        const rest = isCss || mappableKey.startsWith("editor")
-            ? [assetData.dependencies, assetData.version]
-            : [assetData.dependencies, assetData.version, { strategy: 'defer' }];
-        return { isCss, handle, handleData: { src: this.stripBlocksDest(src), rest } };
-    }
-    static getAssetDataAccountingForCSS(src, rawAssetData) {
-        if (rawAssetData[src]) {
-            return rawAssetData[src];
-        }
-        if (src.endsWith(".css")) {
-            return rawAssetData[src.substring(0, src.length - 3) + "js"] // A simple style dependency that isn't named "style"
-                ?? rawAssetData[src.substring(0, src.length - 3).replace("style-style", "style") + "js"]; // A simple style dependency that IS named style
-        }
-        return undefined;
-    }
-    static findFirstChunkFileWithExtension(chunk, extension) {
-        for (const file of chunk.files) {
-            if (file.endsWith(extension)) {
-                return file;
-            }
-        }
-        return undefined;
-    }
-    static getChunkFilesByRuntimeName(runtimeName, compilation) {
-        const files = new Set();
-        for (const chunk of compilation.chunks) {
-            if (typeof chunk.runtime === 'string' ? chunk.runtime === runtimeName : chunk.runtime?.has(runtimeName)) {
-                for (const file of chunk.files) {
-                    if (!file.endsWith(".asset.php")) {
-                        files.add(file);
-                    }
-                }
-            }
-        }
-        return [...files];
-    }
-    stripBlocksDest(item) {
-        return this.blocksDest && item.startsWith(this.blocksDest + "/") ? item.substring(this.blocksDest.length + 1 /* we also need to drop the "/" */) : item;
-    }
-}
-exports.BlockJSONManagingPlugin = BlockJSONManagingPlugin;