xml-disassembler 1.10.12 → 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) {
@@ -299,13 +323,16 @@ function findDirectFieldMatch(element, fieldNames) {
 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))
@@ -417,10 +444,8 @@ function buildDisassembledFilesUnified(_a) {
             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,
@@ -428,25 +453,42 @@ function buildDisassembledFilesUnified(_a) {
             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
@@ -542,68 +584,83 @@ class DisassembleXMLFileHandler {
                 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,