@plaudit/webpack-extensions 2.37.0 → 2.39.0

package/build/wordpress-scripts-wrapper/BlockJSONManagingPlugin.d.ts

@@ -1,14 +1,17 @@
-import { type Compilation, type Compiler, type WebpackPluginInstance } from "webpack";
+import { Compilation, type Compiler, type WebpackPluginInstance } from "webpack";
 export default class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private readonly standaloneBlocks;
     private readonly processingModules;
     static readonly mappableModuleKeys: readonly ["viewScriptModule", "scriptModule"];
     static readonly mappableNonModuleKeys: readonly ["editorStyle", "style", "viewStyle", "editorScript", "script", "viewScript"];
+    private static readonly styleExtensionPattern;
+    private static readonly scriptExtensionPattern;
     private static readonly mappableKeys;
     private static readonly blockJsonToEntrypointsMap;
     private static readonly blockJsonRawDependenciesMap;
     private static readonly blockJSONAssetSourceDirs;
     private static readonly blockJsonAssetKeyMapping;
+    private static readonly blockJsonAssetKeyReadinessMapping;
     constructor(standaloneBlocks: boolean, processingModules: boolean);
     static recordRawDependency(entrypoint: string, dependency: string): void;
     static recordBlockJSONAssetSourceDir(entrypoint: string, source: string): void;
@@ -24,4 +27,9 @@ export default class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private static remapReferencedAssetFile;
     private static getReferencedFileSlot;
     private static addAssetToBlockJsonKey;
+    private registerAssetProcessor;
+    private static populateEntrypointsMap;
+    private registerBlockJsonProcessor;
+    private static normalizeRenderTemplate;
+    private static getSyncs;
 }

package/build/wordpress-scripts-wrapper/BlockJSONManagingPlugin.js

@@ -13,11 +13,14 @@ class BlockJSONManagingPlugin {
     processingModules;
     static mappableModuleKeys = ["viewScriptModule", "scriptModule"];
     static mappableNonModuleKeys = ["editorStyle", "style", "viewStyle", "editorScript", "script", "viewScript"];
+    static styleExtensionPattern = /\.(p?c|sa)ss$/i;
+    static scriptExtensionPattern = /\.m?[tj]sx?$/i;
     static mappableKeys = [...BlockJSONManagingPlugin.mappableNonModuleKeys, ...BlockJSONManagingPlugin.mappableModuleKeys];
     static blockJsonToEntrypointsMap = new Map();
     static blockJsonRawDependenciesMap = new Map();
     static blockJSONAssetSourceDirs = new Map();
     static blockJsonAssetKeyMapping = new Map();
+    static blockJsonAssetKeyReadinessMapping = new Map();
     constructor(standaloneBlocks, processingModules) {
         this.standaloneBlocks = standaloneBlocks;
         this.processingModules = processingModules;
@@ -34,171 +37,10 @@ class BlockJSONManagingPlugin {
     }
     apply(compiler) {
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_ProcessBlockJSONFiles`, compilationAssets => {
-                const testableCompilationAssets = this.processingModules ? BlockJSONManagingPlugin.buildFakeCompilationAssets(compilation) : compilationAssets;
-                const currentBlockJSONAssets = BlockJSONManagingPlugin.blockJSONAssetSourceDirs.entries()
-                    .filter(([name]) => name in testableCompilationAssets)
-                    .toArray();
-                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 additionalFiles = [];
-                            for (const entrypointChunkFile of entrypointChunk.files) {
-                                if (!entrypointChunkFile.endsWith(".asset.php") && entrypointChunkFile !== destPath) {
-                                    additionalFiles.push(entrypointChunkFile);
-                                }
-                            }
-                            const entryMeta = { hash: entrypointChunk.hash ?? destPath, path: destPath };
-                            const currentEntrypoints = BlockJSONManagingPlugin.blockJsonToEntrypointsMap.get(name);
-                            if (currentEntrypoints) {
-                                currentEntrypoints.set(srcPath, [entryMeta, additionalFiles]);
-                            }
-                            else {
-                                BlockJSONManagingPlugin.blockJsonToEntrypointsMap.set(name, new Map([[srcPath, [entryMeta, additionalFiles]]]));
-                            }
-                        }
-                    }
-                }
-                //TODO: Fix modules support when running in non-dev mode
-                const blockDirConfigData = {};
-                for (const [name, sourceDir] of currentBlockJSONAssets) {
-                    const assetContents = this.processingModules ? node_fs_1.default.readFileSync(testableCompilationAssets[name], 'utf8') : compilation.assets[name]?.buffer().toString();
-                    if (!assetContents) {
-                        continue;
-                    }
-                    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 assetKeyMappings = { ...BlockJSONManagingPlugin.blockJsonAssetKeyMapping.get(name), [this.processingModules ? 'module' : 'nonModule']: currentAssetKeyMappings };
-                    BlockJSONManagingPlugin.blockJsonAssetKeyMapping.set(name, assetKeyMappings);
-                    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);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    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(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);
-                    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];
-                        }
-                    }
-                    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;
-                }
-                const sortedBlockDirConfigData = Object.fromEntries(Object.entries(blockDirConfigData)
-                    .sort(([a], [b]) => a.localeCompare(b)));
-                compilation.emitAsset("blockdir.config", new webpack_1.sources.RawSource((0, php_serializer_1.default)(sortedBlockDirConfigData, { excludedKeys: ["$schema"] })));
-            });
+            this.registerAssetProcessor(compilation);
+            if (!this.processingModules) {
+                this.registerBlockJsonProcessor(compilation);
+            }
         });
     }
     static resolveDestinationBySourceExtension(srcPath, entrypoint) {
@@ -331,7 +173,15 @@ class BlockJSONManagingPlugin {
                 const prefix = value.startsWith("./", 5) ? "./" : "";
                 const relativePath = node_path_1.default.relative(node_path_1.default.dirname(name), output.path);
                 const res = [`file:${prefix}${relativePath}`, output.hash];
-                return [res, additionalFiles.map(additionalFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), additionalFile)}`)];
+                if (BlockJSONManagingPlugin.styleExtensionPattern.test(output.path)) {
+                    return [res,
+                        additionalFiles.filter(additionalFile => !BlockJSONManagingPlugin.scriptExtensionPattern.test(additionalFile))
+                            .map(additionalFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), additionalFile)}`)
+                    ];
+                }
+                else {
+                    return [res, additionalFiles.map(additionalFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), additionalFile)}`)];
+                }
             }
         }
         return [[value, ""], []];
