xml-disassembler 1.10.11 → 1.10.13

package/dist/index.cjs

@@ -55,34 +55,49 @@ function mergeXmlElements(elements) {
     const rootKey = Object.keys(first).find((k) => k !== "?xml");
     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] = [...value];
-            }
-            else if (typeof value === "object") {
-                if (Array.isArray(mergedContent[childKey])) {
-                    mergedContent[childKey].push(value);
-                }
-                else if (mergedContent[childKey]) {
-                    mergedContent[childKey] = [mergedContent[childKey], value];
-                }
-                else {
-                    mergedContent[childKey] = value;
-                }
-            }
-            else {
-                if (!mergedContent.hasOwnProperty(childKey)) {
-                    mergedContent[childKey] = value;
-                }
-            }
+        mergeElementContent(mergedContent, element[rootKey]);
+    }
+    return buildFinalXmlElement(first["?xml"], rootKey, mergedContent);
+}
+function mergeElementContent(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        if (Array.isArray(value)) {
+            mergeArrayValue(target, key, value);
+        }
+        else if (isMergeableObject(value)) {
+            mergeObjectValue(target, key, value);
+        }
+        else {
+            mergePrimitiveValue(target, key, value);
         }
     }
-    const declaration = first["?xml"];
-    const finalMerged = declaration
-        ? { "?xml": declaration, [rootKey]: mergedContent }
-        : { [rootKey]: mergedContent };
-    return finalMerged;
+}
+function mergeArrayValue(target, key, value) {
+    target[key] = [...value];
+}
+function mergeObjectValue(target, key, value) {
+    if (Array.isArray(target[key])) {
+        target[key].push(value);
+    }
+    else if (target[key]) {
+        target[key] = [target[key], value];
+    }
+    else {
+        target[key] = value;
+    }
+}
+function mergePrimitiveValue(target, key, value) {
+    if (!Object.prototype.hasOwnProperty.call(target, key)) {
+        target[key] = value;
+    }
+}
+function isMergeableObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function buildFinalXmlElement(declaration, rootKey, content) {
+    return declaration
+        ? { "?xml": declaration, [rootKey]: content }
+        : { [rootKey]: content };
 }
 
 const INDENT = "    ";
@@ -99,25 +114,33 @@ const XML_PARSER_OPTION = {
 };
 const JSON_PARSER_OPTION = Object.assign(Object.assign({}, XML_PARSER_OPTION), { format: true, indentBy: INDENT, suppressBooleanAttributes: false, suppressEmptyNode: false });
 
+function isEmptyTextNode(key, value) {
+    return key === "#text" && typeof value === "string" && value.trim() === "";
+}
+function cleanArray(arr) {
+    return arr
+        .map(stripWhitespaceTextNodes)
+        .filter((entry) => !(typeof entry === "object" && Object.keys(entry).length === 0));
+}
+function cleanObject(obj) {
+    const result = {};
+    for (const key in obj) {
+        const value = obj[key];
+        if (isEmptyTextNode(key, value))
+            continue;
+        const cleaned = stripWhitespaceTextNodes(value);
+        if (cleaned !== undefined) {
+            result[key] = cleaned;
+        }
+    }
+    return result;
+}
 function stripWhitespaceTextNodes(node) {
     if (Array.isArray(node)) {
-        return node.map(stripWhitespaceTextNodes).filter((entry) => {
-            return !(typeof entry === "object" && Object.keys(entry).length === 0);
-        });
+        return cleanArray(node);
     }
     else if (typeof node === "object" && node !== null) {
-        const result = {};
-        for (const key in node) {
-            const value = node[key];
-            if (key === "#text" && typeof value === "string" && value.trim() === "") {
-                continue;
-            }
-            const cleaned = stripWhitespaceTextNodes(value);
-            if (cleaned !== undefined) {
-                result[key] = cleaned;
-            }
-        }
-        return result;
+        return cleanObject(node);
     }
     else {
         return node;
@@ -141,90 +164,91 @@ function parseXML(filePath) {
     });
 }
 
