@plaudit/webpack-extensions 4.0.0-rc.1 → 4.0.0

package/dist/plugins/unified-loader/UnifiedLoaderGenerator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedLoaderGenerator = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const php_writer_1 = require("@plaudit/php-writer");
+const expressions_1 = require("@plaudit/php-writer/expressions");
+const webpack_1 = require("webpack");
+const api_1 = require("../../api");
+const utils_1 = require("../../utils");
+class UnifiedLoaderGenerator extends api_1.CoordinatableEmitter {
+    coordinator;
+    config;
+    constructor(coordinator, config) {
+        super();
+        this.coordinator = coordinator;
+        this.config = config;
+    }
+    provides = [];
+    requires = ["unified-loader"];
+    get defaultCompilationName() {
+        return "unified-loader";
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
+            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL }, async () => {
+                const collectedLoaders = {};
+                for (const loader of this.coordinator.getData("unified-loader")) {
+                    collectedLoaders[loader.group] = { ...loader, ...collectedLoaders[loader.group], requiresBaseURI: loader.requiresBaseURI || (collectedLoaders[loader.group]?.requiresBaseURI ?? false) };
+                }
+                const loaders = Object.values(collectedLoaders).sort((a, b) => a.group.localeCompare(b.group));
+                if (this.config.useUnifiedLoader) {
+                    let phpFile;
+                    if (compilation.outputOptions.path?.endsWith("-dev")) {
+                        compilation['.gitignore' in compilation.assets ? 'updateAsset' : 'emitAsset']('.gitignore', new webpack_1.sources.RawSource('**'), { size: 2 });
+                        await this.ensureDistExists(compilation.outputOptions.path);
+                        phpFile = new php_writer_1.PHPFile();
+                    }
+                    else {
+                        phpFile = this.withDistDevLoader();
+                    }
+                    if (loaders.some(wc => wc.requiresBaseURI)) {
+                        (0, utils_1.emitResolveBaseUriFunction)(phpFile);
+                    }
+                    for (const { action } of loaders) {
+                        action(phpFile);
+                    }
+                    (0, utils_1.emitPHPWriterAsAsset)(phpFile, compilation, "unified-loader.php");
+                }
+            });
+        });
+    }
+    static emissionTarget(config) {
+        return ["unified-loader", (baseConfig, coordinator) => {
+                return {
+                    ...baseConfig,
+                    plugins: [new UnifiedLoaderGenerator(coordinator, config)]
+                };
+            }];
+    }
+    withDistDevLoader() {
+        if (this.config.omitDistDev) {
+            return new php_writer_1.PHPFile();
+        }
+        const devLoaderPath = expressions_1.Op.concat(expressions_1.Constants.__DIR__, '-dev/unified-loader.php');
+        const res = new php_writer_1.PHPFile();
+        res.getWriter("")
+            .if(expressions_1.Op.binary(expressions_1.Op.binary(expressions_1.Expr.call('wp_get_environment_type', []), ' === ', 'development'), ' && ', expressions_1.Expr.call('file_exists', [devLoaderPath])))
+            .require(devLoaderPath, { once: true })
+            .append("return;")
+            .endIf();
+        return res;
+    }
+    async ensureDistExists(outputPath) {
+        if (outputPath.endsWith("-dev")) {
+            outputPath = outputPath.substring(0, outputPath.length - 4);
+        }
+        try {
+            const contents = await (0, promises_1.readFile)((0, node_path_1.join)(outputPath, "unified-loader.php"), 'utf-8');
+            if (!contents.includes("-dev/unified-loader.php")) {
+                await (0, promises_1.writeFile)((0, node_path_1.join)(outputPath, "unified-loader.php"), this.withDistDevLoader().toString() + contents.substring(5), 'utf-8');
+            }
+        }
+        catch {
+            await (0, promises_1.mkdir)(outputPath, { recursive: true });
+            await (0, promises_1.writeFile)((0, node_path_1.join)(outputPath, "unified-loader.php"), this.withDistDevLoader().toString(), 'utf-8');
+        }
+    }
+    getCoordinatedEmissionTargets() {
+        return [];
+    }
+}
+exports.UnifiedLoaderGenerator = UnifiedLoaderGenerator;
+//# sourceMappingURL=UnifiedLoaderGenerator.js.map

