xml-disassembler 1.10.2 → 1.10.4

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { getLogger, configure } from 'log4js';
-import { writeFile, readFile, readdir, stat, rm, mkdir, unlink } from 'node:fs/promises';
+import { readFile, readdir, stat, writeFile, rm, mkdir, unlink } from 'node:fs/promises';
 import { join, dirname, basename } from 'node:path/posix';
 import { parse, stringify } from 'yaml';
 import { parse as parse$1, stringify as stringify$1 } from 'json5';
@@ -9,7 +9,7 @@ import { existsSync } from 'node:fs';
 import { resolve, relative, dirname as dirname$1, join as join$1, basename as basename$1, extname } from 'node:path';
 import ignore from 'ignore';
 import { createHash } from 'node:crypto';
-import { XMLBuilder, XMLParser } from 'fast-xml-parser';
+import { XMLParser, XMLBuilder } from 'fast-xml-parser';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -58,34 +58,6 @@ const XML_PARSER_OPTION = {
 };
 const JSON_PARSER_OPTION = Object.assign(Object.assign({}, XML_PARSER_OPTION), { format: true, indentBy: INDENT, suppressBooleanAttributes: false, suppressEmptyNode: false });
 
-function buildReassembledFile(combinedXmlContents, reassembledPath, xmlElement, xmlRootElementHeader, xmlDeclarationStr) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let finalXmlContent = combinedXmlContents.join("\n");
-        const escapedXmlDeclaration = xmlDeclarationStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const xmlDeclarationLineRegex = new RegExp(`^\\s*${escapedXmlDeclaration}\\s*$`, "gm");
-        finalXmlContent = finalXmlContent.replace(xmlDeclarationLineRegex, "");
-        finalXmlContent = finalXmlContent.replace(new RegExp(`<${xmlElement}\\s*[^>]*>`, "g"), "");
-        finalXmlContent = finalXmlContent.replace(new RegExp(`</${xmlElement}>`, "g"), "");
-        finalXmlContent = finalXmlContent.replace(/<!\[CDATA\[\s*([\s\S]*?)\s*]]>/g, function (_, cdataContent) {
-            const trimmedContent = cdataContent.trim();
-            const lines = trimmedContent.split("\n");
-            const indentedLines = lines.map(function (line) {
-                return line.replace(/^\s*/, "");
-            });
-            return ("<![CDATA[\n" + INDENT + indentedLines.join("\n" + INDENT) + "\n]]>");
-        });
-        finalXmlContent = finalXmlContent.replace(/(\n\s*){2,}/g, `\n${INDENT}`);
-        const closeTag = `</${xmlElement}>`;
-        yield writeFile(reassembledPath, `${xmlDeclarationStr}\n${xmlRootElementHeader}${finalXmlContent}${closeTag}`);
-        logger.debug(`Created reassembled file: ${reassembledPath}`);
-    });
-}
-
-function buildXMLString(element) {
-    const xmlBuilder = new XMLBuilder(JSON_PARSER_OPTION);
-    return xmlBuilder.build(element).trimEnd();
-}
-
 function stripWhitespaceTextNodes(node) {
     if (Array.isArray(node)) {
         return node.map(stripWhitespaceTextNodes).filter((entry) => {
@@ -139,45 +111,10 @@ function parseXML(input_1) {
     });
 }
 
-function buildRootElementHeader(rootElement, rootElementName) {
-    let rootElementHeader = `<${rootElementName}`;
-    for (const [attrKey, attrValue] of Object.entries(rootElement)) {
-        if (attrKey.startsWith("@")) {
-            const cleanAttrKey = attrKey.slice(2);
-            rootElementHeader += ` ${cleanAttrKey}="${String(attrValue)}"`;
-        }
-    }
-    rootElementHeader += ">";
-    return rootElementHeader;
-}
-
-function buildXMLDeclaration(parsedXml) {
-    let xmlDeclarationStr = XML_DEFAULT_DECLARATION;
-    if (parsedXml["?xml"]) {
-        const xmlDeclaration = parsedXml["?xml"];
-        const attributes = Object.entries(xmlDeclaration)
-            .map(([key, value]) => `${key.replace("@_", "")}="${value}"`)
-            .join(" ");
-        xmlDeclarationStr = `<?xml ${attributes}?>`;
-    }
-    return xmlDeclarationStr;
-}
-
-function parseRootElement(xmlParsed) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const xmlDeclarationStr = buildXMLDeclaration(xmlParsed);
-        const rootElementName = Object.keys(xmlParsed)[1];
-        const rootElement = xmlParsed[rootElementName];
-        const rootElementHeader = buildRootElementHeader(rootElement, rootElementName);
-        return [rootElementName, rootElementHeader, xmlDeclarationStr];
-    });
-}
-
 class ReassembleXMLFileHandler {
     processFilesInDirectory(dirPath) {
         return __awaiter(this, void 0, void 0, function* () {
-            const combinedXmlContents = [];
-            let rootResult = undefined;
+            const parsedXmlObjects = [];
             const files = yield readdir(dirPath);
             files.sort((fileA, fileB) => {
                 const fullNameA = fileA.split(".")[0].toLowerCase();
@@ -192,47 +129,44 @@ class ReassembleXMLFileHandler {
                         const parsedObject = yield this.parseToXmlObject(filePath);
                         if (parsedObject === undefined)
                             continue;
-                        const rootResultFromFile = yield parseRootElement(parsedObject);
-                        rootResult = rootResultFromFile;
-                        const combinedXmlString = buildXMLString(parsedObject);
-                        combinedXmlContents.push(combinedXmlString);
+                        parsedXmlObjects.push(parsedObject);
                     }
                 }
                 else if (fileStat.isDirectory()) {
-                    const [subCombinedXmlContents, subRootResult] = yield this.processFilesInDirectory(filePath);
-                    combinedXmlContents.push(...subCombinedXmlContents);
-                    rootResult = subRootResult;
+                    const subParsedObjects = yield this.processFilesInDirectory(filePath);
+                    parsedXmlObjects.push(...subParsedObjects);
                 }
             }
-            return [combinedXmlContents, rootResult];
+            return parsedXmlObjects;
         });
     }
     reassemble(xmlAttributes) {
         return __awaiter(this, void 0, void 0, function* () {
             const { filePath, fileExtension, postPurge = false } = xmlAttributes;
-            let combinedXmlContents = [];
             const fileStat = yield stat(filePath);
             if (!fileStat.isDirectory()) {
                 logger.error(`The provided path to reassemble is not a directory: ${filePath}`);
                 return;
             }
             logger.debug(`Parsing directory to reassemble: ${filePath}`);
-            const [subCombinedXmlContents, rootResult] = yield this.processFilesInDirectory(filePath);
-            combinedXmlContents = subCombinedXmlContents;
+            const parsedXmlObjects = yield this.processFilesInDirectory(filePath);
+            if (!parsedXmlObjects.length) {
+                logger.error(`No files under ${filePath} were parsed successfully. A reassembled XML file was not created.`);
+                return;
+            }
+            const { xml: mergedXml, declaration } = mergeXmlElements(parsedXmlObjects);
+            const xmlDeclarationStr = createXmlDeclaration(declaration);
+            const xmlContent = buildXMLString(mergedXml);
+            const finalXml = xmlDeclarationStr + xmlContent;
             const parentDirectory = dirname(filePath);
             const subdirectoryBasename = basename(filePath);
             const fileName = fileExtension
                 ? `${subdirectoryBasename}.${fileExtension}`
                 : `${subdirectoryBasename}.xml`;
             const outputPath = join(parentDirectory, fileName);
-            if (rootResult !== undefined) {
-                const [rootElementName, rootElementHeader, xmlDeclarationStr] = rootResult;
-                yield buildReassembledFile(combinedXmlContents, outputPath, rootElementName, rootElementHeader, xmlDeclarationStr);
-                if (postPurge)
-                    yield rm(filePath, { recursive: true });
-            }
-            else {
-                logger.error(`No files under ${filePath} were parsed successfully. A reassembled XML file was not created.`);
+            yield writeFile(outputPath, finalXml, "utf-8");
+            if (postPurge) {
+                yield rm(filePath, { recursive: true });
             }
         });
     }
@@ -262,6 +196,51 @@ class ReassembleXMLFileHandler {
         });
     }
 }