+const parsers = {
+    ".yaml": yaml.parse,
+    ".yml": yaml.parse,
+    ".json": JSON.parse,
+    ".json5": json5.parse,
+    ".toml": smolToml.parse,
+    ".ini": ini.parse,
+};
 function parseToXmlObject(filePath) {
     return __awaiter(this, void 0, void 0, function* () {
         if (filePath.endsWith(".xml")) {
             return yield parseXML(filePath);
         }
+        const ext = Object.keys(parsers).find((ext) => filePath.endsWith(ext));
         const fileContent = yield promises$1.readFile(filePath, "utf-8");
-        let parsed;
-        if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-            parsed = yaml.parse(fileContent);
-        }
-        else if (filePath.endsWith(".json5")) {
-            parsed = json5.parse(fileContent);
-        }
-        else if (filePath.endsWith(".json")) {
-            parsed = JSON.parse(fileContent);
-        }
-        else if (filePath.endsWith(".toml")) {
-            parsed = smolToml.parse(fileContent);
-        }
-        else if (filePath.endsWith(".ini")) {
-            parsed = ini.parse(fileContent);
-        }
-        return parsed;
+        return parsers[ext](fileContent);
     });
 }
 
 class ReassembleXMLFileHandler {
+    reassemble(xmlAttributes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filePath, fileExtension, postPurge = false } = xmlAttributes;
+            if (!(yield this._validateDirectory(filePath)))
+                return;
+            logger.debug(`Parsing directory to reassemble: ${filePath}`);
+            const parsedXmlObjects = yield this.processFilesInDirectory(filePath);
+            if (!parsedXmlObjects.length) {
+                this._logEmptyParseError(filePath);
+                return;
+            }
+            const mergedXml = mergeXmlElements(parsedXmlObjects);
+            const finalXml = buildXMLString(mergedXml);
+            const outputPath = this._getOutputPath(filePath, fileExtension);
+            yield promises.writeFile(outputPath, finalXml, "utf-8");
+            if (postPurge)
+                yield promises.rm(filePath, { recursive: true });
+        });
+    }
     processFilesInDirectory(dirPath) {
         return __awaiter(this, void 0, void 0, function* () {
             const parsedXmlObjects = [];
             const files = yield promises.readdir(dirPath);
-            files.sort((fileA, fileB) => {
-                const fullNameA = fileA.split(".")[0].toLowerCase();
-                const fullNameB = fileB.split(".")[0].toLowerCase();
-                return fullNameA.localeCompare(fullNameB);
-            });
-            for (const file of files) {
+            const sortedFiles = this._sortFilesByBaseName(files);
+            for (const file of sortedFiles) {
                 const filePath = posix.join(dirPath, file);
                 const fileStat = yield promises.stat(filePath);
-                if (fileStat.isFile()) {
-                    if (/\.(xml|json|json5|ya?ml|toml|ini)$/.test(file)) {
-                        const parsedObject = yield parseToXmlObject(filePath);
-                        if (parsedObject === undefined)
-                            continue;
-                        parsedXmlObjects.push(parsedObject);
-                    }
+                if (fileStat.isFile() && this._isParsableFile(file)) {
+                    const parsed = yield parseToXmlObject(filePath);
+                    if (parsed)
+                        parsedXmlObjects.push(parsed);
                 }
                 else if (fileStat.isDirectory()) {
-                    const subParsedObjects = yield this.processFilesInDirectory(filePath);
-                    parsedXmlObjects.push(...subParsedObjects);
+                    const subParsed = yield this.processFilesInDirectory(filePath);
+                    parsedXmlObjects.push(...subParsed);
                 }
             }
             return parsedXmlObjects;
         });
     }
-    reassemble(xmlAttributes) {
+    _sortFilesByBaseName(files) {
+        return files.sort((a, b) => a.split(".")[0].localeCompare(b.split(".")[0]));
+    }
+    _isParsableFile(fileName) {
+        return /\.(xml|json|json5|ya?ml|toml|ini)$/i.test(fileName);
+    }
+    _validateDirectory(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { filePath, fileExtension, postPurge = false } = xmlAttributes;
-            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 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 mergedXml = mergeXmlElements(parsedXmlObjects);
-            const xmlContent = buildXMLString(mergedXml);
-            const finalXml = xmlContent;
-            const parentDirectory = posix.dirname(filePath);
-            const subdirectoryBasename = posix.basename(filePath);
-            const fileName = fileExtension
-                ? `${subdirectoryBasename}.${fileExtension}`
-                : `${subdirectoryBasename}.xml`;
-            const outputPath = posix.join(parentDirectory, fileName);
-            yield promises.writeFile(outputPath, finalXml, "utf-8");
-            if (postPurge) {
-                yield promises.rm(filePath, { recursive: true });
+            const stats = yield promises.stat(path);
+            if (!stats.isDirectory()) {
+                logger.error(`The provided path to reassemble is not a directory: ${path}`);
+                return false;
             }
+            return true;
         });
     }
+    _logEmptyParseError(path) {
+        logger.error(`No files under ${path} were parsed successfully. A reassembled XML file was not created.`);
+    }
+    _getOutputPath(dirPath, extension) {
+        const parentDir = posix.dirname(dirPath);
+        const baseName = posix.basename(dirPath);
+        const fileName = `${baseName}.${extension !== null && extension !== void 0 ? extension : "xml"}`;
+        return posix.join(parentDir, fileName);
+    }
 }
 
 function buildXMLString(element) {
@@ -281,32 +305,39 @@ function getTransformer(format) {
 }
 
 function parseUniqueIdElement(element, uniqueIdElements) {
-    if (uniqueIdElements === undefined) {
+    var _a, _b;
+    if (!uniqueIdElements) {
         return createShortHash(element);
     }
-    const uniqueIdElementsArray = uniqueIdElements.split(",");
-    for (const fieldName of uniqueIdElementsArray) {
-        if (element[fieldName] !== undefined) {
-            if (typeof element[fieldName] === "string") {
-                return element[fieldName];
-            }
+    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;
         }
     }
+}
+function findNestedFieldMatch(element, uniqueIdElements) {
     for (const key in element) {
-        if (typeof element[key] === "object" && element[key] !== null) {
-            const childFieldName = parseUniqueIdElement(element[key], uniqueIdElements);
-            if (childFieldName !== undefined) {
-                return childFieldName;
-            }
-        }
+        const child = element[key];
+        if (!isObject(child))
+            continue;
+        const result = parseUniqueIdElement(child, uniqueIdElements);
+        if (result)
+            return result;
     }
-    return createShortHash(element);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function createShortHash(element) {
-    const hash = node_crypto.createHash("sha256");
-    hash.update(JSON.stringify(element));
-    const fullHash = hash.digest("hex");
-    return fullHash.slice(0, 8);
+    const hash = node_crypto.createHash("sha256")
+        .update(JSON.stringify(element))
+        .digest("hex");
+    return hash.slice(0, 8);
 }
 
 function buildDisassembledFile(_a) {
@@ -338,135 +369,135 @@ function buildDisassembledFile(_a) {
     });
 }
 
-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 buildDisassembledFile({
-                content: element,
-                disassembledPath,
-                subdirectory: key,
-                wrapKey: key,
-                rootElementName,
-                rootAttributes,
-                xmlDeclaration,
-                format,
-                uniqueIdElements,
-            });
-            return [{}, leafCount, true];
-        }
-        const leafContent = {
-            [key]: [element],
-        };
-        return [leafContent, leafCount + 1, hasNestedElements];
-    });
-}
-
-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,
+        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) {
+            if (strategy === "grouped-by-tag") {
+                return {
+                    leafContent: {},
+                    leafCount,
+                    hasNestedElements: true,
+                    nestedGroups: { [key]: [element] },
+                };
+            }
+            else {
+                yield buildDisassembledFile({
+                    content: element,
                     disassembledPath,
-                    uniqueIdElements,
+                    subdirectory: key,
+                    wrapKey: key,
                     rootElementName,
                     rootAttributes,
-                    key,
-                    leafCount,
-                    hasNestedElements,
-                    format,
                     xmlDeclaration,
+                    format,
+                    uniqueIdElements,
                 });
-                const newContent = parsedLeafContent[key];
-                if (newContent !== undefined) {
-                    leafContent[key] = [
-                        ...((_a = leafContent[key]) !== null && _a !== void 0 ? _a : []),
-                        ...newContent,
-                    ];
-                }
-                leafCount = updatedLeafCount;
-                hasNestedElements = updatedHasNestedElements;
+                return {
+                    leafContent: {},
+                    leafCount,
+                    hasNestedElements: true,
+                };
             }
         }