package/dist/plugins/unified-loader/UnifiedLoaderGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnifiedLoaderGenerator.js","sourceRoot":"","sources":["../../../src/plugins/unified-loader/UnifiedLoaderGenerator.ts"],"names":[],"mappings":";;;AAAA,+CAA4D;AAC5D,yCAA+B;AAE/B,oDAA4C;AAC5C,iEAAoE;AAEpE,qCAA4D;AAE5D,mCAEmB;AACnB,uCAA6E;AAI7E,4BAAoC,SAAQ,0BAAoB;IAE3C,WAAW;IACb,MAAM;IAFxB,YACoB,WAAkC,EACpC,MAA6C;QAE9D,KAAK,EAAE,CAAC;2BAHW,WAAW;sBACb,MAAM;IAGxB,CAAC;IAEe,QAAQ,GAAG,EAAW,CAAC;IACvB,QAAQ,GAAG,CAAC,gBAAgB,CAAU,CAAC;IAEvD,IAAW,sBAAsB;QAChC,OAAO,gBAAgB,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,QAAkB;QACvB,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACtB,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE;YACvE,WAAW,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,qBAAW,CAAC,+BAA+B,EAAC,EAAE,KAAK,IAAI,EAAE;gBACxI,MAAM,gBAAgB,GAAkC,EAAE,CAAC;gBAC3D,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAa,gBAAgB,CAAC,EAAE,CAAC;oBAC7E,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAC,GAAG,MAAM,EAAE,GAAG,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,eAAe,EAAE,MAAM,CAAC,eAAe,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,eAAe,IAAI,KAAK,CAAC,EAAC,CAAC;gBACxL,CAAC;gBACD,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;gBAE/F,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;oBAClC,IAAI,OAAgB,CAAC;oBACrB,IAAI,WAAW,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;wBACtD,WAAW,CAAC,YAAY,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,YAAY,EAAE,IAAI,iBAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC,CAAC,CAAC;wBACpI,MAAM,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;wBAC5D,OAAO,GAAG,IAAI,oBAAO,EAAE,CAAC;oBACzB,CAAC;yBAAM,CAAC;wBACP,OAAO,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACpC,CAAC;oBAED,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC;wBAC5C,IAAA,kCAA0B,EAAC,OAAO,CAAC,CAAC;oBACrC,CAAC;oBACD,KAAK,MAAM,EAAC,MAAM,EAAC,IAAI,OAAO,EAAE,CAAC;wBAChC,MAAM,CAAC,OAAO,CAAC,CAAC;oBACjB,CAAC;oBACD,IAAA,4BAAoB,EAAC,OAAO,EAAE,WAAW,EAAE,oBAAoB,CAAC,CAAC;gBAClE,CAAC;YACF,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;IAEM,MAAM,CAAC,cAAc,CAAC,MAA6C;QACzE,OAAO,CAAC,gBAAgB,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE;gBACrD,OAAO;oBACN,GAAG,UAAU;oBACb,OAAO,EAAE,CAAC,IAAI,sBAAsB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;iBAC1D,CAAC;YACH,CAAC,CAAqD,CAAC;IACxD,CAAC;IAEO,iBAAiB;QACxB,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC7B,OAAO,IAAI,oBAAO,EAAE,CAAC;QACtB,CAAC;QAED,MAAM,aAAa,GAAG,gBAAE,CAAC,MAAM,CAAC,uBAAS,CAAC,OAAO,EAAE,yBAAyB,CAAC,CAAC;QAC9E,MAAM,GAAG,GAAG,IAAI,oBAAO,EAAE,CAAC;QAC1B,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;aACf,EAAE,CAAC,gBAAE,CAAC,MAAM,CAAC,gBAAE,CAAC,MAAM,CAAC,kBAAI,CAAC,IAAI,CAAC,yBAAyB,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,kBAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;aAC5I,OAAO,CAAC,aAAa,EAAE,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC;aACpC,MAAM,CAAC,SAAS,CAAC;aAClB,KAAK,EAAE,CAAC;QACV,OAAO,GAAG,CAAC;IACZ,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,UAAkB;QAChD,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC7D,CAAC;QACD,IAAI,CAAC;YACJ,MAAM,QAAQ,GAAG,MAAM,IAAA,mBAAQ,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,oBAAoB,CAAC,EAAE,OAAO,CAAC,CAAC;YACjF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,yBAAyB,CAAC,EAAE,CAAC;gBACnD,MAAM,IAAA,oBAAS,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,oBAAoB,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;YAC/H,CAAC;QACF,CAAC;QAAC,MAAM,CAAC;YACR,MAAM,IAAA,gBAAK,EAAC,UAAU,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;YAC3C,MAAM,IAAA,oBAAS,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,oBAAoB,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC;QACvG,CAAC;IACF,CAAC;IAED,6BAA6B;QAC5B,OAAO,EAAE,CAAC;IACX,CAAC;CACD"}

