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

package/dist/plugins/UnifiedLoaderGenerator.js

@@ -1,144 +0,0 @@
-"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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnifiedLoaderGenerator = void 0;
-const node_path_1 = __importStar(require("node:path"));
-const php_writer_1 = require("@plaudit/php-writer");
-const expressions_1 = require("@plaudit/php-writer/expressions");
-const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
-const shared_1 = require("../shared");
-const pseudo_semaphore_1 = require("../utils/pseudo-semaphore");
-const webpack_1 = require("webpack");
-const promises_1 = require("node:fs/promises");
-class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
-    config;
-    static semaphore = new pseudo_semaphore_1.PseudoSemaphore("Unified");
-    constructor(config) {
-        super("unified-loader", []);
-        this.config = config;
-    }
-    attachStandardPhase(compilation) {
-        compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-            compilation.deleteAsset("assets.json");
-        });
-    }
-    attachUniquePhase(compilation) {
-        this.tapRequiringAssetsJson(compilation, { stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-            const groupedLoaderInfo = Object.values((await UnifiedLoaderGenerator.semaphore.wait())
-                .reduce((acc, cur) => {
-                const accValue = acc[cur.group];
-                if (accValue === undefined) {
-                    acc[cur.group] = { ...cur, priority: cur.priority ?? 0, staticallyLoadedEntrypoints: cur.staticallyLoadedEntrypoints?.length ? [...cur.staticallyLoadedEntrypoints] : [] };
-                    return acc;
-                }
-                if (cur.priority && accValue.priority < cur.priority) {
-                    accValue.priority = cur.priority;
-                    accValue.action = cur.action;
-                    accValue.requiresBaseURI = cur.requiresBaseURI;
-                }
-                else if (cur.requiresBaseURI && !accValue.requiresBaseURI) {
-                    accValue.requiresBaseURI = cur.requiresBaseURI;
-                }
-                if (cur.staticallyLoadedEntrypoints?.length) {
-                    accValue.staticallyLoadedEntrypoints.push(...cur.staticallyLoadedEntrypoints);
-                }
-                return acc;
-            }, {}))
-                .sort((a, b) => {
-                const ap = a.priority ?? 0, bp = b.priority ?? 0;
-                return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
-            });
-            const staticallyLoadedEntrypoints = new Set(groupedLoaderInfo.flatMap(lig => lig.staticallyLoadedEntrypoints));
-            for (const [file, assetData] of Object.entries((0, shared_1.getAssetsJson)(compilation))) {
-                if (staticallyLoadedEntrypoints.has(file) || staticallyLoadedEntrypoints.has(file.replace(/\.css$/, '.js')) || staticallyLoadedEntrypoints.has(file.replace(/\.js$/, '.css'))) {
-                    continue;
-                }
-                const parsedPath = node_path_1.default.parse(file);
-                const contents = `<?php return ${(0, php_writer_1.json2php)(assetData)};\n`;
-                const assetName = node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php";
-                compilation[assetName in compilation.assets ? 'updateAsset' : 'emitAsset'](assetName, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
-            }
-            if (this.config.useUnifiedLoader) {
-                compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                    let phpFile;
-                    if (compilation.outputOptions.path?.endsWith("-dev")) {
-                        compilation['.gitignore' in compilation.assets ? 'updateAsset' : 'emitAsset']('.gitignore', new webpack_1.sources.RawSource('**'), { size: 2 });
-                        this.ensureDistExists(compilation.outputOptions.path);
-                        phpFile = new php_writer_1.PHPFile();
-                    }
-                    else {
-                        phpFile = this.withDistDevLoader();
-                    }
-                    if (groupedLoaderInfo.some(wc => wc.requiresBaseURI)) {
-                        (0, shared_1.emitResolveBaseUriFunction)(phpFile);
-                    }
-                    for (const { action } of groupedLoaderInfo) {
-                        action(phpFile);
-                    }
-                    (0, shared_1.emitPHPWriterAsAsset)(phpFile, compilation, "unified-loader.php");
-                });
-            }
-        });
-    }
-    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');
-        }
-    }
-}
-exports.UnifiedLoaderGenerator = UnifiedLoaderGenerator;

package/dist/plugins/VariablesJSMonitorPlugin.d.ts

@@ -1,7 +0,0 @@
-import type { VerifiedPlauditWordpressWebpackConfig } from "../shared";
-import type { Compiler, WebpackPluginInstance } from "webpack";
-export declare class VariablesJSMonitorPlugin implements WebpackPluginInstance {
-    private readonly config;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig);
-    apply(compiler: Compiler): void;
-}