-        if (!hasNestedElements) {
-            logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
+        return {
+            leafContent: {
+                [key]: [element],
+            },
+            leafCount: leafCount + 1,
+            hasNestedElements,
+        };
+    });
+}
+
+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;
-        }
-        if (leafCount > 0) {
-            yield buildDisassembledFile({
-                content: leafContent,
+        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 (shouldAbortForLeafOnly(leafCount, hasNestedElements, filePath))
+            return;
+        yield writeNestedGroups(nestedGroups, strategy, {
+            disassembledPath,
+            rootElementName,
+            rootAttributes,
+            xmlDeclaration,
+            format,
+        });
+        yield writeLeafContentIfAny({
+            leafCount,
+            leafContent,
+            strategy,
+            keyOrder,
+            options: {
                 disassembledPath,
                 outputFileName: `${baseName}.${format}`,
                 rootElementName,
                 rootAttributes,
                 xmlDeclaration,
                 format,
-            });
-        }
+            },
+        });
         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 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,
-            };
-        }
-        const leafContent = {
-            [key]: [element],
-        };
-        return {
-            leafContent,
-            leafCount: params.leafCount + 1,
-            hasNestedElements,
-            nestedGroups,
-        };
+function shouldAbortForLeafOnly(leafCount, hasNestedElements, filePath) {
+    if (!hasNestedElements && leafCount > 0) {
+        logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
+        return true;
+    }
+    return false;
+}
+function writeLeafContentIfAny(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ leafCount, leafContent, strategy, keyOrder, options, }) {
+        if (leafCount === 0)
+            return;
+        const finalLeafContent = strategy === "grouped-by-tag"
+            ? orderXmlElementKeys(leafContent, keyOrder)
+            : leafContent;
+        yield buildDisassembledFile(Object.assign({ content: finalLeafContent }, options));
     });
 }