package/dist/plugins/wpml-config/WPMLConfigBuilder.d.ts

@@ -0,0 +1,24 @@
+import { type Compiler } from "webpack";
+import { CoordinatableEmitter, type CoordinatedEmissionTargetBuilder, type RootCoordinatorPlugin, type VerifiedAdvancedDestinationConfig, type VerifiedPlauditWordpressWebpackConfig } from "../../api";
+export declare class WPMLConfigEmitterPlugin extends CoordinatableEmitter {
+    protected readonly coordinator: RootCoordinatorPlugin;
+    private readonly config;
+    private readonly dest;
+    private readonly srcRoot;
+    private static jsdomInstance?;
+    private static domParser?;
+    private static xmlSerializer?;
+    private readonly parsedDocumentsCache;
+    constructor(coordinator: RootCoordinatorPlugin, config: VerifiedPlauditWordpressWebpackConfig, dest: VerifiedAdvancedDestinationConfig, srcRoot: string);
+    readonly provides: readonly ["unified-loader"];
+    get requires(): readonly [`blocks-directory:${string}`];
+    get defaultCompilationName(): string;
+    apply(compiler: Compiler): void;
+    getCoordinatedEmissionTargets(): CoordinatedEmissionTargetBuilder[];
+    private static getJSDOMInstance;
+    private static getDOMParser;
+    private static getXMLSerializer;
+    private static prettyPrintXML;
+    private loadWPMLConfigXML;
+}
+//# sourceMappingURL=WPMLConfigBuilder.d.ts.map

package/dist/plugins/wpml-config/WPMLConfigBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WPMLConfigBuilder.d.ts","sourceRoot":"","sources":["../../../src/plugins/wpml-config/WPMLConfigBuilder.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,KAAK,QAAQ,EAA6B,MAAM,SAAS,CAAC;AAG/E,OAAO,EACN,oBAAoB,EAAE,KAAK,gCAAgC,EAAE,KAAK,qBAAqB,EAAE,KAAK,iCAAiC,EAC/H,KAAK,qCAAqC,EAC1C,MAAM,WAAW,CAAC;AAyBnB,qBAAa,uBAAwB,SAAQ,oBAAoB;IAQ/D,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,qBAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAVzB,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAQ;IACrC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAY;IACrC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAgB;IAE7C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA0C;IAE/E,YACoB,WAAW,EAAE,qBAAqB,EACpC,MAAM,EAAE,qCAAqC,EAC7C,IAAI,EAAE,iCAAiC,EACvC,OAAO,EAAE,MAAM,EAGhC;IAED,SAAgB,QAAQ,YAAI,gBAAgB,EAAW;IAEvD,IAAW,QAAQ,4CAElB;IAED,IAAW,sBAAsB,WAEhC;IAED,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAwJ9B;IAED,6BAA6B,IAAI,gCAAgC,EAAE,CAElE;IAED,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAG/B,OAAO,CAAC,MAAM,CAAC,YAAY;IAG3B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAI/B,OAAO,CAAC,MAAM,CAAC,cAAc;YAcf,iBAAiB;CAyE/B"}

