@plaudit/webpack-extensions 2.39.0 → 2.41.0

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

@@ -2,6 +2,7 @@ import { type Compiler, type WebpackPluginInstance } from "webpack";
 export default class AdditionalDependencyInjectorPlugin implements WebpackPluginInstance {
     private readonly entrypointAdditionalDependencies;
     private readonly processingModules;
-    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean);
+    private readonly addExternalizedDep;
+    constructor(entrypointAdditionalDependencies: string[], processingModules: boolean, addExternalizedDep: (dep: string) => void);
     apply(compiler: Compiler): void;
 }

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

@@ -8,53 +8,46 @@ const webpack_1 = require("webpack");
 class AdditionalDependencyInjectorPlugin {
     entrypointAdditionalDependencies;
     processingModules;
-    constructor(entrypointAdditionalDependencies, processingModules) {
+    addExternalizedDep;
+    constructor(entrypointAdditionalDependencies, processingModules, addExternalizedDep) {
         this.entrypointAdditionalDependencies = entrypointAdditionalDependencies;
         this.processingModules = processingModules;
+        this.addExternalizedDep = addExternalizedDep;
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap("AdditionalDependencyInjectorPlugin", compilation => {
             compilation.hooks.processAssets.tap({
-                name: "AdditionalDependencyInjectorPlugin_ProcessAssets",
-                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE
-            }, compilationAssets => {
-                const usableEntrypointTest = this.processingModules ? /\.mtsx?$/ : /\.tsx?$/;
-                const assetSources = new Map();
+                name: "AdditionalDependencyInjectorPlugin_ProcessAssets_AddFakeModules",
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, () => {
+                const usableEntrypointTest = this.processingModules ? /\.m[jt]sx?$/i : /\.[jt]sx?$/i;
                 for (const entrypoint of compilation.entrypoints.values()) {
                     const req = entrypoint.origins.filter(origin => usableEntrypointTest.test(origin.request))[0]?.request;
-                    if (req) {
-                        for (const chunk of entrypoint.chunks) {
-                            for (const file of chunk.files) {
-                                if (file.endsWith('.asset.php')) {
-                                    assetSources.set(file, req);
-                                }
-                            }
-                        }
+                    if (!req) {
+                        continue;
+                    }
+                    const additionalDependencies = [...this.entrypointAdditionalDependencies];
+                    const firstLine = node_fs_1.default.readFileSync(req, 'utf8').trim().split(/\r?\n/)[0];
+                    if (firstLine?.startsWith("//ADDITIONAL_DEPENDENCIES:")) {
+                        additionalDependencies.push(...firstLine.substring(26).trim().split(',').map(dep => dep.trim()));
+                    }
+                    const chunk = entrypoint.getEntrypointChunk();
+                    for (const additionalDep of additionalDependencies) {
+                        this.addExternalizedDep(additionalDep);
+                        compilation.chunkGraph.connectChunkAndModule(chunk, new webpack_1.ExternalModule("__REMOVE_ME__", "", additionalDep));
                     }
                 }
-                for (const [name, asset] of Object.entries(compilationAssets)) {
-                    if (name.endsWith(".asset.php") && asset.constructor.name === 'RawSource') {
-                        const assetSource = assetSources.get(name);
-                        if (!assetSource) {
-                            continue;
-                        }
-                        const additionalDependencies = [...this.entrypointAdditionalDependencies];
-                        const firstLine = node_fs_1.default.readFileSync(assetSource, 'utf8').trim().split(/\r?\n/)[0];
-                        if (firstLine?.startsWith("//ADDITIONAL_DEPENDENCIES:")) {
-                            additionalDependencies.push(...firstLine.substring(26).trim().split(',').map(dep => dep.trim()));
-                        }
-                        if (additionalDependencies.length > 0) {
-                            const seen = new Set();
-                            const additionalDeps = additionalDependencies.filter(dep => !seen.has(dep) && seen.add(dep)).sort().map(v => `'${v}'`).join(', ');
-                            if (additionalDeps.length > 0) {
-                                compilation.updateAsset(name, new webpack_1.sources.RawSource(asset.source().toString()
-                                    .replaceAll(/(?:, )?'wp-[^']+\/[^']+'/gi, '')
-                                    .replace(/('dependencies'\s+=>\s+(?:array\(|\[))(.*)([)\]], 'version')/g, (match, g1, g2, g3) => `${g1}${g2.length > 0 ? `${g2}, ${additionalDeps}` : additionalDeps}${g3}`)));
-                                continue;
-                            }
+            });
+            compilation.hooks.processAssets.tap({
+                name: "AdditionalDependencyInjectorPlugin_ProcessAssets_RemoveFakeModules",
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, () => {
+                for (const entrypoint of compilation.entrypoints.values()) {
+                    const entrypointChunk = entrypoint.getEntrypointChunk();
+                    for (const module of compilation.chunkGraph.getChunkModules(entrypointChunk)) {
+                        if (module instanceof webpack_1.ExternalModule && module.request === '__REMOVE_ME__') {
+                            compilation.chunkGraph.disconnectChunkAndModule(entrypointChunk, module);
                         }
-                        compilation.updateAsset(name, new webpack_1.sources.RawSource(asset.source().toString()
-                            .replaceAll(/(?:, )?'wp-[^']+\/[^']+'/gi, '')));
                     }
                 }
             });

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

@@ -12,6 +12,7 @@ export default class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private static readonly blockJSONAssetSourceDirs;
     private static readonly blockJsonAssetKeyMapping;
     private static readonly blockJsonAssetKeyReadinessMapping;
+    readonly additionalMetadata: Map<string, any>;
     constructor(standaloneBlocks: boolean, processingModules: boolean);
     static recordRawDependency(entrypoint: string, dependency: string): void;
     static recordBlockJSONAssetSourceDir(entrypoint: string, source: string): void;

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

@@ -21,6 +21,7 @@ class BlockJSONManagingPlugin {
     static blockJSONAssetSourceDirs = new Map();
     static blockJsonAssetKeyMapping = new Map();
     static blockJsonAssetKeyReadinessMapping = new Map();
+    additionalMetadata = new Map();
     constructor(standaloneBlocks, processingModules) {
         this.standaloneBlocks = standaloneBlocks;
         this.processingModules = processingModules;
@@ -37,6 +38,7 @@ class BlockJSONManagingPlugin {
     }
     apply(compiler) {
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            this.additionalMetadata.clear();
             this.registerAssetProcessor(compilation);
             if (!this.processingModules) {
                 this.registerBlockJsonProcessor(compilation);
@@ -373,8 +375,46 @@ class BlockJSONManagingPlugin {
                 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))]);
+            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 scriptHandles = {};
+                const styleHandles = {};
+                const rawAssetData = JSON.parse(rawAssetDataSource);
+                const mappableKeys = [...BlockJSONManagingPlugin.mappableModuleKeys, ...BlockJSONManagingPlugin.mappableNonModuleKeys];
+                for (const [blockFolder, config] of blockDirConfigs) {
+                    for (const mappableKey of mappableKeys) {
+                        const cfg = config[mappableKey];
+                        if (cfg) {
+                            if (Array.isArray(cfg)) {
+                                for (let i = 0; i < cfg.length; i++) {
+                                    const assetDetails = getAssetDetails(blockFolder, cfg[i], rawAssetData);
+                                    if (assetDetails) {
+                                        (assetDetails[0] ? styleHandles : scriptHandles)[assetDetails[1]] = assetDetails[2];
+                                        cfg[i] = assetDetails[1];
+                                    }
+                                }
+                            }
+                            else {
+                                const assetDetails = getAssetDetails(blockFolder, cfg, rawAssetData);
+                                if (assetDetails) {
+                                    (assetDetails[0] ? styleHandles : scriptHandles)[assetDetails[1]] = assetDetails[2];
+                                    config[mappableKey] = assetDetails[1];
+                                }
+                            }
+                        }
+                    }
+                }
+                sortedBlockDirConfigData = Object.fromEntries([
+                    ["__metadata", { version: 2, ...Object.fromEntries(this.additionalMetadata.entries()), scriptHandles, styleHandles }],
+                    ...blockDirConfigs
+                ]);
+                compilation.deleteAsset("assets.json");
+            }
+            else {
+                sortedBlockDirConfigData = Object.fromEntries([["__metadata", { version: 1, ...Object.fromEntries(this.additionalMetadata.entries()) }], ...blockDirConfigs]);
+            }
             compilation.emitAsset("blockdir.config", new webpack_1.sources.RawSource((0, php_serializer_1.default)(sortedBlockDirConfigData, { excludedKeys: ["$schema"] })));
         });
     }
@@ -447,3 +487,17 @@ function makeSync() {
     });
     return res;
 }
+function getAssetDetails(blockFolder, asset, rawAssetData) {
+    if (!asset.startsWith("file:./")) {
+        return undefined;
+    }
+    const src = `${blockFolder}/${asset.substring(7)}`;
+    const isCss = src.endsWith(".css");
+    const assetData = isCss
+        ? rawAssetData[src.substring(0, src.length - 3) + "js"] ?? rawAssetData[src.substring(0, src.length - 3).replace("style-style", "style") + "js"]
+        : rawAssetData[src];
+    if (!assetData) {
+        return undefined;
+    }
+    return [isCss, src.substring(0, src.length - (isCss ? 4 : 3)), { src, rest: [assetData.dependencies, assetData.version] }];
+}

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

@@ -0,0 +1,16 @@
+import { type Compiler, type WebpackPluginInstance } from "webpack";
+import BlockJSONManagingPlugin from "./BlockJSONManagingPlugin";
+export default class WPMLConfigBuilder implements WebpackPluginInstance {
+    private readonly blockJSONManagingPlugin;
+    private static jsdomInstance?;
+    private static domParser?;
+    private static xmlSerializer?;
+    private readonly parsedDocumentsCache;
+    constructor(blockJSONManagingPlugin: BlockJSONManagingPlugin);
+    apply(compiler: Compiler): void;
+    private static getJSDOMInstance;
+    private static getDOMParser;
+    private static getXMLSerializer;
+    private static prettyPrintXML;
+    private loadWPMLConfigXML;
+}

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

@@ -0,0 +1,471 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("node:fs/promises"));
+const jsdom_1 = require("jsdom");
+const webpack_1 = require("webpack");
+const xml_formatter_1 = __importDefault(require("xml-formatter"));
+class WPMLConfigBuilder {
+    blockJSONManagingPlugin;
+    static jsdomInstance;
+    static domParser;
+    static xmlSerializer;
+    parsedDocumentsCache = new Map();
+    constructor(blockJSONManagingPlugin) {
+        this.blockJSONManagingPlugin = blockJSONManagingPlugin;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}__processXML`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL }, async (assets) => {
+                const entrypoint = compilation.entrypoints.get("wpml-config.xml");
+                if (!entrypoint) {
+                    return;
+                }
+                const files = Promise.all([
+                    Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("wpml-config.xml"))
+                        .map(async (request) => this.loadWPMLConfigXML(request, compilation))),
+                    Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("block.json"))
+                        .map(async (request) => [JSON.parse(await promises_1.default.readFile(request, 'utf8')), request]))
+                ]);
+                for (const name of Object.keys(assets)) {
+                    if (name.startsWith("wpml-config.xml")) {
+                        compilation.deleteAsset(name);
+                    }
+                }
+                const [wpmlConfigs, blockJsons] = await files;
+                if (!wpmlConfigs.length && !blockJsons.length) {
+                    return;
+                }
+                const mergedConfig = {
+                    customFields: {}, customTermFields: {}, customTypes: {}, gutenbergBlocks: {}, shortcodeList: new Set(), shortcodes: {}, taxonomies: {}
+                };
+                const nonMergeableCategories = ['customFields', 'customTermFields', 'customTypes', 'shortcodes', 'taxonomies'];
+                for (const [wpmlConfig, file] of wpmlConfigs) {
+                    for (const category of nonMergeableCategories) {
+                        for (const [key, value] of Object.entries(wpmlConfig[category])) {
+                            if (key in mergedConfig[category]) {
+                                compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${category} entry named, "${key}"`, file));
+                            }
+                            else {
+                                mergedConfig[category][key] = value;
+                            }
+                        }
+                    }
+                    for (const shortcode of wpmlConfig.shortcodeList) {
+                        mergedConfig.shortcodeList.add(shortcode);
+                    }
+                    for (const [type, block] of Object.entries(wpmlConfig.gutenbergBlocks)) {
+                        const existing = mergedConfig.gutenbergBlocks[type];
+                        try {
+                            mergedConfig.gutenbergBlocks[type] = existing ? mergeWPMLGutenbergBlocks(existing, block) : block;
+                        }
+                        catch (e) {
+                            if (typeof e === 'string') {
+                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                            }
+                            else {
+                                compilation.errors.push(e);
+                            }
+                        }
+                    }
+                }
+                for (const [blockJson, file] of blockJsons) {
+                    const type = blockJson["name"]?.toString();
+                    if (typeof type !== 'string') {
+                        continue;
+                    }
+                    const blockConfig = { type, translate: '1', keys: [], xPaths: [] };
+                    if (blockJson['plaudit']?.['properties']) {
+                        const snps = blockJson['plaudit']['properties'];
+                        if (Array.isArray(snps)) {
+                            for (const snp of snps) {
+                                convertSNPToKeys(snp, blockConfig.keys);
+                            }
+                        }
+                        else {
+                            convertSNPToKeys(snps, blockConfig.keys);
+                        }
+                    }
+                    if (typeof blockJson['attributes'] === 'object') {
+                        for (const [name, { translatable }] of Object.entries(blockJson['attributes'])) {
+                            if (translatable) {
+                                blockConfig.keys.push({ name, keys: [] });
+                            }
+                        }
+                    }
+                    const existing = mergedConfig.gutenbergBlocks[blockConfig.type];
+                    if (blockConfig.keys.length || blockConfig.xPaths.length) {
+                        mergedConfig.gutenbergBlocks[blockConfig.type] = existing ? mergeWPMLGutenbergBlocks(existing, blockConfig) : blockConfig;
+                    }
+                    else if (!existing) {
+                        mergedConfig.gutenbergBlocks[blockConfig.type] = blockConfig;
+                    }
+                }
+                const config = WPMLConfigBuilder.getDOMParser().parseFromString("<wpml-config></wpml-config>", "application/xml");
+                appendNamedElementsListToConfig("custom-fields", mergedConfig.customFields, config);
+                appendNamedElementsListToConfig("custom-term-fields", mergedConfig.customTermFields, config);
+                appendNamedElementsListToConfig("custom-types", mergedConfig.customTypes, config);
+                const gutenbergBlocks = Object.values(mergedConfig.gutenbergBlocks);
+                if (gutenbergBlocks.length) {
+                    const gutenbergBlocksElement = config.createElement("gutenberg-blocks");
+                    gutenbergBlocksElement.append(...gutenbergBlocks
+                        .sort((a, b) => a.type.localeCompare(b.type))
+                        .map(gutenbergBlock => {
+                        const gutenbergBlockElement = config.createElement("gutenberg-block");
+                        gutenbergBlockElement.setAttribute("type", gutenbergBlock.type);
+                        if (gutenbergBlock.label) {
+                            gutenbergBlockElement.setAttribute("label", gutenbergBlock.label);
+                        }
+                        gutenbergBlockElement.setAttribute("translate", gutenbergBlock.translate);
+                        writeGenericSettingsKeys(gutenbergBlock.keys, gutenbergBlockElement, config);
+                        gutenbergBlockElement.append(...gutenbergBlock.xPaths
+                            .sort((a, b) => a.path.localeCompare(b.path))
+                            .map(xPath => {
+                            const xPathElement = config.createElement("xpath");
+                            writeCommonGenericSettingsItemProps(xPathElement, xPath);
+                            xPathElement.append(xPath.path);
+                            return xPathElement;
+                        }));
+                        return gutenbergBlockElement;
+                    }));
+                    config.documentElement.append(gutenbergBlocksElement);
+                }
+                if (mergedConfig.shortcodeList.size) {
+                    const node = config.createElement("shortcode-list");
+                    node.append([...mergedConfig.shortcodeList].sort().join(","));
+                    config.documentElement.appendChild(node);
+                }
+                appendNamedElementsListToConfig("shortcodes", mergedConfig.shortcodes, config);
+                appendNamedElementsListToConfig("taxonomies", mergedConfig.taxonomies, config);
+                this.blockJSONManagingPlugin.additionalMetadata.set("wpml-config", true);
+                compilation["wpml-config.xml" in compilation.assets ? 'updateAsset' : 'emitAsset']("wpml-config.xml", new webpack_1.sources.RawSource(WPMLConfigBuilder.prettyPrintXML(config)));
+            });
+        });
+    }
+    static getJSDOMInstance() {
+        return WPMLConfigBuilder.jsdomInstance ?? (WPMLConfigBuilder.jsdomInstance = new jsdom_1.JSDOM("", { contentType: "text/html" }));
+    }
+    static getDOMParser() {
+        return WPMLConfigBuilder.domParser ?? (WPMLConfigBuilder.domParser = new (WPMLConfigBuilder.getJSDOMInstance().window.DOMParser)());
+    }
+    static getXMLSerializer() {
+        return WPMLConfigBuilder.xmlSerializer ?? (WPMLConfigBuilder.xmlSerializer = new (WPMLConfigBuilder.getJSDOMInstance().window.XMLSerializer)());
+    }
+    static prettyPrintXML(document) {
+        return (0, xml_formatter_1.default)(WPMLConfigBuilder.getXMLSerializer().serializeToString(document), {
+            indentation: '\t',
+            collapseContent: true,
+            lineSeparator: '\n',
+            whiteSpaceAtEndOfSelfclosingTag: true,
+            forceSelfClosingEmptyTag: true,
+            strictMode: true,
+            filter(node) {
+                return node.type === 'Element' || node.type === 'Text';
+            }
+        });
+    }
+    async loadWPMLConfigXML(file, compilation) {
+        const contents = await promises_1.default.readFile(file, 'utf8');
+        const existing = this.parsedDocumentsCache.get(file);
+        if (existing?.raw === contents) {
+            return [existing, file];
+        }
+        const wpmlConfig = WPMLConfigBuilder.getDOMParser().parseFromString(contents.replaceAll(/\s+xmlns=['"][^'"]+['"]/sig, ""), "application/xml");
+        const res = { raw: contents, customFields: {}, customTermFields: {}, customTypes: {}, gutenbergBlocks: {}, shortcodeList: new Set(), shortcodes: {}, taxonomies: {} };
+        for (const element of wpmlConfig.documentElement.children) {
+            switch (element.nodeName) {
+                case "custom-fields":
+                    importStandardTranslateActionMap(element, file, "custom-field", res.customFields, compilation);
+                    break;
+                case "custom-term-fields":
+                    importStandardTranslateActionMap(element, file, "custom-term-field", res.customTermFields, compilation);
+                    break;
+                case "custom-types":
+                    importStandardTranslateOptionMap(element, file, "custom-type", res.customTypes, compilation);
+                    break;
+                case "gutenberg-blocks":
+                    for (const child of element.children) {
+                        try {
+                            const block = convertGutenbergBlockToJSRepresentation(child);
+                            const existing = res.gutenbergBlocks[block.type];
+                            if (existing) {
+                                res.gutenbergBlocks[block.type] = mergeWPMLGutenbergBlocks(existing, block);
+                            }
+                            else {
+                                res.gutenbergBlocks[block.type] = block;
+                            }
+                        }
+                        catch (e) {
+                            if (typeof e === 'string') {
+                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                            }
+                            else {
+                                compilation.errors.push(e);
+                            }
+                        }
+                    }
+                    break;
+                case "shortcode-list":
+                    if (element.textContent) {
+                        for (const shortcode of element.textContent.split(",")) {
+                            res.shortcodeList.add(shortcode.trim());
+                        }
+                    }
+                    break;
+                case "shortcodes":
+                    for (const child of element.children) {
+                        const tag = child.getElementsByTagName("tag")[0];
+                        const shortcodeName = tag?.textContent?.trim();
+                        if (!shortcodeName) {
+                            compilation.errors.push(newWebpackErrorForFile(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
+                            continue;
+                        }
+                        const existing = res.shortcodes[shortcodeName];
+                        if (existing) {
+                            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the shortcode entry named, "${shortcodeName}"`, file));
+                        }
+                        else {
+                            res.shortcodes[shortcodeName] = child;
+                        }
+                    }
+                    break;
+                case "taxonomies":
+                    importStandardTranslateOptionMap(element, file, "taxonomy", res.taxonomies, compilation);
+                    break;
+                default:
+                    compilation.errors.push(newWebpackErrorForFile(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
+                    break;
+            }
+        }
+        this.parsedDocumentsCache.set(file, res);
+        return [res, file];
+    }
+}
+exports.default = WPMLConfigBuilder;
+function importStandardTranslateOptionMap(element, file, type, actionMap, compilation) {
+    for (const child of element.children) {
+        const field = child.textContent;
+        if (!field) {
+            compilation.errors.push(newWebpackErrorForFile(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
+            continue;
+        }
+        const translate = child.getAttribute("translate");
+        if (!translate) {
+            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing the translate attribute.`, file));
+            continue;
+        }
+        const existing = actionMap[field];
+        if (existing) {
+            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+        }
+        else {
+            actionMap[field] = child;
+        }
+    }
+}
+function importStandardTranslateActionMap(element, file, type, actionMap, compilation) {
+    for (const child of element.children) {
+        const field = child.textContent?.trim();
+        if (!field) {
+            compilation.errors.push(newWebpackErrorForFile(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
+            continue;
+        }
+        const action = child.getAttribute("action");
+        if (!action) {
+            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing an action.`, file));
+            continue;
+        }
+        const existing = actionMap[field];
+        if (existing) {
+            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+        }
+        else {
+            actionMap[field] = child;
+        }
+    }
+}
+function convertSNPToKeys(prop, keys) {
+    if (Array.isArray(prop)) {
+        for (const p of prop) {
+            convertSNPToKeys(p, keys);
+        }
+    }
+    else if ('properties' in prop) {
+        for (const item of prop.properties) {
+            convertSNPToKeys(item, keys);
+        }
+    }
+    else if ('items' in prop) {
+        for (const item of prop.items) {
+            convertSNPToKeys(item, keys);
+        }
+    }
+    else {
+        if (prop.translatable) {
+            keys.push({ name: prop.name, keys: [] });
+        }
+        else if ('fields' in prop) {
+            if (prop.fields) {
+                const nestedKeys = [];
+                convertSNPToKeys(prop.fields, nestedKeys);
+                if (nestedKeys.length) {
+                    keys.push({ name: prop.name, keys: nestedKeys });
+                }
+            }
+        }
+        else if ('itemType' in prop && Array.isArray(prop.itemType)) {
+            const nestedKeys = [];
+            convertSNPToKeys(prop.itemType, nestedKeys);
+            if (nestedKeys.length) {
+                keys.push({ name: prop.name, keys: nestedKeys });
+            }
+        }
+    }
+}
+function convertGutenbergBlockToJSRepresentation(element) {
+    const type = element.getAttribute("type");
+    if (!type) {
+        throw `A gutenberg-block entry in a wpml-config.xml file is missing its type attribute.`;
+    }
+    const translate = element.getAttribute("translate");
+    if (!translate) {
+        throw `The gutenberg-block entry for ${type} is missing its translate attribute.`;
+    }
+    if (translate !== '0' && translate !== '1') {
+        throw `The gutenberg-block entry for ${type} has an invalid translate attribute. Expected 0 or 1, but got, "${translate}"`;
+    }
+    const keys = [];
+    const xPaths = [];
+    for (const child of element.children) {
+        if (child.nodeName === 'key') {
+            keys.push(convertGenericSettingsKeyToJSRepresentation(child, `a gutenberg-block entry for ${type}`));
+        }
+        else if (child.nodeName === 'xpath') {
+            xPaths.push(convertGenericSettingsXPathToJSRepresentation(child, `a gutenberg-block entry for ${type}`));
+        }
+        else {
+            throw `The gutenberg-block entry for ${type} has an unsupported child node ("${child.nodeName}")`;
+        }
+    }
+    return { type, label: element.getAttribute("label"), translate, keys, xPaths };
+}
+function convertGenericSettingsKeyToJSRepresentation(element, containerName) {
+    const name = element.getAttribute("name");
+    if (!name) {
+        throw `Encountered a key without a name in ${containerName}.`;
+    }
+    let encoding = element.getAttribute("encoding");
+    if (encoding && encoding !== 'json') {
+        throw `Encountered an invalid encoding on a key named, "${name}" in ${containerName}. It must be either blank or JSON`;
+    }
+    else {
+        encoding = null;
+    }
+    let searchMethod = element.getAttribute("searchMethod");
+    if (searchMethod && searchMethod !== 'wildcards' && searchMethod !== 'regex') {
+        throw `Encountered an invalid search-method on a key named, "${name}" in ${containerName}. It must be either blank or JSON`;
+    }
+    else {
+        searchMethod = null;
+    }
+    return {
+        name,
+        label: element.getAttribute("label"),
+        type: element.getAttribute("type"),
+        subType: element.getAttribute("sub-type"),
+        encoding,
+        searchMethod,
+        keys: [...element.children].map(child => convertGenericSettingsKeyToJSRepresentation(child, containerName))
+    };
+}
+function convertGenericSettingsXPathToJSRepresentation(element, containerName) {
+    if (!element.textContent) {
+        throw `Encountered an empty XPath in ${containerName}.`;
+    }
+    return {
+        path: element.textContent,
+        label: element.getAttribute("label"),
+        type: element.getAttribute("type"),
+        subType: element.getAttribute("sub-type")
+    };
+}
+function mergeWPMLGutenbergBlocks(existing, novel) {
+    if (novel.type && existing.type !== novel.type) {
+        throw `Cannot merge WPML Gutenberg Blocks of differing types`;
+    }
+    if (novel.translate && existing.translate !== novel.translate) {
+        throw `Cannot merge WPML Gutenberg Blocks (${existing.type} and ${novel.type ?? existing.type}) with differing translate values`;
+    }
+    return {
+        type: existing.type,
+        translate: existing.translate,
+        label: novel.label ?? existing.label,
+        keys: novel.keys?.length ? (existing.keys.length ? mergeGenericSettingsKeyLists(existing.keys, novel.keys) : novel.keys) : existing.keys,
+        xPaths: novel.xPaths?.length ? (existing.xPaths.length ? [...existing.xPaths, ...novel.xPaths] : novel.xPaths) : existing.xPaths
+    };
+}
+function mergeGenericSettingsKeyLists(existingKeys, novelKeys) {
+    const keys = {};
+    for (const key of existingKeys) {
+        const existing = keys[key.name];
+        keys[key.name] = existing ? mergeGenericSettingsKeys(existing, key) : key;
+    }
+    for (const key of novelKeys) {
+        const existing = keys[key.name];
+        keys[key.name] = existing ? mergeGenericSettingsKeys(existing, key) : key;
+    }
+    return Object.values(keys);
+}
+function mergeGenericSettingsKeys(existing, novel) {
+    if (existing.encoding && novel.encoding && existing.encoding !== novel.encoding) {
+        throw `Cannot merge WPMLGenericSettingsKeys with differing encoding values (${existing.encoding} and ${novel.encoding}) on ${novel.name}.`;
+    }
+    if (existing.searchMethod && novel.searchMethod && existing.searchMethod !== novel.searchMethod) {
+        throw `Cannot merge WPMLGenericSettingsKeys with differing search-method values (${existing.searchMethod} and ${novel.searchMethod}) on ${novel.name}.`;
+    }
+    return { ...existing, ...novel, keys: mergeGenericSettingsKeyLists(existing.keys, novel.keys) };
+}
+function newWebpackErrorForFile(error, file) {
+    const res = new webpack_1.WebpackError(error);
+    res.hideStack = true;
+    res.file = file;
+    return res;
+}
+function writeGenericSettingsKeys(keys, parent, document) {
+    parent.append(...keys.sort((a, b) => a.name.localeCompare(b.name)).map(key => {
+        const element = document.createElement("key");
+        element.setAttribute("name", key.name);
+        writeCommonGenericSettingsItemProps(element, key);
+        if (key.encoding) {
+            element.setAttribute("encoding", key.encoding);
+        }
+        if (key.searchMethod) {
+            element.setAttribute("search-method", key.searchMethod);
+        }
+        writeGenericSettingsKeys(key.keys, element, document);
+        return element;
+    }));
+}
+function appendNamedElementsListToConfig(containerName, elements, config) {
+    const allElements = Object.entries(elements);
+    if (allElements.length) {
+        const containerElement = config.createElement(containerName);
+        config.documentElement.append(containerElement);
+        containerElement.append(...allElements
+            .sort(([fieldNameA], [fieldNameB]) => fieldNameA.localeCompare(fieldNameB))
+            .map(([_, element]) => element));
+    }
+}
+function writeCommonGenericSettingsItemProps(element, item) {
+    if (item.label) {
+        element.setAttribute("label", item.label);
+    }
+    if (item.type) {
+        element.setAttribute("type", item.type);
+    }
+    if (item.subType) {
+        element.setAttribute("sub-type", item.subType);
+    }
+}

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

@@ -6,4 +6,7 @@ export type IndividualExternalDepConfig = string | {
 export type Externals = {
     [dep: string]: IndividualExternalDepConfig;
 };
-export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean): false | DependencyExtractionWebpackPlugin;
+export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, wantsGroupedDepData: boolean): {
+    instance: DependencyExtractionWebpackPlugin;
+    addExternalizedDep: (dep: string) => void;
+};

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

@@ -5,15 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (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) {
+function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibraries, wantsGroupedDepData) {
+    const baseProps = makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries);
+    const instance = new dependency_extraction_webpack_plugin_1.default(wantsGroupedDepData ? { ...baseProps, outputFormat: "json", combineAssets: true } : baseProps);
+    return {
+        instance,
+        addExternalizedDep: (dep) => {
+            instance.externalizedDeps.add(dep);
+        }
+    };
+}
+function makeDependencyExtractionPluginProps(externals, assumeGlobalizedPlauditLibraries) {
     if (!externals) {
         if (assumeGlobalizedPlauditLibraries) {
-            return new dependency_extraction_webpack_plugin_1.default({
+            return {
                 requestToExternal: plauditRequestToExternal,
                 requestToHandle: plauditRequestToHandle
-            });
+            };
         }
-        return false;
+        return {};
     }
     const exactExternals = {};
     const suffixExternals = [];
@@ -54,15 +64,18 @@ function makeDependencyExtractionPlugin(externals, assumeGlobalizedPlauditLibrar
         }
         return undefined;
     };
-    return assumeGlobalizedPlauditLibraries
-        ? new dependency_extraction_webpack_plugin_1.default({
+    if (assumeGlobalizedPlauditLibraries) {
+        return {
             requestToExternal: curryRequestHandlers(baselineRequestToExternal, plauditRequestToExternal),
             requestToHandle: curryRequestHandlers(baselineRequestToHandle, plauditRequestToHandle),
-        })
-        : new dependency_extraction_webpack_plugin_1.default({
+        };
+    }
+    else {
+        return {
             requestToExternal: baselineRequestToExternal,
             requestToHandle: baselineRequestToHandle,
-        });
+        };
+    }
 }
 const PLAUDIT_NAMESPACE = '@plaudit/';
 const EXTERNALIZABLE_PLAUDIT_LIBRARIES = ['@plaudit/library-extensions'];

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

@@ -5,7 +5,7 @@ interface AdvancedOutputConfig {
     destination: string;
     withLegacyBlocksIn?: string | undefined;
     additionalDependencies?: string[];
-    directoryLayout?: 'blocks' | 'extensions';
+    directoryLayout?: 'blocks' | 'extensions' | 'plain';
     assumeGlobalizedPlauditLibraries?: boolean;
 }
 type PlauditWordpressWebpackConfig = {
@@ -19,6 +19,8 @@ type PlauditWordpressWebpackConfig = {
     };
     externals?: Externals;
     assumeGlobalizedPlauditLibraries?: boolean;
+    processTranslationConfigs?: boolean;
+    combineAssetMetadata?: boolean;
 };
 declare const _default: (config: PlauditWordpressWebpackConfig, webpackConfig?: Configuration[] | Configuration) => Configuration[];
 export = _default;

package/build/wordpress-scripts-wrapper.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
 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"));
@@ -12,6 +13,7 @@ const MiniCSSExtractPluginErrorCleaner_1 = __importDefault(require("./wordpress-
 const VariablesJSMonitorPlugin_1 = __importDefault(require("./wordpress-scripts-wrapper/VariablesJSMonitorPlugin"));
 const BrowserSyncPlugin_1 = require("./wordpress-scripts-wrapper/BrowserSyncPlugin");
 const static_configs_1 = require("./wordpress-scripts-wrapper/static-configs");
+const WPMLConfigBuilder_1 = __importDefault(require("./wordpress-scripts-wrapper/WPMLConfigBuilder"));
 const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
 const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
@@ -246,7 +248,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         scriptExtension = scriptWithoutModuleExtension;
         entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
     }
-    const { standaloneBlocks, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries } = config;
+    const { standaloneBlocks, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, combineAssetMetadata } = config;
     let currentVariables = config.currentVariables;
     const fixedRules = [
         replaceDefaultURLProcessing,
@@ -255,6 +257,16 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         },
         injectSupportForInliningSVGsAsStrings
     ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
+    if (config.processTranslationConfigs) {
+        fixedRules.push({
+            test: /wpml-config\.xml$/i,
+            type: 'asset/resource',
+            generator: {
+                filename: '[name][ext]',
+                emit: false
+            }
+        });
+    }
     return sources.map(([src, dest]) => {
         const srcRoots = (typeof dest !== 'string' && dest.withLegacyBlocksIn
             ? [...src.split(','), ...resolveLegacyBlockScriptsInFolder(dest.withLegacyBlocksIn)]
@@ -302,22 +314,26 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         if (variablesFilePath) {
             plugins.push(new VariablesJSMonitorPlugin_1.default(variablesFilePath));
         }
-        if (copyFiles && (typeof dest === 'string' || dest.directoryLayout !== 'extensions')) {
-            plugins.push(new BlockJSONManagingPlugin_1.default(standaloneBlocks, processingModules));
-        }
-        plugins.push(new AdditionalDependencyInjectorPlugin_1.default(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules));
-        if (srcIsDirectory && (typeof dest !== 'string' && dest.directoryLayout === 'extensions')) {
-            plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.default(srcRoot));
+        const forBlocksDirectory = copyFiles && (typeof dest === 'string' || (dest.directoryLayout !== 'extensions' && dest.directoryLayout !== 'plain'));
+        if (forBlocksDirectory) {
+            const blockJSONManagingPlugin = new BlockJSONManagingPlugin_1.default(standaloneBlocks, processingModules);
+            plugins.push(blockJSONManagingPlugin);
+            if (config.processTranslationConfigs && srcIsDirectory && !processingModules) {
+                plugins.push(new WPMLConfigBuilder_1.default(blockJSONManagingPlugin));
+            }
         }
         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;
-            }
+            const localAssumeGlobalizedPlauditLibraries = typeof dest !== 'string' ? dest.assumeGlobalizedPlauditLibraries : undefined;
+            const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries ?? assumeGlobalizedPlauditLibraries, combineAssetMetadata && !processingModules && forBlocksDirectory);
+            plugins[pluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
+            plugins.push(new AdditionalDependencyInjectorPlugin_1.default(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
+        }
+        if (srcIsDirectory && (typeof dest !== 'string' && dest.directoryLayout === 'extensions')) {
+            plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.default(srcRoot));
         }
         if (process.argv.includes('--browser-sync') || process.env['BROWSER_SYNC'] === 'true') {
             plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
@@ -325,50 +341,69 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         let entry;
         if (srcIsDirectory) {
             if (typeof dest !== 'string' && dest.directoryLayout === 'extensions') {
-                entry = () => {
-                    const rawEntrypoints = node_fs_1.default.readdirSync(srcRoot, 'utf8')
-                        .map(file => joinPossiblyAbsolutePaths(srcRoot, file))
-                        .filter(file => (scriptExtension.test(file) || styleExtension.test(file)) && node_fs_1.default.statSync(file).isFile())
-                        .map((file) => [node_path_1.default.basename(file, node_path_1.default.extname(file)), file]);
+                entry = async () => {
+                    const rawEntrypoints = [];
+                    for await (const dirent of await promises_1.default.opendir(srcRoot)) {
+                        if (dirent.isFile()) {
+                            if (scriptExtension.test(dirent.name) || styleExtension.test(dirent.name)) {
+                                const file = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
+                                rawEntrypoints.push([node_path_1.default.basename(file, node_path_1.default.extname(file)), file]);
+                            }
+                        }
+                    }
                     return Object.fromEntries(rawEntrypoints);
                 };
             }
             else {
-                entry = () => {
-                    const rawEntrypoints = node_fs_1.default.readdirSync(srcRoot, 'utf8')
-                        .map(dir => joinPossiblyAbsolutePaths(srcRoot, dir))
-                        .filter(dir => node_fs_1.default.statSync(dir).isDirectory())
-                        .flatMap(dir => {
-                        const res = [];
-                        try {
-                            const blockJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'block.json'), 'utf8'));
-                            const blockJSONChunkName = node_path_1.default.join(node_path_1.default.basename(dir), "block.json");
-                            for (const key of entrypointFields) {
-                                if (key in blockJSON) {
-                                    res.push(...mapToRealEntrypoints(blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep, blockJSONChunkName));
-                                }
-                            }
-                            BlockJSONManagingPlugin_1.default.recordBlockJSONAssetSourceDir(blockJSONChunkName, dir);
-                            return res;
+                entry = async () => {
+                    const loadingEntrypoints = [];
+                    for await (const dirent of await promises_1.default.opendir(srcRoot)) {
+                        if (!dirent.isDirectory()) {
+                            continue;
                         }
-                        catch (e) {
+                        const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
+                        loadingEntrypoints.push(new Promise(async (resolve) => {
+                            const rawEntrypoints = [];
+                            const wpmlFiles = [];
                             try {
-                                const packageJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                                res.push(...mapToRealEntrypoints(packageJSON['main'], dir));
-                                res.push(...mapToRealEntrypoints(packageJSON['style'], dir));
+                                const blockJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'block.json'), 'utf8'));
+                                const blockJSONChunkName = node_path_1.default.join(node_path_1.default.basename(dir), "block.json");
+                                for (const key of entrypointFields) {
+                                    if (key in blockJSON) {
+                                        rawEntrypoints.push(...mapToRealEntrypoints(blockJSON[key], dir, ep => ep.startsWith("file:") ? ep.substring(5) : ep, blockJSONChunkName));
+                                    }
+                                }
+                                wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
+                                BlockJSONManagingPlugin_1.default.recordBlockJSONAssetSourceDir(blockJSONChunkName, dir);
                             }
                             catch (e) {
                                 try {
-                                    res.push(...parseEntrypointsJSON(dir));
+                                    const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
+                                    rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir));
+                                    rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir));
                                 }
                                 catch (e) {
-                                    // This just means that the directory doesn't contain any declared entrypoints.
+                                    try {
+                                        rawEntrypoints.push(...parseEntrypointsJSON(dir));
+                                    }
+                                    catch (e) {
+                                        // This just means that the directory doesn't contain any declared entrypoints.
+                                    }
                                 }
                             }
-                        }
-                        return res;
-                    });
-                    const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(rawEntrypoints, e => e[0]);
+                            try {
+                                const wpmlFilePath = node_path_1.default.join(dir, "wpml-config.xml");
+                                await promises_1.default.access(wpmlFilePath);
+                                wpmlFiles.push(wpmlFilePath);
+                            }
+                            catch (e) {
+                                // This just means that the file doesn't exist
+                            }
+                            resolve([rawEntrypoints, wpmlFiles]);
+                        }));
+                    }
+                    const allEntrypoints = await Promise.all(loadingEntrypoints);
+                    const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(allEntrypoints.flatMap(e => e[0]), e => e[0]);
                     const currentEntry = {};
                     for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
                         if (groupedEntrypoints.length === 1 && groupedEntrypoints[0] !== undefined) {
@@ -387,6 +422,16 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
                             BlockJSONManagingPlugin_1.default.recordRawDependency(entry.lazyDependent, key);
                         }
                     }
+                    const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
+                    try {
+                        await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
+                        currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles] };
+                    }
+                    catch (e) {
+                        if (wpmlEntrypointFiles.length) {
+                            currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles };
+                        }
+                    }
                     return currentEntry;
                 };
             }
@@ -469,13 +514,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, assumeGlobalizedPlauditLibraries = true } = config;
+    const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = 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, assumeGlobalizedPlauditLibraries };
+    const cfg = { currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, processTranslationConfigs, combineAssetMetadata };
     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,6 +1,6 @@
 {
 	"name": "@plaudit/webpack-extensions",
-	"version": "2.39.0",
+	"version": "2.41.0",
 	"license": "UNLICENSED",
 	"scripts": {
 		"prepublishOnly": "rm -rf build && mkdir build && tsc",
@@ -21,8 +21,9 @@
 		}
 	},
 	"devDependencies": {
+		"@plaudit/gutenberg-api-extensions": "^2.66.0",
 		"@types/browser-sync-webpack-plugin": "^2.2.5",
-		"@types/node": "^22.13.10",
+		"@types/node": "^22.13.13",
 		"@types/postcss-functions": "^4.0.4",
 		"@types/tapable": "^2.2.7",
 		"@types/webpack": "^5.28.5",
@@ -42,7 +43,7 @@
 		"autoprefixer": "^10.4.21",
 		"browser-sync": "^3.0.3",
 		"clean-webpack-plugin": "^4.0.0",
-		"copy-webpack-plugin": "^12.0.2",
+		"copy-webpack-plugin": "^10.2.4",
 		"cssnano": "^6.1.2",
 		"eslint": "^8.57.1",
 		"eslint-plugin-jsdoc": "^48.11.0",
@@ -69,7 +70,8 @@
 		"react": "^18.3.1",
 		"react-dom": "^18.3.1",
 		"webpack": "^5.98.0",
-		"webpack-remove-empty-scripts": "^1.0.4"
+		"webpack-remove-empty-scripts": "^1.0.4",
+		"xml-formatter": "^3.6.5"
 	},
 	"engines": {
 		"node": ">=20"