xml-disassembler 1.10.2 → 1.10.4

package/dist/index.umd.js

@@ -51,34 +51,6 @@
     };
     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 promises.writeFile(reassembledPath, `${xmlDeclarationStr}\n${xmlRootElementHeader}${finalXmlContent}${closeTag}`);
-            logger.debug(`Created reassembled file: ${reassembledPath}`);
-        });
-    }
-
-    function buildXMLString(element) {
-        const xmlBuilder = new fastXmlParser.XMLBuilder(JSON_PARSER_OPTION);
-        return xmlBuilder.build(element).trimEnd();
-    }
-
     function stripWhitespaceTextNodes(node) {
         if (Array.isArray(node)) {
             return node.map(stripWhitespaceTextNodes).filter((entry) => {
@@ -132,45 +104,10 @@
         });
     }
 
-    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 promises.readdir(dirPath);
                 files.sort((fileA, fileB) => {
                     const fullNameA = fileA.split(".")[0].toLowerCase();
@@ -185,47 +122,44 @@
                             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 promises.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 = posix.dirname(filePath);
                 const subdirectoryBasename = posix.basename(filePath);
                 const fileName = fileExtension
                     ? `${subdirectoryBasename}.${fileExtension}`
                     : `${subdirectoryBasename}.xml`;
                 const outputPath = posix.join(parentDirectory, fileName);
-                if (rootResult !== undefined) {
-                    const [rootElementName, rootElementHeader, xmlDeclarationStr] = rootResult;
-                    yield buildReassembledFile(combinedXmlContents, outputPath, rootElementName, rootElementHeader, xmlDeclarationStr);
-                    if (postPurge)
-                        yield promises.rm(filePath, { recursive: true });
-                }
-                else {
-                    logger.error(`No files under ${filePath} were parsed successfully. A reassembled XML file was not created.`);
+                yield promises.writeFile(outputPath, finalXml, "utf-8");
+                if (postPurge) {
+                    yield promises.rm(filePath, { recursive: true });
                 }
             });
         }
@@ -255,6 +189,51 @@
             });
         }
     }
+    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) {
@@ -285,6 +264,11 @@
         return fullHash.slice(0, 8);
     }
 
+    function buildXMLString(element) {
+        const xmlBuilder = new fastXmlParser.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);
@@ -371,26 +355,27 @@
 
     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 = posix.join(disassembledPath, `${baseName}.xml`);
-            yield promises.writeFile(leafOutputPath, leafFile);
+            yield promises.mkdir(disassembledPath, { recursive: true });
+            const wrappedXml = {
+                [rootElementName]: Object.assign(Object.assign({}, rootAttributes), leafContent),
+            };
+            const serialized = `${xmlDeclarationStr}\n${buildXMLString(wrappedXml)}`;
+            yield promises.writeFile(leafOutputPath, serialized);
             logger.debug(`Created disassembled file: ${leafOutputPath}`);
             const transformer = getTransformer(format);
             if (transformer) {
@@ -400,6 +385,18 @@
         });
     }
 
+    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)) {
@@ -410,7 +407,7 @@
         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)
@@ -418,49 +415,40 @@
             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;
                 }
@@ -470,38 +458,41 @@
                 return;
             }
             if (leafCount > 0) {
-                yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootElementHeader, xmlDeclarationStr, format);
+                yield buildLeafFile(leafContent, disassembledPath, baseName, rootElementName, rootAttributes, xmlDeclarationStr, format);
             }
             if (postPurge) {
-                promises.unlink(filePath);
+                yield promises.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,
+            };
         });
     }
 
@@ -523,21 +514,31 @@
         });
     }
 
-    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]];
@@ -545,21 +546,33 @@
                     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;
             }
@@ -567,7 +580,8 @@
                 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 promises.unlink(filePath);
@@ -645,10 +659,10 @@
                 if (prePurge && node_fs.existsSync(outputPath))
                     yield promises.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);
                 }
             });
         }