@plaudit/webpack-extensions 2.38.0 → 2.40.0

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

@@ -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;