package/dist/plugins/wpml-config/WPMLConfigBuilder.js

@@ -0,0 +1,542 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WPMLConfigEmitterPlugin = void 0;
+const promises_1 = __importStar(require("node:fs/promises"));
+const node_path_1 = __importStar(require("node:path"));
+const expressions_1 = require("@plaudit/php-writer/expressions");
+const jsdom_1 = require("jsdom");
+const webpack_1 = require("webpack");
+const xml_formatter_1 = __importDefault(require("xml-formatter"));
+const api_1 = require("../../api");
+const utils_1 = require("../../utils");
+const UnifiedLoaderGenerator_1 = require("../unified-loader/UnifiedLoaderGenerator");
+class WPMLConfigEmitterPlugin extends api_1.CoordinatableEmitter {
+    coordinator;
+    config;
+    dest;
+    srcRoot;
+    static jsdomInstance;
+    static domParser;
+    static xmlSerializer;
+    parsedDocumentsCache = new Map();
+    constructor(coordinator, config, dest, srcRoot) {
+        super();
+        this.coordinator = coordinator;
+        this.config = config;
+        this.dest = dest;
+        this.srcRoot = srcRoot;
+    }
+    provides = ["unified-loader"];
+    get requires() {
+        return [`blocks-directory:${this.dest.destination}`];
+    }
+    get defaultCompilationName() {
+        return `wpml-config:${this.dest.destination}`;
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
+            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL }, async () => {
+                const rootWpmlConfigXmlSrc = (0, node_path_1.join)(this.srcRoot, "wpml-config.xml");
+                const blockJsonData = this.coordinator
+                    .getData(`blocks-directory:${this.dest.destination}`)
+                    .flatMap(Object.values);
+                let wpmlConfigs;
+                if ((await (0, promises_1.stat)(rootWpmlConfigXmlSrc, { throwIfNoEntry: false }))?.isFile()) {
+                    wpmlConfigs = [rootWpmlConfigXmlSrc, ...blockJsonData.map(v => v.wpmlConfigSrcPath).filter((v) => !!v)];
+                }
+                else {
+                    wpmlConfigs = blockJsonData.map(v => v.wpmlConfigSrcPath).filter((v) => !!v);
+                }
+                compilation.contextDependencies.addAll(wpmlConfigs);
+                const blockJsons = blockJsonData.map(v => v.blockJson);
+                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 await Promise.all(wpmlConfigs.map(request => this.loadWPMLConfigXML(request, compilation)))) {
+                    for (const category of nonMergeableCategories) {
+                        for (const [key, value] of Object.entries(wpmlConfig[category])) {
+                            if (key in mergedConfig[category]) {
+                                compilation.errors.push((0, utils_1.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((0, utils_1.newWebpackErrorForFile)(e, file));
+                            }
+                            else {
+                                compilation.errors.push(e);
+                            }
+                        }
+                    }
+                }
+                for (const blockJson of blockJsons) {
+                    const type = blockJson["name"]?.toString();
+                    if (typeof type !== 'string') {
+                        continue;
+                    }
+                    const blockConfig = {
+                        type,
+                        translate: blockJson['supports']?.['translation'] ?? true ? '1' : '0',
+                        keys: [],
+                        xPaths: []
+                    };
+                    if (typeof blockJson.plaudit === 'object' && !('group' in blockJson.plaudit) && 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 = WPMLConfigEmitterPlugin.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);
+                //TODO: CONSIDER: Add lazy-loader support
+                const wpmlEmitPath = node_path_1.default.join(this.dest.destination, "wpml-config.xml");
+                compilation[wpmlEmitPath in compilation.assets ? 'updateAsset' : 'emitAsset'](wpmlEmitPath, new webpack_1.sources.RawSource(WPMLConfigEmitterPlugin.prettyPrintXML(config)));
+                //TODO: This needs to still work in non-unified-loader mode
+                this.coordinator.reportData(compilation, this, "unified-loader", {
+                    group: "wpml-config",
+                    requiresBaseURI: true,
+                    action: file => {
+                        const wpml_config_class = expressions_1.Expr.namespacedRef("\\WPML_Config");
+                        const writer = file.getWriter("");
+                        if (writer.getLineCount() > 0) {
+                            writer.linebreak();
+                        }
+                        writer
+                            .if(wpml_config_class.isAvailable())
+                            .assign(wpml_config_class.access(new expressions_1.Var('wpml_config_files', 'array')), expressions_1.Op.concat(expressions_1.Constants.__DIR__, '/' + wpmlEmitPath.split(node_path_1.default.sep).join('/')), { push: true })
+                            .endIf();
+                    },
+                });
+            });
+        });
+    }
+    getCoordinatedEmissionTargets() {
+        return [UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.emissionTarget(this.config)];
+    }
+    static getJSDOMInstance() {
+        return WPMLConfigEmitterPlugin.jsdomInstance ?? (WPMLConfigEmitterPlugin.jsdomInstance = new jsdom_1.JSDOM("", { contentType: "text/html" }));
+    }
+    static getDOMParser() {
+        return WPMLConfigEmitterPlugin.domParser ?? (WPMLConfigEmitterPlugin.domParser = new (WPMLConfigEmitterPlugin.getJSDOMInstance().window.DOMParser)());
+    }
+    static getXMLSerializer() {
+        return WPMLConfigEmitterPlugin.xmlSerializer ?? (WPMLConfigEmitterPlugin.xmlSerializer = new (WPMLConfigEmitterPlugin.getJSDOMInstance().window.XMLSerializer)());
+    }
+    static prettyPrintXML(document) {
+        return (0, xml_formatter_1.default)(WPMLConfigEmitterPlugin.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 = WPMLConfigEmitterPlugin.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((0, utils_1.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((0, utils_1.newWebpackErrorForFile)(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
+                            continue;
+                        }
+                        const existing = res.shortcodes[shortcodeName];
+                        if (existing) {
+                            compilation.errors.push((0, utils_1.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((0, utils_1.newWebpackErrorForFile)(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
+                    break;
+            }
+        }
+        this.parsedDocumentsCache.set(file, res);
+        return [res, file];
+    }
+}
+exports.WPMLConfigEmitterPlugin = WPMLConfigEmitterPlugin;
+function importStandardTranslateOptionMap(element, file, type, actionMap, compilation) {
+    for (const child of element.children) {
+        const field = child.textContent;
+        if (!field) {
+            compilation.errors.push((0, utils_1.newWebpackErrorForFile)(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
+            continue;
+        }
+        const translate = child.getAttribute("translate");
+        if (!translate) {
+            compilation.errors.push((0, utils_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing the translate attribute.`, file));
+            continue;
+        }
+        const existing = actionMap[field];
+        if (existing) {
+            compilation.errors.push((0, utils_1.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((0, utils_1.newWebpackErrorForFile)(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
+            continue;
+        }
+        const action = child.getAttribute("action");
+        if (!action) {
+            compilation.errors.push((0, utils_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing an action.`, file));
+            continue;
+        }
+        const existing = actionMap[field];
+        if (existing) {
+            compilation.errors.push((0, utils_1.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 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);
+    }
+}
+//# sourceMappingURL=WPMLConfigBuilder.js.map