+function mergeXmlElements(elements) {
+    if (elements.length === 0)
+        throw new Error("No elements to merge.");
+    const first = elements[0];
+    const declaration = first['?xml'];
+    const rootKey = Object.keys(first).find((k) => k !== '?xml');
+    if (!rootKey) {
+        throw new Error("No root element found in the provided XML elements.");
+    }
+    const mergedContent = {};
+    for (const element of elements) {
+        const current = element[rootKey];
+        for (const [childKey, value] of Object.entries(current)) {
+            if (Array.isArray(value)) {
+                mergedContent[childKey] = mergedContent[childKey]
+                    ? mergedContent[childKey].concat(value)
+                    : [...value];
+            }
+            else if (typeof value === "object") {
+                mergedContent[childKey] = mergedContent[childKey]
+                    ? [].concat(mergedContent[childKey], value)
+                    : [value];
+            }
+            else {
+                if (!mergedContent.hasOwnProperty(childKey)) {
+                    mergedContent[childKey] = value;
+                }
+            }
+        }
+    }
+    return {
+        xml: { [rootKey]: mergedContent },
+        declaration,
+    };
+}
+function createXmlDeclaration(declaration) {
+    let declarationStr = `${XML_DEFAULT_DECLARATION}\n`;
+    if (declaration) {
+        const attributes = Object.entries(declaration)
+            .map(([key, value]) => `${key.replace("@_", "")}="${value}"`)
+            .join(" ");
+        declarationStr = `<?xml ${attributes}?>\n`;
+    }
+    return declarationStr;
+}
 
 function parseUniqueIdElement(element, uniqueIdElements) {
     if (uniqueIdElements === undefined) {
@@ -292,6 +271,11 @@ function createShortHash(element) {
     return fullHash.slice(0, 8);
 }
 
+function buildXMLString(element) {
+    const xmlBuilder = new XMLBuilder(JSON_PARSER_OPTION);
+    return xmlBuilder.build(element).trimEnd();
+}
+
 function transformToYaml(xmlPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const parsedXml = yield parseXML(xmlPath);
@@ -378,26 +362,27 @@ function buildNestedFile(element, disassembledPath, uniqueIdElements, rootElemen
 
 function parseElement$1(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, indent, leafContent, leafCount, hasNestedElements, xmlDeclarationStr, format, } = params;
-        if (typeof element === "object") {
+        const { element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, leafCount, hasNestedElements, xmlDeclarationStr, format, } = params;
+        if (typeof element === "object" && element !== null) {
             yield buildNestedFile(element, disassembledPath, uniqueIdElements, rootElementName, rootAttributes, key, xmlDeclarationStr, format);
-            return [leafContent, leafCount, true];
-        }
-        else {
-            const updatedLeafContent = `${leafContent}${indent}<${key}>${String(element)}</${key}>\n`;
-            return [updatedLeafContent, leafCount + 1, hasNestedElements];
+            return [{}, leafCount, true];
         }
+        const leafContent = {
+            [key]: element,
+        };
+        return [leafContent, leafCount + 1, hasNestedElements];
     });
 }
 
-function buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootElementHeader, xmlDeclarationStr, format) {
+function buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootAttributes, xmlDeclarationStr, format) {
     return __awaiter(this, void 0, void 0, function* () {
-        let leafFile = `${xmlDeclarationStr}\n`;
-        leafFile += `${rootElementHeader}\n`;
-        leafFile += leafContent;
-        leafFile += `</${rootElementName}>`;
         const leafOutputPath = join(disassembledPath, `${baseName}.xml`);
-        yield writeFile(leafOutputPath, leafFile);
+        yield mkdir(disassembledPath, { recursive: true });
+        const wrappedXml = {
+            [rootElementName]: Object.assign(Object.assign({}, rootAttributes), leafContent),
+        };
+        const serialized = `${xmlDeclarationStr}\n${buildXMLString(wrappedXml)}`;
+        yield writeFile(leafOutputPath, serialized);
         logger.debug(`Created disassembled file: ${leafOutputPath}`);
         const transformer = getTransformer(format);
         if (transformer) {
@@ -407,6 +392,18 @@ function buildLeafFile(leafContent, disassembledPath, baseName, rootElementName,
     });
 }
 
+function buildXMLDeclaration(parsedXml) {
+    let xmlDeclarationStr = XML_DEFAULT_DECLARATION;
+    if (parsedXml["?xml"]) {
+        const xmlDeclaration = parsedXml["?xml"];
+        const attributes = Object.entries(xmlDeclaration)
+            .map(([key, value]) => `${key.replace("@_", "")}="${value}"`)
+            .join(" ");
+        xmlDeclarationStr = `<?xml ${attributes}?>`;
+    }
+    return xmlDeclarationStr;
+}
+
 function extractRootAttributes(rootElement) {
     const attributesOnly = {};
     for (const [attrKey, attrValue] of Object.entries(rootElement)) {
@@ -417,7 +414,7 @@ function extractRootAttributes(rootElement) {
     return attributesOnly;
 }
 
-function buildDisassembledFiles$1(filePath, disassembledPath, uniqueIdElements, baseName, indent, postPurge, format) {
+function buildDisassembledFiles$1(filePath, disassembledPath, uniqueIdElements, baseName, postPurge, format) {
     return __awaiter(this, void 0, void 0, function* () {
         const parsedXml = yield parseXML(filePath);
         if (parsedXml === undefined)
@@ -425,49 +422,40 @@ function buildDisassembledFiles$1(filePath, disassembledPath, uniqueIdElements,
         const rootElementName = Object.keys(parsedXml)[1];
         const xmlDeclarationStr = buildXMLDeclaration(parsedXml);
         const rootElement = parsedXml[rootElementName];
-        const rootElementHeader = buildRootElementHeader(rootElement, rootElementName);
         const rootAttributes = extractRootAttributes(rootElement);
-        let leafContent = "";
+        let leafContent = {};
         let leafCount = 0;
         let hasNestedElements = false;
-        for (const key of Object.keys(rootElement).filter((key) => !key.startsWith("@"))) {
-            if (Array.isArray(rootElement[key])) {
-                for (const element of rootElement[key]) {
-                    const [updatedLeafContent, updatedLeafCount, updatedHasNestedElements] = yield parseElement$1({
-                        element,
-                        disassembledPath,
-                        uniqueIdElements,
-                        rootElementName,
-                        rootAttributes,
-                        key,
-                        indent,
-                        leafContent,
-                        leafCount,
-                        hasNestedElements,
-                        xmlDeclarationStr,
-                        format,
-                    });
-                    leafContent = updatedLeafContent;
-                    leafCount = updatedLeafCount;
-                    hasNestedElements = updatedHasNestedElements;
-                }
-            }
-            else {
-                const [updatedLeafContent, updatedLeafCount, updatedHasNestedElements] = yield parseElement$1({
-                    element: rootElement[key],
+        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,
-                    indent,
-                    leafContent,
                     leafCount,
                     hasNestedElements,
                     xmlDeclarationStr,
                     format,
                 });
-                leafContent = updatedLeafContent;
+                const newContent = parsedLeafContent[key];
+                if (newContent !== undefined) {
+                    const existing = leafContent[key];
+                    const existingArray = Array.isArray(existing)
+                        ? existing
+                        : existing !== undefined
+                            ? [existing]
+                            : [];
+                    const incomingArray = Array.isArray(newContent)
+                        ? newContent
+                        : [newContent];
+                    leafContent[key] = [...existingArray, ...incomingArray];
+                }
                 leafCount = updatedLeafCount;
                 hasNestedElements = updatedHasNestedElements;
             }
@@ -477,38 +465,41 @@ function buildDisassembledFiles$1(filePath, disassembledPath, uniqueIdElements,
             return;
         }
         if (leafCount > 0) {
-            yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootElementHeader, xmlDeclarationStr, format);
+            yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootAttributes, xmlDeclarationStr, format);
         }
         if (postPurge) {
-            unlink(filePath);
+            yield unlink(filePath);
         }
     });
 }
 
 function parseElement(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { element, key, indent, leafContent, leafCount, hasNestedElements } = params;
+        const { element, key, hasNestedElements } = params;
         const nestedGroups = {};
-        if (typeof element === "object") {
-            if (!nestedGroups[key])
-                nestedGroups[key] = [];
-            nestedGroups[key].push(element);
+        const isArray = Array.isArray(element);
+        const isObjectWithMultipleFields = typeof element === "object" &&
+            element !== null &&
+            Object.keys(element).length > 1;
+        const isNested = isArray || isObjectWithMultipleFields;
+        if (isNested) {
+            nestedGroups[key] = [element];
             return {
-                leafContent,
-                leafCount,
+                leafContent: {},
+                leafCount: params.leafCount,
                 hasNestedElements: true,
                 nestedGroups,
             };
         }
-        else {
-            const updatedLeafContent = `${leafContent}${indent}<${key}>${String(element)}</${key}>\n`;
-            return {
-                leafContent: updatedLeafContent,
-                leafCount: leafCount + 1,
-                hasNestedElements,
-                nestedGroups,
-            };
-        }
+        const leafContent = {
+            [key]: element,
+        };
+        return {
+            leafContent,
+            leafCount: params.leafCount + 1,
+            hasNestedElements,
+            nestedGroups,
+        };
     });
 }
 
@@ -530,21 +521,31 @@ function buildGroupedNestedFile(tag, elements, disassembledPath, rootElementName
     });
 }
 
-function buildDisassembledFiles(filePath, disassembledPath, baseName, indent, postPurge, format) {
+function orderXmlElementKeys(content, keyOrder) {
+    const ordered = {};
+    for (const key of keyOrder) {
+        if (content[key] !== undefined) {
+            ordered[key] = content[key];
+        }
+    }
+    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 rootElementName = Object.keys(parsedXml)[1];
         const xmlDeclarationStr = buildXMLDeclaration(parsedXml);
         const rootElement = parsedXml[rootElementName];
-        const rootElementHeader = buildRootElementHeader(rootElement, rootElementName);
         const rootAttributes = extractRootAttributes(rootElement);
-        let leafContent = "";
+        let leafContent = {};
         let leafCount = 0;
         let hasNestedElements = false;
         const nestedGroups = {};
-        for (const key of Object.keys(rootElement).filter((key) => !key.startsWith("@"))) {
+        const keyOrder = Object.keys(parsedXml[rootElementName]).filter((k) => !k.startsWith("@"));
+        for (const key of keyOrder) {
             const elements = Array.isArray(rootElement[key])
                 ? rootElement[key]
                 : [rootElement[key]];
@@ -552,21 +553,33 @@ function buildDisassembledFiles(filePath, disassembledPath, baseName, indent, po
                 const result = yield parseElement({
                     element,
                     key,
-                    indent,
-                    leafContent,
                     leafCount,
                     hasNestedElements});
-                leafContent = result.leafContent;
+                if (Object.keys(result.leafContent).length > 0) {
+                    const newContent = result.leafContent[key];
+                    if (newContent !== undefined) {
+                        const existing = leafContent[key];
+                        const existingArray = Array.isArray(existing)
+                            ? existing
+                            : existing !== undefined
+                                ? [existing]
+                                : [];
+                        const incomingArray = Array.isArray(newContent)
+                            ? newContent
+                            : [newContent];
+                        leafContent[key] = [...existingArray, ...incomingArray];
+                    }
+                }
                 leafCount = result.leafCount;
                 hasNestedElements = result.hasNestedElements;
                 for (const tag in result.nestedGroups) {
                     if (!nestedGroups[tag])
                         nestedGroups[tag] = [];
-                    nestedGroups[tag].push(...result.nestedGroups[tag]);
+                    nestedGroups[tag].push(...((_a = result.nestedGroups[tag]) !== null && _a !== void 0 ? _a : []));
                 }
             }
         }
-        if (!hasNestedElements) {
+        if (!hasNestedElements && leafCount > 0) {
             logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
             return;
         }
@@ -574,7 +587,8 @@ function buildDisassembledFiles(filePath, disassembledPath, baseName, indent, po
             yield buildGroupedNestedFile(tag, nestedGroups[tag], disassembledPath, rootElementName, rootAttributes, xmlDeclarationStr, format);
         }
         if (leafCount > 0) {
-            yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootElementHeader, xmlDeclarationStr, format);
+            const orderedLeafContent = orderXmlElementKeys(leafContent, keyOrder);
+            yield buildLeafFile(orderedLeafContent, disassembledPath, baseName, rootElementName, rootAttributes, xmlDeclarationStr, format);
         }
         if (postPurge) {
             yield unlink(filePath);
@@ -652,10 +666,10 @@ class DisassembleXMLFileHandler {
             if (prePurge && existsSync(outputPath))
                 yield rm(outputPath, { recursive: true });
             if (strategy === "grouped-by-tag") {
-                yield buildDisassembledFiles(filePath, outputPath, fullName, INDENT, postPurge, format);
+                yield buildDisassembledFiles(filePath, outputPath, fullName, postPurge, format);
             }
             else {
-                yield buildDisassembledFiles$1(filePath, outputPath, uniqueIdElements, fullName, INDENT, postPurge, format);
+                yield buildDisassembledFiles$1(filePath, outputPath, uniqueIdElements, fullName, postPurge, format);
             }
         });
     }