@plaudit/webpack-extensions 3.21.2 → 4.0.0

package/dist/plugins/EnhancedBlockJSONPlugin.js

@@ -1,657 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnhancedBlockJSONPlugin = void 0;
-const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:fs/promises");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const php_writer_1 = require("@plaudit/php-writer");
-const expressions_1 = require("@plaudit/php-writer/expressions");
-const webpack_1 = require("webpack");
-const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
-const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-const shared_1 = require("../shared");
-const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
-const pseudo_semaphore_1 = require("../utils/pseudo-semaphore");
-class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
-    config;
-    dest;
-    webpackRemoveEmptyScriptsPlugin;
-    static semaphore = new pseudo_semaphore_1.PseudoSemaphore("Block JSON v3");
-    constructor(config, dest, webpackRemoveEmptyScriptsPlugin, context, entry) {
-        super(`block-json-${dest.destination}`, [EnhancedBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
-        this.config = config;
-        this.dest = dest;
-        this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
-    }
-    async processAssets(compilation, parsedAssetJsonProvider) {
-        const applicableBlockJsonFiles = {};
-        const blockJsonOriginToOutputMapping = {};
-        const staticallyLoadedEntrypoints = [];
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
-        for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            staticallyLoadedEntrypoints.push(...entrypoint.getEntrypointChunk().files);
-            if ((0, node_path_1.basename)(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
-                continue;
-            }
-            const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypoint.getEntrypointChunk())][0]?.originalSource();
-            if (asset) {
-                const epBlockJson = entrypoint.name + ".json";
-                if (!applicableBlockJsonFiles[epBlockJson]) {
-                    const blockJsonText = EnhancedBlockJSONPlugin.extractAssetSource(compilation, epBlockJson) ?? await (0, promises_1.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, metadata, srcPath } of relevantEntrypoints) {
-            if ((0, node_path_1.basename)(srcPath).toLowerCase() === "block.json" || 'purpose' in metadata) {
-                continue;
-            }
-            const entrypointChunk = entrypoint.getEntrypointChunk();
-            const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => (0, node_path_1.basename)(auxFile) === "block.json")
-                ?? blockJsonOriginToOutputMapping[metadata.blockJsonOrigin];
-            if (epBlockJson) {
-                const assetData = parsedAssetJsonProvider(entrypoint, metadata)?.assetData;
-                if (!assetData) {
-                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
-                    continue;
-                }
-                const workableBlockEntrypointsInfo = entrypoint.getFiles()
-                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(file))
-                    .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
-                    .filter((item) => item[1] !== '')
-                    .map(([file, assetType]) => {
-                    const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(file, metadata.enqueuingFlags, this.dest.enqueuingFlags);
-                    const { scriptArgsObject, assetMeta } = (0, path_query_and_related_helpers_1.convertEnqueuingControlFlagsToScriptArgsObject)(compilation, file, enqueuingFlags);
-                    if (assetMeta?.inlinedAsset !== undefined) {
-                        staticallyLoadedEntrypoints.push(file);
-                    }
-                    const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
-                    const outputPath = this.stripOffBlocksDestPrefix(file);
-                    if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
-                        const entrypointField = (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType);
-                        return {
-                            ...metadata, outputPath, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
-                            entrypointField, handleGroup: (0, shared_1.getHandleGroup)(entrypointField), scriptArgsObject, ...assetMeta
-                        };
-                    }
-                    return { ...metadata, outputPath, assetData, hash: entrypointChunk.hash ?? "", scriptArgsObject, ...assetMeta };
-                });
-                if (applicableBlockJsonFiles[epBlockJson]) {
-                    applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
-                }
-                else {
-                    applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo };
-                }
-            }
-        }
-        EnhancedBlockJSONPlugin.semaphore.resolve(this.id, {
-            collatableWorkableBlockInfo: applicableBlockJsonFiles, blocksDest: this.dest.destination,
-            emittingWpmlXml: compilation.getAsset((0, node_path_1.join)(this.dest.destination, "wpml-config.xml")) !== undefined
-        });
-        const generateLoader = (writer) => {
-            writer.require((0, node_path_1.join)(this.dest.destination, "blockdir-loader.php"), { dirRelative: true, once: true });
-        };
-        let action;
-        const lazyLoader = this.dest.lazyLoader;
-        if (lazyLoader) {
-            try {
-                action = writer => writer.function(new expressions_1.NamespacedReference(this.config.targetNamespace, lazyLoader, 'function'), [], generateLoader, { returnType: 'void' });
-            }
-            catch (e) {
-                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for lazily loading blocks", { cause: e }], this.dest.destination));
-                this.rejectSemaphores();
-                return;
-            }
-        }
-        else {
-            action = writer => writer.withScope(generateLoader);
-        }
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(applicableBlockJsonFiles).length ? {
-            group: this.group,
-            requiresBaseURI: false,
-            staticallyLoadedEntrypoints,
-            action
-        } : undefined);
-    }
-    emitBlockLoaderFile(compilation, blockDirConfig) {
-        if (this.config.useUnifiedLoader) {
-            const { '__metadata': metadata, ...blockData } = blockDirConfig;
-            const splitOutInlinedAssets = (handles, type) => {
-                const registerableHandles = {};
-                const inlinedAssets = [];
-                for (const [handle, handleData] of Object.entries(handles)) {
-                    const { inlinedAsset, ...finalizedHandle } = handleData;
-                    if (inlinedAsset !== undefined) {
-                        finalizedHandle.src = false;
-                        inlinedAssets.push([handle, type, handleData]);
-                    }
-                    registerableHandles[handle] = finalizedHandle;
-                }
-                return [registerableHandles, inlinedAssets];
-            };
-            const [finalizedScriptHandles, inlinableScripts] = splitOutInlinedAssets(metadata.scriptHandles, 'script');
-            const [finalizedStyleHandles, inlinableStyles] = splitOutInlinedAssets(metadata.styleHandles, 'style');
-            const finalizedMetadata = Object.fromEntries(Object.entries(metadata)
-                .map(([key, value]) => {
-                if (key === 'scriptHandles') {
-                    return [key, []];
-                }
-                if (key === 'styleHandles') {
-                    return [key, []];
-                }
-                if (key === 'scriptModuleHandles') {
-                    return [key, []];
-                }
-                return [key, value];
-            }));
-            const writer = new php_writer_1.PHPWriter()
-                .action("init", writer => {
-                const baseUriVar = new expressions_1.Var("base_uri");
-                writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
-                this.callRegisterFunction('script', writer, baseUriVar, Object.entries(finalizedScriptHandles));
-                this.callRegisterFunction('style', writer, baseUriVar, Object.entries(finalizedStyleHandles));
-                this.callRegisterFunction('script_module', writer, baseUriVar, Object.entries(metadata.scriptModuleHandles));
-                const entries = Object.entries(metadata.bindableBlockAttributes);
-                const supportedAttributes = new expressions_1.Var("supported_block_attributes", "?array");
-                if ((0, shared_1.arrayIsLength)(entries, 1)) {
-                    writer.filter(`block_bindings_supported_attributes_${entries[0][0]}`, writer => {
-                        const parameters = entries[0][1];
-                        if (parameters.length === 1) {
-                            writer.appendExpr(new expressions_1.Assignment(supportedAttributes, parameters[0], true));
-                        }
-                        else {
-                            writer.call("array_push", [supportedAttributes, ...parameters]);
-                        }
-                        writer.return(supportedAttributes);
-                    }, { functionArgParameters: [supportedAttributes] });
-                }
-                else if (entries.length > 1) {
-                    const compiledBindingSupportingAttributes = new expressions_1.Var("compiled_binding_supporting_attributes");
-                    writer.assign(compiledBindingSupportingAttributes, metadata.bindableBlockAttributes);
-                    const blockType = new expressions_1.Var("block_type", "?string");
-                    writer.filter(`block_bindings_supported_attributes`, writer => {
-                        writer
-                            .if(expressions_1.Op.binary(expressions_1.Expr.call("empty", [blockType]), " || ", expressions_1.Expr.call("empty", [new expressions_1.ArrayAccess(compiledBindingSupportingAttributes, blockType)])))
-                            .return(supportedAttributes)
-                            .endIf()
-                            .call("array_push", [supportedAttributes, new expressions_1.Op("...", new expressions_1.ArrayAccess(compiledBindingSupportingAttributes, blockType))])
-                            .return(supportedAttributes);
-                    }, { functionArgParameters: [supportedAttributes, blockType], useVars: [compiledBindingSupportingAttributes] });
-                }
-                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [
-                    expressions_1.Constants.__DIR__, // string $dir
-                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")), // array $blockdirConfig
-                    expressions_1.Constants.__FILE__, // string $blockdirConfigFile
-                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(finalizedMetadata, false, "\t")), // array $metadata
-                    null // ?string $urlPrefix
-                ]);
-                for (const inlinableScript of inlinableScripts) {
-                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableScript);
-                }
-                for (const inlinableStyle of inlinableStyles) {
-                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableStyle);
-                }
-            }, { accountForAlreadyDoing: this.config.includePostInitFallback });
-            if (this.config.useBlockSupportsAsThemeJsonDefaults) {
-                const copyableBlockSupports = [];
-                for (const { name, supports } of Object.values(blockData)) {
-                    if (typeof name === 'string' && !!name && typeof supports === 'object' && !!supports && !Array.isArray(supports)) {
-                        const flagProps = EnhancedBlockJSONPlugin.pickOutFlagPropsFromBlockSupports(supports);
-                        if (flagProps) {
-                            copyableBlockSupports.push([name, flagProps]);
-                        }
-                    }
-                }
-                if (copyableBlockSupports.length > 0) {
-                    const themeJsonBlockSettings = new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)({
-                        version: 3,
-                        settings: {
-                            blocks: Object.fromEntries(copyableBlockSupports)
-                        }
-                    }, false, "\t"));
-                    const theme_json = new expressions_1.Var("theme_json");
-                    writer.filter('wp_theme_json_data_blocks', writer => {
-                        const updateCall = new expressions_1.Call(expressions_1.Literal.of("update_with", true), [themeJsonBlockSettings]);
-                        writer.appendExpr(new expressions_1.InstanceAccess(theme_json, [updateCall]), { return: true });
-                    }, { functionArgParameters: [theme_json] });
-                }
-            }
-            (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, (0, node_path_1.join)(this.dest.destination, "blockdir-loader.php"));
-        }
-        else {
-            compilation.emitAsset((0, node_path_1.join)(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
-        }
-    }
-    /*
-     * The block supports that have a boolean counterpart under theme.json's settings, as
-     * `settings key -> {support prop: settings prop}`. This is an allow-list rather than an ignore-list
-     * because most supports (align, alignWide, anchor, contentRole, inserter, interactivity, listView,
-     * plaudit, ...) have no theme.json settings equivalent at all, and the ones that do don't always
-     * share a name: typography's fontSize is settings.typography.customFontSize, and Gutenberg still
-     * ships several of these under an __experimental prefix.
-     */
-    static THEME_JSON_FLAG_PROPS = {
-        color: { background: 'background', link: 'link', text: 'text' },
-        dimensions: { aspectRatio: 'aspectRatio', minHeight: 'minHeight' },
-        spacing: { blockGap: 'blockGap', margin: 'margin', padding: 'padding' },
-        typography: {
-            fontSize: 'customFontSize',
-            lineHeight: 'lineHeight',
-            textAlign: 'textAlign',
-            fontStyle: 'fontStyle', __experimentalFontStyle: 'fontStyle',
-            fontWeight: 'fontWeight', __experimentalFontWeight: 'fontWeight',
-            letterSpacing: 'letterSpacing', __experimentalLetterSpacing: 'letterSpacing',
-            textDecoration: 'textDecoration', __experimentalTextDecoration: 'textDecoration',
-            textTransform: 'textTransform', __experimentalTextTransform: 'textTransform',
-            writingMode: 'writingMode', __experimentalWritingMode: 'writingMode'
-        }
-    };
-    static pickOutFlagPropsFromBlockSupports(supports) {
-        function isRecord(value) {
-            return typeof value === 'object' && !!value && !Array.isArray(value);
-        }
-        let addedProp = false;
-        const res = {};
-        for (const [settingsKey, props] of Object.entries(EnhancedBlockJSONPlugin.THEME_JSON_FLAG_PROPS)) {
-            const support = supports[settingsKey];
-            if (!isRecord(support)) {
-                continue;
-            }
-            const flags = {};
-            for (const [supportProp, settingsProp] of Object.entries(props)) {
-                // A sided support such as `"margin": ["top", "bottom"]` is still just "on" as far as theme.json is concerned
-                if (support[supportProp]) {
-                    flags[settingsProp] = true;
-                    res[settingsKey] = flags;
-                    addedProp = true;
-                }
-            }
-        }
-        return addedProp ? res : undefined;
-    }
-    callRegisterFunction(type, writer, baseUriVar, handles) {
-        for (const [name, { src, rest }] of handles) {
-            writer.call(`wp_register_${type}`, [name, src === false ? false : expressions_1.Op.concat(baseUriVar, src), ...rest]);
-        }
-    }
-    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 = {};
-        const bindableBlockAttributes = {};
-        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 = (0, node_path_1.dirname)(blockJsonSourcePath);
-            const outputDir = (0, node_path_1.join)(compilation.compiler.outputPath, (0, node_path_1.dirname)(blockJsonAssetName));
-            const blockJson = JSON.parse(blockJsonText);
-            const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
-            EnhancedBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
-            EnhancedBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "variations", pathsNeedRemapping, sourceDir, outputDir, compilation, false);
-            EnhancedBlockJSONPlugin.handleExperimentalBlockSupportsFlags(blockJson);
-            const hashForVersion = EnhancedBlockJSONPlugin
-                .hashThingForAsset([blockJsonText, ...workableBlockEntrypointsInfo.map(bi => bi.hash)].join("~"));
-            if (blockJson["version"]) {
-                blockJson["version"] = `${blockJson["version"]}-${hashForVersion}`;
-            }
-            else {
-                blockJson["version"] = hashForVersion;
-            }
-            if (typeof blockJson["name"] === 'string' && typeof blockJson["attributes"] === 'object' && blockJson["attributes"]) {
-                for (const [name, attr] of Object.entries(blockJson["attributes"])) {
-                    if (attr["supports-bindings"]) {
-                        delete attr["supports-bindings"];
-                        if (bindableBlockAttributes[blockJson["name"]] !== undefined) {
-                            bindableBlockAttributes[blockJson["name"]].push(name);
-                        }
-                        else {
-                            bindableBlockAttributes[blockJson["name"]] = [name];
-                        }
-                    }
-                }
-            }
-            EnhancedBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
-            const blockDirName = (0, node_path_1.dirname)((0, node_path_1.relative)(this.dest.destination, blockJsonAssetName));
-            blockData[blockDirName] = EnhancedBlockJSONPlugin
-                .doFileOrHandleReplacements(compilation, Object.fromEntries(Object.entries(blockJson).filter(([k]) => k !== '$schema')), workableBlockEntrypointsInfo, epi => epi.handle);
-            const emittableBlockJson = EnhancedBlockJSONPlugin.doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, epi => "file:./" + (0, node_path_1.relative)(blockDirName, epi.outputPath));
-            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(emittableBlockJson, undefined, "  ")));
-        }
-        return {
-            __metadata: {
-                version: 3,
-                "wpml-config": emittingWpmlXml,
-                scriptHandles: Object.fromEntries(EnhancedBlockJSONPlugin
-                    .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && !(0, shared_1.isScriptModuleField)(hd.entrypointField)))),
-                scriptModuleHandles: Object.fromEntries(EnhancedBlockJSONPlugin
-                    .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 => {
-                    if (hd.inlinedAsset === undefined) {
-                        return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version], assetContents: hd.assetContents }];
-                    }
-                    return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version], inlinedAsset: hd.inlinedAsset, assetContents: hd.assetContents }];
-                })),
-                bindableBlockAttributes
-            },
-            ...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 => {
-            const { assetContents, inlinedAsset, originalValue, outputPath, entrypointField, scriptArgsObject: rawScriptArgsObject, assetData, handle } = hd;
-            const { dependencies = [], module_dependencies = undefined } = originalValue !== undefined ? assetData : {};
-            let scriptArgsObject;
-            if (rawScriptArgsObject !== undefined) {
-                const merged_module_dependencies = (0, shared_1.mergeModuleDependencyArrays)(rawScriptArgsObject.module_dependencies, module_dependencies);
-                scriptArgsObject = merged_module_dependencies?.length ? { ...rawScriptArgsObject, module_dependencies: merged_module_dependencies } : { ...rawScriptArgsObject };
-            }
-            else {
-                if (inlinedAsset !== undefined) {
-                    scriptArgsObject = inlinedAsset.position === 'before' ? { strategy: "defer" } : undefined;
-                }
-                else if (!entrypointField.startsWith("editor")) {
-                    scriptArgsObject = { strategy: "defer" };
-                }
-                else {
-                    scriptArgsObject = undefined;
-                }
-                if (module_dependencies?.length) {
-                    if (scriptArgsObject === undefined) {
-                        scriptArgsObject = { module_dependencies };
-                    }
-                    else {
-                        scriptArgsObject.module_dependencies = module_dependencies;
-                    }
-                }
-            }
-            const rest = scriptArgsObject !== undefined ? [dependencies, assetData.version, scriptArgsObject] : [dependencies, assetData.version];
-            if (inlinedAsset) {
-                return [handle, { src: outputPath, rest, inlinedAsset, assetContents }];
-            }
-            else {
-                return [handle, { src: outputPath, rest, assetContents }];
-            }
-        });
-    }
-    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) {
-        return this.dest.destination && file.startsWith(this.dest.destination + "/") ? file.substring(this.dest.destination.length + 1 /* we also need to drop the "/" */) : file;
-    }
-    static hashThingForAsset(thing) {
-        return (0, node_crypto_1.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 => (0, node_path_1.normalize)(p).split(node_path_1.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 = EnhancedBlockJSONPlugin.findCommonAncestor(path1, path2);
-        return (".." + node_path_1.sep).repeat(path1.split(node_path_1.sep).length - commonAncestor.length) + (0, node_path_1.relative)(commonAncestor.join(node_path_1.sep), path2);
-    }
-    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`, (0, node_path_1.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 => (0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
-                .filter(node_fs_1.existsSync)
-                .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
-            : rawFiles
-                .filter(p => (0, node_fs_1.existsSync)((0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.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 => (0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
-                .filter(node_fs_1.existsSync)
-                .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
-            : rawRenderTemplate
-                .filter(p => (0, node_fs_1.existsSync)((0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.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. Please set the render key in block.json to the intended one", (0, node_path_1.join)(sourceDir, 'block.json')));
-                blockJson[validTemplateLocation] = renderTemplate.find(p => p.endsWith(".php")) ?? renderTemplate[0];
-            }
-            else {
-                blockJson[validTemplateLocation] = renderTemplate[0];
-            }
-        }
-    }
-    static knownExperimentalProperties = ['border', 'defaultControls', 'fontFamily', 'fontWeight', 'fontStyle', 'letterSpacing', 'textTransform', 'textDecoration']
-        .map(prop => [prop, "__experimental" + prop.substring(0, 1).toUpperCase() + prop.substring(1)]);
-    static handleExperimentalBlockSupportsFlags(blockSupports) {
-        for (const [key, value] of Object.entries(blockSupports)) {
-            if (typeof value === 'object' && !!value && !Array.isArray(value)) {
-                EnhancedBlockJSONPlugin.handleExperimentalBlockSupportsFlags(value);
-            }
-            if (!key.startsWith("__experimental")) {
-                continue;
-            }
-            const realKey = key.substring(14, 15).toLowerCase() + key.substring(15);
-            if (!(realKey in blockSupports)) {
-                blockSupports[realKey] = value;
-            }
-        }
-        // This handles known currently-experimental properties
-        for (const [eventualKey, experimentalKey] of EnhancedBlockJSONPlugin.knownExperimentalProperties) {
-            if (eventualKey in blockSupports && !(experimentalKey in blockSupports)) {
-                blockSupports[experimentalKey] = blockSupports[eventualKey];
-            }
-        }
-    }
-    attachUniquePhase(compilation) {
-        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-            const allSemaphoreData = (await EnhancedBlockJSONPlugin.semaphore.wait())
-                .reduce((acc, cur) => {
-                (acc[cur.blocksDest] ?? (acc[cur.blocksDest] = [])).push(cur);
-                return acc;
-            }, {});
-            const semaphoreData = allSemaphoreData[this.dest.destination];
-            if (semaphoreData === undefined) {
-                compilation.errors.push(new Error(`Semaphore data missing for ${this.dest.destination}`));
-                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, this.deduplicateEntrypointHandles(workableBlockInfo), semaphoreData.some(sd => sd.emittingWpmlXml));
-            this.emitBlockLoaderFile(compilation, blockData);
-        });
-    }
-    attachStandardPhase(compilation) {
-        super.attachStandardPhase(compilation);
-        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER }, async () => {
-            const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
-            for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-                if ((0, node_path_1.basename)(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
-                    continue;
-                }
-                const entrypointChunk = entrypoint.getEntrypointChunk();
-                for (const danglingBlockJsFile of [...entrypointChunk.files, ...entrypointChunk.auxiliaryFiles]) {
-                    if (!danglingBlockJsFile.endsWith("block.json")) {
-                        compilation.deleteAsset(danglingBlockJsFile);
-                    }
-                }
-            }
-        });
-    }
-    deduplicateEntrypointHandles(workableBlockInfo) {
-        const handleRecords = { scriptHandles: {}, scriptModuleHandles: {}, styleHandles: {} };
-        for (const { workableBlockEntrypointsInfo } of Object.values(workableBlockInfo)) {
-            for (const { handleGroup, handle, originalValue, outputPath } of workableBlockEntrypointsInfo) {
-                if (originalValue !== undefined) {
-                    handleRecords[handleGroup][handle] = outputPath;
-                }
-            }
-        }
-        return Object.fromEntries(Object.entries(workableBlockInfo).map((e) => {
-            const deduplicatedWorkableBlockEntrypointsInfo = e[1].workableBlockEntrypointsInfo.map(bei => {
-                if (handleRecords[bei.handleGroup][bei.handle] === bei.outputPath) {
-                    return bei;
-                }
-                for (let count = 1, handle = `${bei.handle}_${count}`;; handle = `${bei.handle}_${++count}`) {
-                    if (!handleRecords[bei.handleGroup][handle] || handleRecords[bei.handleGroup][handle] === bei.outputPath) {
-                        return { ...bei, handle };
-                    }
-                }
-            });
-            return [e[0], { ...e[1], workableBlockEntrypointsInfo: deduplicatedWorkableBlockEntrypointsInfo }];
-        }));
-    }
-}
-exports.EnhancedBlockJSONPlugin = EnhancedBlockJSONPlugin;