@@ -373,5 +223,227 @@ class BlockJSONManagingPlugin {
             }
         }
     }
+    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.getSyncs(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 additionalFiles = [];
+                    for (const entrypointChunkFile of entrypointChunk.files) {
+                        if (!entrypointChunkFile.endsWith(".asset.php") && entrypointChunkFile !== destPath) {
+                            additionalFiles.push(entrypointChunkFile);
+                        }
+                    }
+                    const entryMeta = { hash: entrypointChunk.hash ?? destPath, path: destPath };
+                    const currentEntrypoints = BlockJSONManagingPlugin.blockJsonToEntrypointsMap.get(name);
+                    if (currentEntrypoints) {
+                        currentEntrypoints.set(srcPath, [entryMeta, additionalFiles]);
+                    }
+                    else {
+                        BlockJSONManagingPlugin.blockJsonToEntrypointsMap.set(name, new Map([[srcPath, [entryMeta, additionalFiles]]]));
+                    }
+                }
+            }
+        }
+    }
+    registerBlockJsonProcessor(compilation) {
+        const blockDirConfigData = {};
+        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;
+            }
+            const sortedBlockDirConfigData = Object.fromEntries([["__metadata", { version: 1 }], ...Object.entries(blockDirConfigData)
+                    .sort(([a], [b]) => a.localeCompare(b))]);
+            compilation.emitAsset("blockdir.config", new webpack_1.sources.RawSource((0, php_serializer_1.default)(sortedBlockDirConfigData, { excludedKeys: ["$schema"] })));
+        });
+    }
+    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];
+            }
+        }
+    }
+    static getSyncs(name) {
+        const res = BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.get(name);
+        if (res) {
+            return res;
+        }
+        BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.set(name, { nonModule: makeSync(), module: makeSync() });
+        return BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.get(name);
+    }
 }
 exports.default = BlockJSONManagingPlugin;
