xml-disassembler 1.10.12 → 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) {
@@ -289,13 +313,16 @@
     function findNestedFieldMatch(element, uniqueIdElements) {
         for (const key in element) {
             const child = element[key];
-            if (typeof child === "object" && child !== null) {
-                const result = parseUniqueIdElement(child, uniqueIdElements);
-                if (result)
-                    return result;
-            }
+            if (!isObject(child))
+                continue;
+            const result = parseUniqueIdElement(child, uniqueIdElements);
+            if (result)
+                return result;
         }
     }
+    function isObject(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
     function createShortHash(element) {
         const hash = node_crypto.createHash("sha256")
             .update(JSON.stringify(element))
@@ -407,10 +434,8 @@
                 strategy,
                 format,
             });
-            if (!hasNestedElements && leafCount > 0) {
-                logger.error(`The XML file ${filePath} only has leaf elements. This file will not be disassembled.`);
+            if (shouldAbortForLeafOnly(leafCount, hasNestedElements, filePath))
                 return;
-            }
             yield writeNestedGroups(nestedGroups, strategy, {
                 disassembledPath,
                 rootElementName,
@@ -418,25 +443,42 @@
                 xmlDeclaration,
                 format,
             });
-            if (leafCount > 0) {
-                const finalLeafContent = strategy === "grouped-by-tag"
-                    ? orderXmlElementKeys(leafContent, keyOrder)
-                    : leafContent;
-                yield buildDisassembledFile({
-                    content: finalLeafContent,
+            yield writeLeafContentIfAny({
+                leafCount,
+                leafContent,
+                strategy,
+                keyOrder,
+                options: {
                     disassembledPath,
                     outputFileName: `${baseName}.${format}`,
                     rootElementName,
                     rootAttributes,
                     xmlDeclaration,
                     format,
-                });
-            }
+                },
+            });
             if (postPurge) {
                 yield promises.unlink(filePath);
             }
         });
     }
+    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
@@ -532,68 +574,83 @@
                     logger.warn(`Unsupported strategy "${strategy}", defaulting to "unique-id".`);
                     strategy = "unique-id";
                 }
-                const resolvedIgnorePath = node_path.resolve(ignorePath);
-                if (node_fs.existsSync(resolvedIgnorePath)) {
-                    const content = yield promises.readFile(resolvedIgnorePath);
-                    this.ign.add(content.toString());
-                }
+                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 });
+                }
                 yield buildDisassembledFilesUnified({
                     filePath,
                     disassembledPath: outputPath,