package/dist/plugins/VariablesJSMonitorPlugin.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariablesJSMonitorPlugin = void 0;
-class VariablesJSMonitorPlugin {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    apply(compiler) {
-        const variablesFilePath = this.config.variablesFilePath;
-        if (variablesFilePath) {
-            compiler.hooks.make.tap(this.constructor.name, compilation => {
-                if (!compilation.fileDependencies.has(variablesFilePath)) {
-                    compilation.fileDependencies.add(variablesFilePath);
-                }
-            });
-        }
-    }
-}
-exports.VariablesJSMonitorPlugin = VariablesJSMonitorPlugin;

package/dist/plugins/WPMLConfigBuilder.d.ts

@@ -1,17 +0,0 @@
-import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
-    private readonly destDir;
-    private readonly referencePlugin;
-    private static jsdomInstance?;
-    private static domParser?;
-    private static xmlSerializer?;
-    private readonly parsedDocumentsCache;
-    constructor(destDir: string, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
-    apply(compiler: Compiler): void;
-    private static getJSDOMInstance;
-    private static getDOMParser;
-    private static getXMLSerializer;
-    private static prettyPrintXML;
-    private loadWPMLConfigXML;
-}

package/dist/plugins/WPMLConfigBuilder.js

@@ -1,472 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WPMLConfigBuilderPlugin = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const shared_1 = require("../shared");
-const jsdom_1 = require("jsdom");
-const webpack_1 = require("webpack");
-const xml_formatter_1 = __importDefault(require("xml-formatter"));
-class WPMLConfigBuilderPlugin {
-    destDir;
-    referencePlugin;
-    static jsdomInstance;
-    static domParser;
-    static xmlSerializer;
-    parsedDocumentsCache = new Map();
-    constructor(destDir, referencePlugin) {
-        this.destDir = destDir;
-        this.referencePlugin = referencePlugin;
-    }
-    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 blockJsonFiles = this.referencePlugin.getRelevantEntrypoints(compilation)
-                    .map(ep => ep.srcPath)
-                    .filter(srcPath => srcPath.endsWith("block.json"));
-                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(blockJsonFiles.map(async (request) => JSON.parse(await promises_1.default.readFile(request, 'utf8'))))
-                ]);
-                const wpmlEmitPath = node_path_1.default.join(this.destDir, "wpml-config.xml");
-                for (const name of Object.keys(assets)) {
-                    if (name.startsWith("wpml-config.xml") || name.startsWith(wpmlEmitPath)) {
-                        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((0, shared_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, shared_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 (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 = WPMLConfigBuilderPlugin.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);
-                compilation[wpmlEmitPath in compilation.assets ? 'updateAsset' : 'emitAsset'](wpmlEmitPath, new webpack_1.sources.RawSource(WPMLConfigBuilderPlugin.prettyPrintXML(config)));
-            });
-        });
-    }
-    static getJSDOMInstance() {
-        return WPMLConfigBuilderPlugin.jsdomInstance ?? (WPMLConfigBuilderPlugin.jsdomInstance = new jsdom_1.JSDOM("", { contentType: "text/html" }));
-    }
-    static getDOMParser() {
-        return WPMLConfigBuilderPlugin.domParser ?? (WPMLConfigBuilderPlugin.domParser = new (WPMLConfigBuilderPlugin.getJSDOMInstance().window.DOMParser)());
-    }
-    static getXMLSerializer() {
-        return WPMLConfigBuilderPlugin.xmlSerializer ?? (WPMLConfigBuilderPlugin.xmlSerializer = new (WPMLConfigBuilderPlugin.getJSDOMInstance().window.XMLSerializer)());
-    }
-    static prettyPrintXML(document) {
-        return (0, xml_formatter_1.default)(WPMLConfigBuilderPlugin.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 = WPMLConfigBuilderPlugin.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, shared_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, shared_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, shared_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, shared_1.newWebpackErrorForFile)(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
-                    break;
-            }
-        }
-        this.parsedDocumentsCache.set(file, res);
-        return [res, file];
-    }
-}
-exports.WPMLConfigBuilderPlugin = WPMLConfigBuilderPlugin;
-function importStandardTranslateOptionMap(element, file, type, actionMap, compilation) {
-    for (const child of element.children) {
-        const field = child.textContent;
-        if (!field) {
-            compilation.errors.push((0, shared_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, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing the translate attribute.`, file));
-            continue;
-        }
-        const existing = actionMap[field];
-        if (existing) {
-            compilation.errors.push((0, shared_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, shared_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, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing an action.`, file));
-            continue;
-        }
-        const existing = actionMap[field];
-        if (existing) {
-            compilation.errors.push((0, shared_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);
-    }
-}

package/dist/plugins/dependency-extraction-webpack-plugin-config-builder.d.ts

@@ -1,4 +0,0 @@
-import type { Externals } from "../shared";
-import { EnhancedDependencyExtractionWebpackPlugin } from "../wordpress-ports/dependency-extraction-webpack-plugin";
-import type { Configuration } from "webpack";
-export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, externalizing: Required<Configuration>['output']['library']): EnhancedDependencyExtractionWebpackPlugin;