+function makeSync() {
+    const res = { done: false };
+    res.sync = new Promise((resolve, reject) => {
+        res.resolve = (v) => resolve(v);
+        res.reject = () => reject();
+    });
+    return res;
+}

package/build/wordpress-scripts-wrapper/dependency-extraction-webpack-plugin-config-builder.d.ts

@@ -0,0 +1,9 @@
+import DependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
+export type IndividualExternalDepConfig = string | {
+    import?: string | [string, ...string[]];
+    handle: string;
+};
+export type Externals = {
+    [dep: string]: IndividualExternalDepConfig;
+};
+export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean): false | DependencyExtractionWebpackPlugin;

package/build/wordpress-scripts-wrapper/dependency-extraction-webpack-plugin-config-builder.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDependencyExtractionPlugin = makeDependencyExtractionPlugin;
+const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
+function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries) {
+    if (!externals) {
+        if (assumeGlobalizedPlauditLibraries) {
+            return new dependency_extraction_webpack_plugin_1.default({
+                requestToExternal: plauditRequestToExternal,
+                requestToHandle: plauditRequestToHandle
+            });
+        }
+        return false;
+    }
+    const exactExternals = {};
+    const suffixExternals = [];
+    for (const [key, value] of Object.entries(externals)) {
+        const normalizedValue = typeof value !== 'string' && value.import === undefined ? { ...value, import: key } : value;
+        if (key.startsWith("*/")) {
+            suffixExternals.push([key.substring(1), typeof normalizedValue === 'string' ? { import: normalizedValue, handle: key.substring(2) } : normalizedValue]);
+        }
+        else {
+            exactExternals[key] = normalizedValue;
+        }
+    }
+    const resolvePossibleExternal = (request) => {
+        if (request in exactExternals) {
+            return exactExternals[request];
+        }
+        for (const [key, value] of suffixExternals) {
+            if (request.endsWith(key)) {
+                return value;
+            }
+        }
+        return undefined;
+    };
+    const baselineRequestToExternal = request => {
+        const possibleExternal = resolvePossibleExternal(request);
+        if (typeof possibleExternal === 'string') {
+            return possibleExternal;
+        }
+        else if (possibleExternal !== undefined) {
+            return possibleExternal['import'];
+        }
+        return undefined;
+    };
+    const baselineRequestToHandle = request => {
+        const possibleExternal = resolvePossibleExternal(request);
+        if (possibleExternal !== undefined && typeof possibleExternal !== 'string') {
+            return possibleExternal.handle;
+        }
+        return undefined;
+    };
+    return assumeGlobalizedPlauditLibraries
+        ? new dependency_extraction_webpack_plugin_1.default({
+            requestToExternal: curryRequestHandlers(baselineRequestToExternal, plauditRequestToExternal),
+            requestToHandle: curryRequestHandlers(baselineRequestToHandle, plauditRequestToHandle),
+        })
+        : new dependency_extraction_webpack_plugin_1.default({
+            requestToExternal: baselineRequestToExternal,
+            requestToHandle: baselineRequestToHandle,
+        });
+}
+const PLAUDIT_NAMESPACE = '@plaudit/';
+const EXTERNALIZABLE_PLAUDIT_LIBRARIES = ['@plaudit/library-extensions'];
+function plauditRequestToExternal(request) {
+    if (EXTERNALIZABLE_PLAUDIT_LIBRARIES.includes(request)) {
+        return ['plaudit', camelCaseDash(request.substring(PLAUDIT_NAMESPACE.length))];
+    }
+    else if (request.startsWith('@plaudit/gutenberg-api-extensions')) {
+        return ['plaudit', 'gutenbergApiExtensions'];
+    }
+    return undefined;
+}
+function plauditRequestToHandle(request) {
+    if (EXTERNALIZABLE_PLAUDIT_LIBRARIES.includes(request)) {
+        return 'plaudit-' + request.substring(PLAUDIT_NAMESPACE.length);
+    }
+    else if (request.startsWith('@plaudit/gutenberg-api-extensions')) {
+        return 'plaudit-gutenberg-api-extensions';
+    }
+    return undefined;
+}
+function curryRequestHandlers(primary, secondary) {
+    return (...args) => primary(...args) ?? secondary(...args);
+}
+/**
+ * Copied from @wordpress/dependency-extraction-webpack-plugin for consistency
+ */
+function camelCaseDash(string) {
+    return string.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}