-
+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) {
@@ -476,84 +507,69 @@ 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 buildDisassembledFile({
                 content: nestedGroups[tag],
-                disassembledPath,
-                outputFileName: `${tag}.${format}`,
+                disassembledPath: options.disassembledPath,
+                outputFileName: `${tag}.${options.format}`,
                 wrapKey: tag,
                 isGroupedArray: true,
-                rootElementName,
-                rootAttributes,
-                xmlDeclaration,
-                format,
+                rootElementName: options.rootElementName,
+                rootAttributes: options.rootAttributes,
+                xmlDeclaration: options.xmlDeclaration,
+                format: options.format,
             });
         }
-        if (leafCount > 0) {
-            const orderedLeafContent = orderXmlElementKeys(leafContent, keyOrder);
-            yield buildDisassembledFile({
-                content: orderedLeafContent,
-                disassembledPath,
-                outputFileName: `${baseName}.${format}`,
-                rootElementName,
-                rootAttributes,
-                xmlDeclaration,
-                format,
-            });
-        }
-        if (postPurge) {
-            yield promises.unlink(filePath);
-        }
     });
 }
 
@@ -563,75 +579,97 @@ 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;
-            const resolvedIgnorePath = node_path.resolve(ignorePath);
-            if (node_fs.existsSync(resolvedIgnorePath)) {
-                const content = yield promises.readFile(resolvedIgnorePath);
-                this.ign.add(content.toString());
+            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";
             }
