xml-disassembler 1.10.10 → 1.10.12

package/dist/index.cjs

@@ -6,12 +6,12 @@ var posix = require('node:path/posix');
 var node_fs = require('node:fs');
 var node_path = require('node:path');
 var ignore = require('ignore');
-var node_crypto = require('node:crypto');
 var fastXmlParser = require('fast-xml-parser');
 var json5 = require('json5');
 var smolToml = require('smol-toml');
 var ini = require('ini');
 var yaml = require('yaml');
+var node_crypto = require('node:crypto');
 var promises$1 = require('fs/promises');
 
 /******************************************************************************
@@ -227,35 +227,6 @@ class ReassembleXMLFileHandler {
     }
 }
 
-function parseUniqueIdElement(element, uniqueIdElements) {
-    if (uniqueIdElements === undefined) {
-        return createShortHash(element);
-    }
-    const uniqueIdElementsArray = uniqueIdElements.split(",");
-    for (const fieldName of uniqueIdElementsArray) {
-        if (element[fieldName] !== undefined) {
-            if (typeof element[fieldName] === "string") {
-                return element[fieldName];
-            }
-        }
-    }
-    for (const key in element) {
-        if (typeof element[key] === "object" && element[key] !== null) {
-            const childFieldName = parseUniqueIdElement(element[key], uniqueIdElements);
-            if (childFieldName !== undefined) {
-                return childFieldName;
-            }
-        }
-    }
-    return createShortHash(element);
-}
-function createShortHash(element) {
-    const hash = node_crypto.createHash("sha256");
-    hash.update(JSON.stringify(element));
-    const fullHash = hash.digest("hex");
-    return fullHash.slice(0, 8);
-}
-
 function buildXMLString(element) {
     const xmlBuilder = new fastXmlParser.XMLBuilder(JSON_PARSER_OPTION);
     return xmlBuilder.build(element).trimEnd();
@@ -309,189 +280,182 @@ function getTransformer(format) {
     }
 }
 
-function buildNestedFile(element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, parentKey, format, xmlDeclaration) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fieldName = parseUniqueIdElement(element, uniqueIdElements);
-        const outputDirectory = posix.join(disassembledPath, parentKey);
-        const outputFileName = `${fieldName}.${parentKey}-meta.${format}`;
-        const outputPath = posix.join(outputDirectory, outputFileName);
-        yield promises.mkdir(outputDirectory, { recursive: true });
-        let finalXml = {
-            [rootElementName]: Object.assign(Object.assign({}, rootAttributes), { [parentKey]: element }),
-        };
-        if (typeof xmlDeclaration === "object" && xmlDeclaration !== null) {
-            finalXml = Object.assign({ "?xml": xmlDeclaration }, finalXml);
-        }
-        let nestedString;
-        const transformer = getTransformer(format);
-        if (transformer) {
-            nestedString = yield transformer(finalXml);
-        }
-        else {
-            nestedString = buildXMLString(finalXml);
+function parseUniqueIdElement(element, uniqueIdElements) {
+    var _a, _b;
+    if (!uniqueIdElements) {
+        return createShortHash(element);
+    }
+    const id = (_b = (_a = findDirectFieldMatch(element, uniqueIdElements.split(","))) !== null && _a !== void 0 ? _a : findNestedFieldMatch(element, uniqueIdElements)) !== null && _b !== void 0 ? _b : createShortHash(element);
+    return id;
+}
+function findDirectFieldMatch(element, fieldNames) {
+    for (const name of fieldNames) {
+        const value = element[name];
+        if (typeof value === "string") {
+            return value;
         }
-        yield promises.writeFile(outputPath, nestedString);
-        logger.debug(`Created disassembled file: ${outputPath}`);
-    });
+    }
 }
-
-function parseElement$1(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, leafCount, hasNestedElements, format, xmlDeclaration, } = params;
-        if (typeof element === "object" && element !== null) {
-            yield buildNestedFile(element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, format, xmlDeclaration);
-            return [{}, leafCount, true];
+function findNestedFieldMatch(element, uniqueIdElements) {
+    for (const key in element) {
+        const child = element[key];
+        if (typeof child === "object" && child !== null) {
+            const result = parseUniqueIdElement(child, uniqueIdElements);
+            if (result)
+                return result;
         }
-        const leafContent = {
-            [key]: [element],
-        };
-        return [leafContent, leafCount + 1, hasNestedElements];
-    });
+    }
+}
+function createShortHash(element) {
+    const hash = node_crypto.createHash("sha256")
+        .update(JSON.stringify(element))
+        .digest("hex");
+    return hash.slice(0, 8);
 }
 
-function buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootAttributes, format, xmlDeclaration) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const leafOutputPath = posix.join(disassembledPath, `${baseName}.${format}`);
-        yield promises.mkdir(disassembledPath, { recursive: true });
+function buildDisassembledFile(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ content, disassembledPath, outputFileName, subdirectory, wrapKey, isGroupedArray = false, rootElementName, rootAttributes, xmlDeclaration, format, uniqueIdElements, }) {
+        const targetDirectory = subdirectory
+            ? posix.join(disassembledPath, subdirectory)
+            : disassembledPath;
+        let fileName = outputFileName;
+        if (!fileName && wrapKey && !isGroupedArray && typeof content === "object") {
+            const fieldName = parseUniqueIdElement(content, uniqueIdElements);
+            fileName = `${fieldName}.${wrapKey}-meta.${format}`;
+        }
+        const outputPath = posix.join(targetDirectory, fileName);
+        yield promises.mkdir(targetDirectory, { recursive: true });
         let wrappedXml = {
-            [rootElementName]: Object.assign(Object.assign({}, rootAttributes), leafContent),
+            [rootElementName]: Object.assign(Object.assign({}, rootAttributes), (wrapKey
+                ? { [wrapKey]: isGroupedArray ? content : content }
+                : content)),
         };
         if (typeof xmlDeclaration === "object" && xmlDeclaration !== null) {
             wrappedXml = Object.assign({ "?xml": xmlDeclaration }, wrappedXml);
         }
-        let leafString;
         const transformer = getTransformer(format);
-        if (transformer) {
-            leafString = yield transformer(wrappedXml);
-        }
-        else {
-            leafString = buildXMLString(wrappedXml);
-        }
-        yield promises.writeFile(leafOutputPath, leafString);
-        logger.debug(`Created disassembled file: ${leafOutputPath}`);
+        const outputString = transformer
+            ? yield transformer(wrappedXml)
+            : buildXMLString(wrappedXml);
+        yield promises.writeFile(outputPath, outputString);
+        logger.debug(`Created disassembled file: ${outputPath}`);
     });
 }
 
-function extractRootAttributes(rootElement) {
-    const attributesOnly = {};
-    for (const [attrKey, attrValue] of Object.entries(rootElement)) {
-        if (attrKey.startsWith("@")) {
-            attributesOnly[attrKey] = attrValue;
+function extractRootAttributes(element) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(element)) {
+        if (key.startsWith("@") && typeof value === "string") {
+            attributes[key] = value;
         }
     }
-    return attributesOnly;
+    return attributes;
 }
 
-function buildDisassembledFiles$1(filePath, disassembledPath, uniqueIdElements, baseName, postPurge, format) {
+function parseElementUnified(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const parsedXml = yield parseXML(filePath);
-        if (parsedXml === undefined)
-            return;
-        const rawDeclaration = parsedXml["?xml"];
-        const xmlDeclaration = typeof rawDeclaration === "object" && rawDeclaration !== null
-            ? rawDeclaration
-            : undefined;
-        const rootElementName = Object.keys(parsedXml).find((k) => k !== "?xml");
-        const rootElement = parsedXml[rootElementName];
-        const rootAttributes = extractRootAttributes(rootElement);
-        let leafContent = {};
-        let leafCount = 0;
-        let hasNestedElements = false;
-        for (const key of Object.keys(rootElement).filter((k) => !k.startsWith("@"))) {
-            const elements = Array.isArray(rootElement[key])
-                ? rootElement[key]
-                : [rootElement[key]];
-            for (const element of elements) {
-                const [parsedLeafContent, updatedLeafCount, updatedHasNestedElements] = yield parseElement$1({
-                    element,
-                    disassembledPath,
-                    uniqueIdElements,
-                    rootElementName,
-                    rootAttributes,
-                    key,
-                    leafCount,
-                    hasNestedElements,
-                    format,
-                    xmlDeclaration,
-                });
-                const newContent = parsedLeafContent[key];
-                if (newContent !== undefined) {
-                    leafContent[key] = [
-                        ...((_a = leafContent[key]) !== null && _a !== void 0 ? _a : []),
-                        ...newContent,
-                    ];
-                }
-                leafCount = updatedLeafCount;
-                hasNestedElements = updatedHasNestedElements;
-            }
-        }
-        if (!hasNestedElements) {
-            logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
-            return;
-        }
-        if (leafCount > 0) {
-            yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootAttributes, format, xmlDeclaration);
-        }
-        if (postPurge) {
-            yield promises.unlink(filePath);
-        }
-    });
-}
-
-function parseElement(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { element, key, hasNestedElements } = params;
-        const nestedGroups = {};
+        const { element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, leafCount, hasNestedElements, format, xmlDeclaration, strategy, } = params;
         const isArray = Array.isArray(element);
         const isNestedObject = typeof element === "object" &&
             element !== null &&
             Object.keys(element).some((k) => !k.startsWith("#"));
         const isNested = isArray || isNestedObject;
         if (isNested) {
-            nestedGroups[key] = [element];
-            return {
-                leafContent: {},
-                leafCount: params.leafCount,
-                hasNestedElements: true,
-                nestedGroups,
-            };
+            if (strategy === "grouped-by-tag") {
+                return {
+                    leafContent: {},
+                    leafCount,
+                    hasNestedElements: true,
+                    nestedGroups: { [key]: [element] },
+                };
+            }
+            else {
+                yield buildDisassembledFile({
+                    content: element,
+                    disassembledPath,
+                    subdirectory: key,
+                    wrapKey: key,
+                    rootElementName,
+                    rootAttributes,
+                    xmlDeclaration,
+                    format,
+                    uniqueIdElements,
+                });
+                return {
+                    leafContent: {},
+                    leafCount,
+                    hasNestedElements: true,
+                };
+            }
         }
-        const leafContent = {
-            [key]: [element],
-        };
         return {
-            leafContent,
-            leafCount: params.leafCount + 1,
+            leafContent: {
+                [key]: [element],
+            },
+            leafCount: leafCount + 1,
             hasNestedElements,
-            nestedGroups,
         };
     });
 }
 
-function buildGroupedNestedFile(tag, elements, disassembledPath, rootElementName, rootAttributes, format, xmlDeclaration) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const outputPath = posix.join(disassembledPath, `${tag}.${format}`);
-        yield promises.mkdir(disassembledPath, { recursive: true });
-        let rootElement = {
-            [rootElementName]: Object.assign(Object.assign({}, rootAttributes), { [tag]: elements }),
-        };
-        if (typeof xmlDeclaration === "object" && xmlDeclaration !== null) {
-            rootElement = Object.assign({ "?xml": xmlDeclaration }, rootElement);
+function buildDisassembledFilesUnified(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ filePath, disassembledPath, baseName, postPurge, format, uniqueIdElements, strategy, }) {
+        const parsedXml = yield parseXML(filePath);
+        if (!parsedXml)
+            return;
+        const { rootElementName, rootElement, xmlDeclaration } = getRootInfo(parsedXml);
+        const rootAttributes = extractRootAttributes(rootElement);
+        const keyOrder = Object.keys(rootElement).filter((k) => !k.startsWith("@"));
+        const { leafContent, nestedGroups, leafCount, hasNestedElements } = yield disassembleElementKeys({
+            rootElement,
+            keyOrder,
+            disassembledPath,
+            rootElementName,
+            rootAttributes,
+            xmlDeclaration,
+            uniqueIdElements,
+            strategy,
+            format,
+        });
+        if (!hasNestedElements && leafCount > 0) {
+            logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
+            return;
         }
-        let nestedString;
-        const transformer = getTransformer(format);
-        if (transformer) {
-            nestedString = yield transformer(rootElement);
+        yield writeNestedGroups(nestedGroups, strategy, {
+            disassembledPath,
+            rootElementName,
+            rootAttributes,
+            xmlDeclaration,
+            format,
+        });
+        if (leafCount > 0) {
+            const finalLeafContent = strategy === "grouped-by-tag"
+                ? orderXmlElementKeys(leafContent, keyOrder)
+                : leafContent;
+            yield buildDisassembledFile({
+                content: finalLeafContent,
+                disassembledPath,
+                outputFileName: `${baseName}.${format}`,
+                rootElementName,
+                rootAttributes,
+                xmlDeclaration,
+                format,
+            });
         }
-        else {
-            nestedString = buildXMLString(rootElement);
+        if (postPurge) {
+            yield promises.unlink(filePath);
         }
-        yield promises.writeFile(outputPath, nestedString);
-        logger.debug(`Created disassembled file: ${outputPath}`);
     });
 }
-
+function getRootInfo(parsedXml) {
+    const rawDeclaration = parsedXml["?xml"];
+    const xmlDeclaration = typeof rawDeclaration === "object" && rawDeclaration !== null
+        ? rawDeclaration
+        : undefined;
+    const rootElementName = Object.keys(parsedXml).find((k) => k !== "?xml");
+    const rootElement = parsedXml[rootElementName];
+    return { rootElementName, rootElement, xmlDeclaration };
+}
 function orderXmlElementKeys(content, keyOrder) {
     const ordered = {};
     for (const key of keyOrder) {
@@ -501,65 +465,68 @@ function orderXmlElementKeys(content, keyOrder) {
     }
     return ordered;
 }
-function buildDisassembledFiles(filePath, disassembledPath, baseName, postPurge, format) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const parsedXml = yield parseXML(filePath);
-        if (parsedXml === undefined)
-            return;
-        const rawDeclaration = parsedXml["?xml"];
-        const xmlDeclaration = typeof rawDeclaration === "object" && rawDeclaration !== null
-            ? rawDeclaration
-            : undefined;
-        const rootElementName = Object.keys(parsedXml).find((k) => k !== "?xml");
-        const rootElement = parsedXml[rootElementName];
-        const rootAttributes = extractRootAttributes(rootElement);
+function disassembleElementKeys(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ rootElement, keyOrder, disassembledPath, rootElementName, rootAttributes, xmlDeclaration, uniqueIdElements, strategy, format, }) {
+        var _b, _c;
         let leafContent = {};
+        let nestedGroups = {};
         let leafCount = 0;
         let hasNestedElements = false;
-        const nestedGroups = {};
-        const keyOrder = Object.keys(rootElement).filter((k) => !k.startsWith("@"));
         for (const key of keyOrder) {
             const elements = Array.isArray(rootElement[key])
                 ? rootElement[key]
                 : [rootElement[key]];
             for (const element of elements) {
-                const result = yield parseElement({
+                const result = yield parseElementUnified({
                     element,
+                    disassembledPath,
+                    uniqueIdElements,
+                    rootElementName,
+                    rootAttributes,
                     key,
                     leafCount,
-                    hasNestedElements});
-                if (Object.keys(result.leafContent).length > 0) {
-                    const newContent = result.leafContent[key];
-                    if (newContent !== undefined) {
-                        leafContent[key] = [
-                            ...((_a = leafContent[key]) !== null && _a !== void 0 ? _a : []),
-                            ...newContent,
+                    hasNestedElements,
+                    format,
+                    xmlDeclaration,
+                    strategy,
+                });
+                if (result.leafContent[key]) {
+                    leafContent[key] = [
+                        ...((_b = leafContent[key]) !== null && _b !== void 0 ? _b : []),
+                        ...result.leafContent[key],
+                    ];
+                }
+                if (strategy === "grouped-by-tag" && result.nestedGroups) {
+                    for (const tag in result.nestedGroups) {
+                        nestedGroups[tag] = [
+                            ...((_c = nestedGroups[tag]) !== null && _c !== void 0 ? _c : []),
+                            ...result.nestedGroups[tag],
                         ];
                     }
                 }
                 leafCount = result.leafCount;
                 hasNestedElements = result.hasNestedElements;
-                for (const tag in result.nestedGroups) {
-                    if (!nestedGroups[tag])
-                        nestedGroups[tag] = [];
-                    nestedGroups[tag].push(...result.nestedGroups[tag]);
-                }
             }
         }
-        if (!hasNestedElements && leafCount > 0) {
-            logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
+        return { leafContent, nestedGroups, leafCount, hasNestedElements };
+    });
+}
+function writeNestedGroups(nestedGroups, strategy, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (strategy !== "grouped-by-tag")
             return;
-        }
         for (const tag in nestedGroups) {
-            yield buildGroupedNestedFile(tag, nestedGroups[tag], disassembledPath, rootElementName, rootAttributes, format, xmlDeclaration);
-        }
-        if (leafCount > 0) {
-            const orderedLeafContent = orderXmlElementKeys(leafContent, keyOrder);
-            yield buildLeafFile(orderedLeafContent, disassembledPath, baseName, rootElementName, rootAttributes, format, xmlDeclaration);
-        }
-        if (postPurge) {
-            yield promises.unlink(filePath);
+            yield buildDisassembledFile({
+                content: nestedGroups[tag],
+                disassembledPath: options.disassembledPath,
+                outputFileName: `${tag}.${options.format}`,
+                wrapKey: tag,
+                isGroupedArray: true,
+                rootElementName: options.rootElementName,
+                rootAttributes: options.rootAttributes,
+                xmlDeclaration: options.xmlDeclaration,
+                format: options.format,
+            });
         }
     });
 }
@@ -570,7 +537,11 @@ class DisassembleXMLFileHandler {
     }
     disassemble(xmlAttributes) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { filePath, uniqueIdElements, strategy = "unique-id", prePurge = false, postPurge = false, ignorePath = ".xmldisassemblerignore", format = "xml", } = xmlAttributes;
+            let { filePath, uniqueIdElements, strategy = "unique-id", prePurge = false, postPurge = false, ignorePath = ".xmldisassemblerignore", format = "xml", } = xmlAttributes;
+            if (!["unique-id", "grouped-by-tag"].includes(strategy)) {
+                logger.warn(`Unsupported strategy "${strategy}", defaulting to "unique-id".`);
+                strategy = "unique-id";
+            }
             const resolvedIgnorePath = node_path.resolve(ignorePath);
             if (node_fs.existsSync(resolvedIgnorePath)) {
                 const content = yield promises.readFile(resolvedIgnorePath);
@@ -633,12 +604,15 @@ class DisassembleXMLFileHandler {
             outputPath = node_path.join(dirPath, baseName);
             if (prePurge && node_fs.existsSync(outputPath))
                 yield promises.rm(outputPath, { recursive: true });
-            if (strategy === "grouped-by-tag") {
-                yield buildDisassembledFiles(filePath, outputPath, fullName, postPurge, format);
-            }
-            else {
-                yield buildDisassembledFiles$1(filePath, outputPath, uniqueIdElements, fullName, postPurge, format);
-            }
+            yield buildDisassembledFilesUnified({
+                filePath,
+                disassembledPath: outputPath,
+                uniqueIdElements,
+                baseName: fullName,
+                postPurge,
+                format,
+                strategy,
+            });
         });
     }
     posixPath(path) {