package/build/wordpress-scripts-wrapper.d.ts

@@ -1,3 +1,4 @@
+import { type Externals } from "./wordpress-scripts-wrapper/dependency-extraction-webpack-plugin-config-builder";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
 import type { Configuration } from "webpack";
 interface AdvancedOutputConfig {
@@ -5,14 +6,8 @@ interface AdvancedOutputConfig {
     withLegacyBlocksIn?: string | undefined;
     additionalDependencies?: string[];
     directoryLayout?: 'blocks' | 'extensions';
+    assumeGlobalizedPlauditLibraries?: boolean;
 }
-type IndividualExternalDepConfig = string | {
-    import?: string | [string, ...string[]];
-    handle: string;
-};
-type Externals = {
-    [dep: string]: IndividualExternalDepConfig;
-};
 type PlauditWordpressWebpackConfig = {
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
@@ -23,6 +18,7 @@ type PlauditWordpressWebpackConfig = {
         functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
     };
     externals?: Externals;
+    assumeGlobalizedPlauditLibraries?: boolean;
 };
 declare const _default: (config: PlauditWordpressWebpackConfig, webpackConfig?: Configuration[] | Configuration) => Configuration[];
 export = _default;

package/build/wordpress-scripts-wrapper.js

@@ -6,6 +6,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const AdditionalDependencyInjectorPlugin_1 = __importDefault(require("./wordpress-scripts-wrapper/AdditionalDependencyInjectorPlugin"));
 const BlockJSONManagingPlugin_1 = __importDefault(require("./wordpress-scripts-wrapper/BlockJSONManagingPlugin"));
+const dependency_extraction_webpack_plugin_config_builder_1 = require("./wordpress-scripts-wrapper/dependency-extraction-webpack-plugin-config-builder");
 const ExtensionsConfigFileGeneratorPlugin_1 = __importDefault(require("./wordpress-scripts-wrapper/ExtensionsConfigFileGeneratorPlugin"));
 const MiniCSSExtractPluginErrorCleaner_1 = __importDefault(require("./wordpress-scripts-wrapper/MiniCSSExtractPluginErrorCleaner"));
 const VariablesJSMonitorPlugin_1 = __importDefault(require("./wordpress-scripts-wrapper/VariablesJSMonitorPlugin"));
@@ -233,49 +234,6 @@ function parseEntrypointsJSON(dir) {
         });
     }
 }
-function makeDependencyExtractionPlugin(externals) {
-    const exactExternals = {};
-    const suffixExternals = [];
-    for (const [key, value] of Object.entries(externals)) {
-        const normalizedValue = typeof value !== 'string' && value.import === undefined ? { ...value, import: key } : value;
-        if (key.startsWith("*/")) {
-            suffixExternals.push([key.substring(1), typeof normalizedValue === 'string' ? { import: normalizedValue, handle: key.substring(2) } : normalizedValue]);
-        }
-        else {
-            exactExternals[key] = normalizedValue;
-        }
-    }
-    const resolvePossibleExternal = (request) => {
-        if (request in exactExternals) {
-            return exactExternals[request];
-        }
-        for (const [key, value] of suffixExternals) {
-            if (request.endsWith(key)) {
-                return value;
-            }
-        }
-        return undefined;
-    };
-    return new dependency_extraction_webpack_plugin_1.default({
-        requestToExternal(request) {
-            const possibleExternal = resolvePossibleExternal(request);
-            if (typeof possibleExternal === 'string') {
-                return possibleExternal;
-            }
-            else if (possibleExternal !== undefined) {
-                return possibleExternal['import'];
-            }
-            return undefined;
-        },
-        requestToHandle(request) {
-            const possibleExternal = resolvePossibleExternal(request);
-            if (possibleExternal !== undefined && typeof possibleExternal !== 'string') {
-                return possibleExternal.handle;
-            }
-            return undefined;
-        }
-    });
-}
 function processIndividualWebpackConfig(config, webpackConfig, sources) {
     let scriptExtension; // This is only used in non-block contexts. It might not actually be necessary, but it is good to have
     let entrypointFields;
@@ -288,7 +246,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         scriptExtension = scriptWithoutModuleExtension;
         entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
     }