+            yield this._loadIgnoreRules(ignorePath);
             const fileStat = yield promises.stat(filePath);
             const relativePath = this.posixPath(node_path.relative(process.cwd(), filePath));
             if (fileStat.isFile()) {
-                const resolvedPath = node_path.resolve(filePath);
-                if (!resolvedPath.endsWith(".xml")) {
-                    logger.error(`The file path provided is not an XML file: ${resolvedPath}`);
-                    return;
-                }
-                if (this.ign.ignores(relativePath)) {
-                    logger.warn(`File ignored by ${ignorePath}: ${resolvedPath}`);
-                    return;
-                }
-                const dirPath = node_path.dirname(resolvedPath);
-                yield this.processFile({
-                    dirPath,
-                    strategy,
-                    filePath: resolvedPath,
+                yield this._handleFile(filePath, relativePath, {
                     uniqueIdElements,
+                    strategy,
                     prePurge,
                     postPurge,
                     format,
                 });
             }
             else if (fileStat.isDirectory()) {
-                const subFiles = yield promises.readdir(filePath);
-                for (const subFile of subFiles) {
-                    const subFilePath = node_path.join(filePath, subFile);
-                    const relativeSubFilePath = this.posixPath(node_path.relative(process.cwd(), subFilePath));
-                    if (subFilePath.endsWith(".xml") &&
-                        !this.ign.ignores(relativeSubFilePath)) {
-                        yield this.processFile({
-                            dirPath: filePath,
-                            strategy,
-                            filePath: subFilePath,
-                            uniqueIdElements,
-                            prePurge,
-                            postPurge,
-                            format,
-                        });
-                    }
-                    else if (this.ign.ignores(relativeSubFilePath)) {
-                        logger.warn(`File ignored by ${ignorePath}: ${subFilePath}`);
-                    }
+                yield this._handleDirectory(filePath, {
+                    uniqueIdElements,
+                    strategy,
+                    prePurge,
+                    postPurge,
+                    format,
+                    ignorePath,
+                });
+            }
+        });
+    }
+    _loadIgnoreRules(ignorePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolvedIgnorePath = node_path.resolve(ignorePath);
+            if (node_fs.existsSync(resolvedIgnorePath)) {
+                const content = yield promises.readFile(resolvedIgnorePath);
+                this.ign.add(content.toString());
+            }
+        });
+    }
+    _handleFile(filePath, relativePath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolvedPath = node_path.resolve(filePath);
+            if (!this._isXmlFile(resolvedPath)) {
+                logger.error(`The file path provided is not an XML file: ${resolvedPath}`);
+                return;
+            }
+            if (this.ign.ignores(relativePath)) {
+                logger.warn(`File ignored by ignore rules: ${resolvedPath}`);
+                return;
+            }
+            const dirPath = node_path.dirname(resolvedPath);
+            yield this.processFile(Object.assign(Object.assign({}, options), { dirPath, filePath: resolvedPath }));
+        });
+    }
+    _handleDirectory(dirPath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subFiles = yield promises.readdir(dirPath);
+            for (const subFile of subFiles) {
+                const subFilePath = node_path.join(dirPath, subFile);
+                const relativeSubFilePath = this.posixPath(node_path.relative(process.cwd(), subFilePath));
+                if (this._isXmlFile(subFilePath) &&
+                    !this.ign.ignores(relativeSubFilePath)) {
+                    yield this.processFile(Object.assign(Object.assign({}, options), { dirPath, filePath: subFilePath }));
+                }
+                else if (this.ign.ignores(relativeSubFilePath)) {
+                    logger.warn(`File ignored by ignore rules: ${subFilePath}`);
                 }
             }
         });
     }
+    _isXmlFile(filePath) {
+        return filePath.endsWith(".xml");
+    }
     processFile(xmlAttributes) {
         return __awaiter(this, void 0, void 0, function* () {
             const { dirPath, strategy, filePath, uniqueIdElements, prePurge, postPurge, format, } = xmlAttributes;
             logger.debug(`Parsing file to disassemble: ${filePath}`);
             const fullName = node_path.basename(filePath, node_path.extname(filePath));
             const baseName = fullName.split(".")[0];
-            let outputPath;
-            outputPath = node_path.join(dirPath, baseName);
-            if (prePurge && node_fs.existsSync(outputPath))
+            const 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) {