xml-disassembler 1.10.11 → 1.10.13

package/dist/index.umd.js

@@ -45,34 +45,49 @@
         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 = "    ";
@@ -89,25 +104,33 @@
     };
     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;
@@ -131,90 +154,91 @@
         });
     }
 
+    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) {
@@ -271,32 +295,39 @@
     }
 
     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) {
@@ -328,135 +359,135 @@
         });
     }
 
-    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) {
@@ -466,84 +497,69 @@
         }
         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);
-            }
         });
     }
 
@@ -553,75 +569,97 @@
         }
         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) {