-    const { standaloneBlocks, variablesFilePath, verbose, externals } = config;
+    const { standaloneBlocks, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries } = config;
     let currentVariables = config.currentVariables;
     const fixedRules = [
         replaceDefaultURLProcessing,
@@ -351,13 +309,14 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         if (srcIsDirectory && (typeof dest !== 'string' && dest.directoryLayout === 'extensions')) {
             plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.default(srcRoot));
         }
-        if (externals) {
-            const pluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
-            if (pluginIndex === -1) {
-                console.error("Cannot apply externals when they have been disabled via CLI flag.");
-            }
-            else {
-                plugins[pluginIndex] = makeDependencyExtractionPlugin(externals);
+        const pluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
+        if (pluginIndex === -1) {
+            console.error("Cannot apply externals when they have been disabled via CLI flag. This will greatly increase bundle size and will likely cause the build to file");
+        }
+        else {
+            const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, (typeof dest !== 'string' ? dest.assumeGlobalizedPlauditLibraries : undefined) ?? assumeGlobalizedPlauditLibraries);
+            if (builtDependencyExtractionWebpackPlugin) {
+                plugins[pluginIndex] = builtDependencyExtractionWebpackPlugin;
             }
         }
         if (process.argv.includes('--browser-sync') || process.env['BROWSER_SYNC'] === 'true') {
@@ -510,13 +469,13 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
 }
 module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
     testForDuplicatedEntryPaths(config);
-    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals } = config;
+    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true } = config;
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
         variablesFilePath = ["variables.js", "src/site/variables.js"].map(p => node_path_1.default.join(process.cwd(), p)).filter(p => node_fs_1.default.existsSync(p))[0];
     }
-    const cfg = { currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals };
+    const cfg = { currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries };
     const sources = Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src);
     if (Array.isArray(webpackConfig)) {
         return webpackConfig.toSorted((a, b) => {

package/package.json

@@ -1,74 +1,91 @@
 {
-  "name": "@plaudit/webpack-extensions",
-  "version": "2.37.0",
-  "license": "UNLICENSED",
-  "scripts": {
-    "prepublishOnly": "rm -rf build && mkdir build && tsc",
-    "build": "tsc",
-    "watch": "tsc -w"
-  },
-  "files": [
-    "/build"
-  ],
-  "exports": {
-    "./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js"
-  },
-  "typesVersions": {
-    "*": {
-      "wordpress-scripts-wrapper": [
-        "build/wordpress-scripts-wrapper.d.ts"
-      ]
-    }
-  },
-  "devDependencies": {
-    "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/postcss-functions": "^4.0.4",
-    "@types/node": "^22.9.0",
-    "@types/tapable": "^2.2.7",
-    "@types/webpack": "^5.28.5",
-    "@types/webpack-sources": "^3.2.3",
-    "postcss-load-config": "^4.0.2",
-    "postcss-loader": "^7.3.4",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.3"
-  },
-  "dependencies": {
-    "@plaudit/postcss-color-function": "^5.0.0",
-    "@plaudit/postcss-silent-extend": "^3.0.0",
-    "@plaudit/postcss-strip-units": "^3.0.0",
-    "@plaudit/postcss-variables": "^1.0.0",
-	"@wordpress/dependency-extraction-webpack-plugin": "^6.11.0",
-    "@wordpress/scripts": "^30.4.0",
-    "autoprefixer": "^10.4.19",
-    "browser-sync": "^3.0.3",
-    "clean-webpack-plugin": "^4.0.0",
-    "copy-webpack-plugin": "^12.0.2",
-    "cssnano": "^6.1.2",
-    "eslint": "^8.57.0",
-    "eslint-plugin-jsdoc": "^48.2.3",
-    "fork-ts-checker-webpack-plugin": "^9.0.2",
-    "http-proxy-middleware": "^3.0.3",
-    "postcss": "^8.4.39",
-    "postcss-calc": "^9.0.1",
-    "postcss-discard-comments": "^6.0.2",
-    "postcss-fallback": "^0.1.0",
-    "postcss-functions": "^4.0.2",
-    "postcss-import": "^16.1.0",
-    "postcss-inline-svg": "^6.0.0",
-    "postcss-media-minmax": "^5.0.0",
-    "postcss-mixins": "6.2.3",
-    "postcss-nested": "^6.0.1",
-    "postcss-property-lookup": "^3.0.0",
-    "postcss-quantity-queries": "^0.5.0",
-    "postcss-reporter": "^7.1.0",
-    "postcss-short-position": "^4.0.1",
-    "postcss-short-size": "^4.0.0",
-    "postcss-short-spacing": "^4.0.0",
-    "postcss-simple-vars": "^7.0.1",
-    "postcss-url": "^10.1.3",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "webpack": "^5.96.1",
-    "webpack-remove-empty-scripts": "^1.0.4"
-  }
+	"name": "@plaudit/webpack-extensions",
+	"version": "2.39.0",
+	"license": "UNLICENSED",
+	"scripts": {
+		"prepublishOnly": "rm -rf build && mkdir build && tsc",
+		"build": "tsc",
+		"watch": "tsc -w"
+	},
+	"files": [
+		"/build"
+	],
+	"exports": {
+		"./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js"
+	},
+	"typesVersions": {
+		"*": {
+			"wordpress-scripts-wrapper": [
+				"build/wordpress-scripts-wrapper.d.ts"
+			]
+		}
+	},
+	"devDependencies": {
+		"@types/browser-sync-webpack-plugin": "^2.2.5",
+		"@types/node": "^22.13.10",
+		"@types/postcss-functions": "^4.0.4",
+		"@types/tapable": "^2.2.7",
+		"@types/webpack": "^5.28.5",
+		"@types/webpack-sources": "^3.2.3",
+		"postcss-load-config": "^4.0.2",
+		"postcss-loader": "^7.3.4",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.8.2"
+	},
+	"dependencies": {
+		"@plaudit/postcss-color-function": "^5.0.0",
+		"@plaudit/postcss-silent-extend": "^3.0.0",
+		"@plaudit/postcss-strip-units": "^3.0.0",
+		"@plaudit/postcss-variables": "^1.1.0",
+		"@wordpress/dependency-extraction-webpack-plugin": "^6.20.0",
+		"@wordpress/scripts": "^30.13.0",
+		"autoprefixer": "^10.4.21",
+		"browser-sync": "^3.0.3",
+		"clean-webpack-plugin": "^4.0.0",
+		"copy-webpack-plugin": "^12.0.2",
+		"cssnano": "^6.1.2",
+		"eslint": "^8.57.1",
+		"eslint-plugin-jsdoc": "^48.11.0",
+		"fork-ts-checker-webpack-plugin": "^9.0.2",
+		"http-proxy-middleware": "^3.0.3",
+		"postcss": "^8.5.3",
+		"postcss-calc": "^9.0.1",
+		"postcss-discard-comments": "^6.0.2",
+		"postcss-fallback": "^0.1.0",
+		"postcss-functions": "^4.0.2",
+		"postcss-import": "^16.1.0",
+		"postcss-inline-svg": "^6.0.0",
+		"postcss-media-minmax": "^5.0.0",
+		"postcss-mixins": "6.2.3",
+		"postcss-nested": "^6.2.0",
+		"postcss-property-lookup": "^3.0.0",
+		"postcss-quantity-queries": "^0.5.0",
+		"postcss-reporter": "^7.1.0",
+		"postcss-short-position": "^4.0.1",
+		"postcss-short-size": "^4.0.0",
+		"postcss-short-spacing": "^4.0.0",
+		"postcss-simple-vars": "^7.0.1",
+		"postcss-url": "^10.1.3",
+		"react": "^18.3.1",
+		"react-dom": "^18.3.1",
+		"webpack": "^5.98.0",
+		"webpack-remove-empty-scripts": "^1.0.4"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"pnpm": {
+		"onlyBuiltDependencies": [
+			"core-js",
+			"core-js-pure"
+		],
+		"ignoredBuiltDependencies": [
+			"@parcel/watcher"
+		],
+		"overrides": {
+			"micromatch": "^4",
+			"react-autosize-textarea>react": "*",
+			"react-autosize-textarea>react-dom": "*"
+		}
+	}
 }