@ds-sfdc/sfparty 1.7.9 → 3.0.0

package/dist/party/combine.js

@@ -0,0 +1,723 @@
+import ci from 'ci-info';
+import clc from 'cli-color';
+import { XMLBuilder } from 'fast-xml-parser';
+import fs from 'fs';
+import path from 'path';
+import { sanitizeErrorPath } from '../lib/errorUtils.js';
+import * as fileUtils from '../lib/fileUtils.js';
+import { getGlobalProgressTracker } from '../lib/tuiProgressTracker.js';
+const processed = {
+    total: 0,
+    errors: 0,
+    current: 0,
+    type: undefined,
+};
+/**
+ * Updates file stats with the latest access and modification times
+ * @param fileStats Current file stats to update
+ * @param stats File system stats to compare against
+ * @returns Updated file stats with latest atime and mtime
+ */
+export function updateFileStats(fileStats, stats) {
+    try {
+        if (!stats)
+            return fileStats;
+        const updated = { ...fileStats };
+        if (updated.atime === undefined || stats.atime > updated.atime) {
+            updated.atime = stats.atime;
+        }
+        if (updated.mtime === undefined || stats.mtime > updated.mtime) {
+            updated.mtime = stats.mtime;
+        }
+        return updated;
+    }
+    catch (_error) {
+        return fileStats;
+    }
+}
+export class Combine {
+    #type = undefined;
+    #root = undefined;
+    #fileName = {
+        fullName: undefined,
+        shortName: undefined,
+        profileName: undefined,
+    };
+    #errorMessage = '';
+    #types = [];
+    #fileStats = {
+        atime: undefined,
+        mtime: undefined,
+    };
+    #json = {};
+    #delta = false;
+    #addedFiles = [];
+    #deletedFiles = [];
+    #mainDeleted = false;
+    ctx;
+    _metadataDefinition;
+    sourceDir;
+    targetDir;
+    _metaDir;
+    _sequence;
+    total;
+    addPkg;
+    desPkg;
+    constructor(config) {
+        this.ctx = config.ctx;
+        this.metadataDefinition = config.metadataDefinition;
+        this.sourceDir = config.sourceDir;
+        this.targetDir = config.targetDir;
+        this.metaDir = config.metaDir;
+        this.sequence = config.sequence;
+        this.total = config.total;
+        this.addPkg = config.addPkg;
+        this.desPkg = config.desPkg;
+        // Test helper to set error message for coverage testing (line 913)
+        // This is only used in tests to cover the unreachable code path
+        // SEC-005: Validate NODE_ENV environment variable
+        const nodeEnv = process.env.NODE_ENV;
+        const isValidNodeEnv = nodeEnv &&
+            typeof nodeEnv === 'string' &&
+            nodeEnv.length <= 20 &&
+            !/[\0\n\r<>"|\\]/.test(nodeEnv);
+        if (isValidNodeEnv && nodeEnv === 'test') {
+            // biome-ignore lint/suspicious/noExplicitAny: Test helper - TypeScript doesn't allow adding properties to 'this' without type assertion
+            ;
+            this.__testSetErrorMessage = (msg) => {
+                this.#errorMessage = msg;
+            };
+        }
+    }
+    get metadataDefinition() {
+        return this._metadataDefinition;
+    }
+    set metadataDefinition(definition) {
+        this._metadataDefinition = definition;
+        this.#type = definition.filetype;
+        this.#root = definition.root;
+    }
+    get metaDir() {
+        return this._metaDir;
+    }
+    set metaDir(metaDir) {
+        this._metaDir = metaDir;
+        this.#fileName.fullName = path.join(this.targetDir, metaDir.split(path.sep).pop() + `.${this.#type}-meta.xml`);
+        this.#fileName.shortName = metaDir.split(path.sep).pop();
+    }
+    get sequence() {
+        if (this.ctx.process && this.ctx.process.current > this._sequence) {
+            return this.ctx.process.current;
+        }
+        else {
+            return this._sequence;
+        }
+    }
+    set sequence(sequence) {
+        this._sequence = sequence;
+    }
+    async combine() {
+        const that = this;
+        const exists = await fileUtils.directoryExists({
+            workspaceRoot: that.ctx.basedir,
+            dirPath: that.sourceDir,
+            fs,
+        });
+        if (!exists) {
+            // SEC-008: Sanitize path in error message
+            throw new Error(`Path does not exist: ${sanitizeErrorPath(that.sourceDir)}`);
+        }
+        const types = ['directories', 'singleFiles', 'main'];
+        types.forEach((type) => {
+            const metaType = type;
+            if (that.metadataDefinition[metaType] !== undefined) {
+                const values = that.metadataDefinition[metaType];
+                if (Array.isArray(values)) {
+                    that.#types = that.#types.concat(values);
+                }
+            }
+        });
+        that.#types.sort((a, b) => {
+            if (a === '$')
+                return -1;
+            if (that.metadataDefinition.xmlFirst !== undefined) {
+                if (a === that.metadataDefinition.xmlFirst)
+                    return -1;
+            }
+            if (a < b)
+                return -1;
+            if (a > b)
+                return 1;
+            return 0;
+        });
+        that.#types.forEach((key) => {
+            that.#json[key] = undefined;
+        });
+        return processStart(that);
+        async function processStart(that) {
+            // set delta based on metadata definition if git delta enabled
+            that.#delta =
+                that.metadataDefinition.delta === true &&
+                    that.ctx.git?.delta === true;
+            if (that.#delta) {
+                const pathMatch = `/${that.metadataDefinition.directory}/${that.#fileName.shortName}/`;
+                // get a list of all the added files
+                that.#addedFiles = (that.ctx.metaTypes[that.metadataDefinition.alias]?.add
+                    .files || []).filter((i) => i.toLowerCase().includes(pathMatch.toLowerCase()));
+                // get a list of all the removed files
+                that.#deletedFiles = (that.ctx.metaTypes[that.metadataDefinition.alias]?.remove
+                    .files || []).filter((i) => i.toLowerCase().includes(pathMatch.toLowerCase()));
+                // check if main part file deleted
+                that.#mainDeleted = (that.ctx.metaTypes[that.metadataDefinition.alias]?.remove
+                    .files || []).some((i) => i.includes(pathMatch) &&
+                    i.toLowerCase().includes(`/main.${that.ctx.format}`));
+            }
+            const success = await processParts(that);
+            // Ensure we only match existing metadata type directory and item
+            if (success === true) {
+                if (!that.metadataDefinition.packageTypeIsDirectory &&
+                    that.ctx.git?.enabled) {
+                    if (!that.#delta || that.#addedFiles.length > 0) {
+                        that.addPkg.addMember(that.metadataDefinition.type, that.#fileName.shortName || '');
+                    }
+                    // only include the workflow node if main part file is delete
+                    if (that.#delta && that.#mainDeleted) {
+                        that.desPkg.addMember(that.metadataDefinition.type, that.#fileName.shortName || '');
+                    }
+                }
+                await saveXML(that);
+                return true;
+            }
+            else if (success &&
+                typeof success === 'object' &&
+                success &&
+                typeof success === 'object' &&
+                'name' in success &&
+                success.name === 'YAMLException') {
+                throw success;
+            }
+            else {
+                // Handle special cases where we should return true instead of 'deleted'
+                if (that.#delta &&
+                    that.#mainDeleted &&
+                    !that.metadataDefinition.packageTypeIsDirectory &&
+                    that.ctx.git?.enabled) {
+                    // Delta mode with mainDeleted: add to desPkg and return true
+                    that.desPkg.addMember(that.metadataDefinition.type, that.#fileName.shortName || '');
+                    return true;
+                }
+                if (that.metadataDefinition.packageTypeIsDirectory &&
+                    that.ctx.git?.enabled) {
+                    // packageTypeIsDirectory with git enabled: return true even if files don't exist
+                    return true;
+                }
+                // Suppress verbose output - log via TUI if active, otherwise via global.logger
+                const message = `Source not found for ${that.#fileName.shortName || 'unknown'} - removing XML file`;
+                // Try to use TUI progress tracker if available
+                const progressTracker = getGlobalProgressTracker();
+                if (progressTracker) {
+                    progressTracker.logWarning(message);
+                }
+                else {
+                    // Only log to console if console transport is not silenced (TUI not active)
+                    if (!that.ctx.consoleTransport ||
+                        !that.ctx.consoleTransport.silent) {
+                        that.ctx.logger.warn(message);
+                    }
+                }
+                if (!that.metadataDefinition.packageTypeIsDirectory &&
+                    that.ctx.git?.enabled) {
+                    that.desPkg.addMember(that.metadataDefinition.type, that.#fileName.shortName || '');
+                }
+                try {
+                    await deleteFile(that, that.#fileName.fullName || '');
+                }
+                catch (_error) { }
+                return 'deleted';
+            }
+        }
+        async function processParts(that) {
+            if (processed.type !== that.#root) {
+                processed.current = 0;
+                processed.type = that.#root;
+            }
+            processed.current++;
+            try {
+                for (const key of that.#types) {
+                    // Progress is handled by ProgressTracker
+                    if (that.metadataDefinition.main?.includes(key)) {
+                        const fileObj = {
+                            shortName: 'Main',
+                            fullName: path.join(that.sourceDir, that.metaDir, `main.${that.ctx.format}`),
+                        };
+                        const success = await processFile(that, key, fileObj, 'main');
+                        if (!success) {
+                            throw new Error('delete XML');
+                        }
+                        if (that.#json.$ === undefined) {
+                            that.#json.$ = {
+                                xmlns: 'https://soap.sforce.com/2006/04/metadata',
+                            };
+                        }
+                    }
+                    else if (that.metadataDefinition.singleFiles?.includes(key)) {
+                        await processSingleFile(that, key);
+                    }
+                    else if (that.metadataDefinition.directories?.includes(key)) {
+                        await processDirectory(that, key);
+                    }
+                    else {
+                        const message = `Unexpected metadata type: ${clc.redBright(key)}`;
+                        const progressTracker = getGlobalProgressTracker();
+                        if (progressTracker) {
+                            progressTracker.logWarning(message);
+                        }
+                        else {
+                            // Only log to console if console transport is not silenced (TUI not active)
+                            if (!that.ctx.consoleTransport ||
+                                !that.ctx.consoleTransport.silent) {
+                                that.ctx.logger.warn(message);
+                            }
+                        }
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'delete XML') {
+                    return false;
+                }
+                else if (error &&
+                    typeof error === 'object' &&
+                    error &&
+                    typeof error === 'object' &&
+                    'name' in error &&
+                    error.name === 'YAMLException') {
+                    throw error;
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+        async function processSingleFile(that, key) {
+            const fileObj = {
+                shortName: key,
+                fullName: path.join(that.sourceDir, that.metaDir, key + `.${that.ctx.format}`),
+            };
+            await processFile(that, key, fileObj);
+        }
+        async function processDirectory(that, key) {
+            // Process the directory sourceDir/metaDir/key
+            const currentDir = path.join(that.sourceDir, that.metaDir, key);
+            // ensure the directory exists
+            const dirExists = await fileUtils.directoryExists({
+                dirPath: currentDir,
+                fs,
+            });
+            if (dirExists) {
+                const fileList = await fileUtils.getFiles(currentDir, that.ctx.format);
+                fileList.sort(); // process files alphabetically
+                that.#json[key] = [];
+                // iterate over fileList
+                for (let index = 0; index < fileList.length; index++) {
+                    const file = fileList[index];
+                    if (!ci.isCI) {
+                        // Progress is handled by ProgressTracker
+                        // Suppress verbose output - main progress is handled by ProgressTracker
+                    }
+                    const fileObj = {
+                        shortName: file,
+                        fullName: path.join(that.sourceDir, that.metaDir, key, file),
+                    };
+                    await processFile(that, key, fileObj);
+                }
+            }
+            const filteredArray = (that.ctx.metaTypes[that.metadataDefinition.alias]?.remove
+                .files || []).filter((filePath) => filePath.startsWith(path.join(that.sourceDir, that.metaDir, key)));
+            for (const file of filteredArray) {
+                const fileObj = {
+                    shortName: path.basename(file),
+                    fullName: file,
+                };
+                await processFile(that, key, fileObj);
+            }
+            return true;
+        }
+        async function deleteFile(that, fileName) {
+            await fileUtils.deleteFile(fileName);
+            await fileUtils.deleteDirectory(path.join(that.sourceDir, that.metaDir));
+        }
+        async function processFile(that, key, fileObj, rootKey) {
+            if (fileObj === undefined ||
+                typeof fileObj !== 'object' ||
+                fileObj.shortName === undefined ||
+                fileObj.fullName === undefined) {
+                that.ctx.displayError(`${that.ctx.icons.warn || ''} Invalid file information passed ${clc.redBright(JSON.stringify(fileObj))}`, true);
+            }
+            if (that.#delta) {
+                if (!that.#addedFiles
+                    .concat(that.#deletedFiles)
+                    .includes(fileObj.fullName) &&
+                    !fileObj.fullName
+                        .toLowerCase()
+                        .includes(`/main.${that.ctx.format}`))
+                    return true;
+            }
+            const loginIpRanges = fileObj.shortName.toLowerCase() ===
+                'loginIpRanges'.toLocaleLowerCase();
+            let loginIpRangesSandboxFile;
+            let loginIpRangesSandbox = false;
+            let loginIpRangesStats;
+            let fileStats;
+            // Use stat() directly to combine existence and metadata check
+            // SEC-011: Validate symlinks before stat()
+            if (loginIpRanges) {
+                loginIpRangesSandboxFile = fileObj.fullName.replace(`.${that.ctx.format}`, `-sandbox.${that.ctx.format}`);
+                try {
+                    if (loginIpRangesSandboxFile) {
+                        // SEC-011: Validate symlink before stat()
+                        const linkStats = await fs.promises.lstat(loginIpRangesSandboxFile);
+                        if (linkStats.isSymbolicLink()) {
+                            await fileUtils.validateSymlink(loginIpRangesSandboxFile, that.ctx.basedir);
+                        }
+                        loginIpRangesStats = await fs.promises.stat(loginIpRangesSandboxFile);
+                        loginIpRangesSandbox = loginIpRangesStats.isFile();
+                    }
+                }
+                catch {
+                    loginIpRangesSandbox = false;
+                }
+            }
+            try {
+                // SEC-011: Validate symlink before stat()
+                const linkStats = await fs.promises.lstat(fileObj.fullName);
+                if (linkStats.isSymbolicLink()) {
+                    await fileUtils.validateSymlink(fileObj.fullName, that.ctx.basedir);
+                }
+                fileStats = await fs.promises.stat(fileObj.fullName);
+            }
+            catch {
+                // File doesn't exist
+            }
+            const fileExists = fileStats?.isFile() ?? false;
+            if ((!fileExists && !loginIpRanges) ||
+                (loginIpRanges && !fileExists && !loginIpRangesSandbox)) {
+                // File does not exist
+                // If file is main part file, then return false to indicate that the XML file should be deleted
+                if (fileObj.fullName ===
+                    path.join(that.sourceDir, that.metaDir, `main.${that.ctx.format}`)) {
+                    return false;
+                }
+                if (
+                // git enabled and (package directory OR package mapping)
+                that.ctx.git?.enabled &&
+                    (that.metadataDefinition.packageTypeIsDirectory ||
+                        (that.metadataDefinition.package !== undefined &&
+                            path.dirname(fileObj.fullName).split('/').pop() in
+                                that.metadataDefinition.package))) {
+                    if (
+                    // package mapping
+                    that.metadataDefinition.package !== undefined &&
+                        path.dirname(fileObj.fullName).split('/').pop() in
+                            that.metadataDefinition.package) {
+                        that.desPkg.addMember(that.metadataDefinition.package[path.dirname(fileObj.fullName).split('/').pop()], that.#fileName.shortName +
+                            '.' +
+                            fileObj.shortName.replace(`.${that.ctx.format}`, ''));
+                    }
+                    else if (
+                    // package directory
+                    that.metadataDefinition.packageTypeIsDirectory) {
+                        that.desPkg.addMember(that.metadataDefinition.type, fileObj.shortName.replace(`.${that.ctx.format}`, ''));
+                    }
+                }
+                return true;
+            }
+            // abort function if doing a delta deploy and file is not in git list
+            if (that.#delta &&
+                !(that.ctx.metaTypes[that.metadataDefinition.alias]?.add
+                    .files || []).includes(fileObj.fullName) &&
+                !loginIpRangesSandbox &&
+                fileObj.fullName !==
+                    path.join(that.sourceDir, that.metaDir, `main.${that.ctx.format}`)) {
+                return true;
+            }
+            let result;
+            try {
+                if (loginIpRanges) {
+                    let loginIpRangesResult;
+                    let loginIpRangesSandboxResult;
+                    if (fileExists)
+                        loginIpRangesResult = await fileUtils.readFile(that.ctx, fileObj.fullName);
+                    if (loginIpRangesSandbox && loginIpRangesSandboxFile)
+                        loginIpRangesSandboxResult = await fileUtils.readFile(that.ctx, loginIpRangesSandboxFile);
+                    if (fileExists && loginIpRangesSandbox) {
+                        result = mergeIpRanges(loginIpRangesResult, loginIpRangesSandboxResult);
+                    }
+                    else if (fileExists) {
+                        result = loginIpRangesResult;
+                    }
+                    else if (loginIpRangesSandbox) {
+                        result = loginIpRangesSandboxResult;
+                    }
+                }
+                else {
+                    result = await fileUtils.readFile(that.ctx, fileObj.fullName);
+                }
+            }
+            catch (error) {
+                // Suppress verbose output - errors are logged via ctx.logger
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                that.ctx.logger.error(`Error reading file: ${sanitizeErrorPath(fileObj.fullName)}: ${errorMessage}`);
+                throw error;
+            }
+            const resultTyped = result;
+            if (fileObj.fullName ===
+                path.join(that.sourceDir, that.metaDir, `main.${that.ctx.format}`) &&
+                that.#type === 'profile' &&
+                resultTyped.main &&
+                typeof resultTyped.main === 'object' &&
+                resultTyped.main !== null &&
+                'main' in resultTyped &&
+                'fullName' in resultTyped.main) {
+                that.#fileName.profileName = path.join(that.targetDir, resultTyped.main.fullName +
+                    `.${that.#type}-meta.xml`);
+            }
+            // if split by object we need to add object back to values
+            if (that.metadataDefinition.splitObjects !== undefined &&
+                that.metadataDefinition.splitObjects.includes(key)) {
+                result = hydrateObject(that, resultTyped, key, fileObj);
+            }
+            const sortedResult = sortAndArrange(that, resultTyped, key);
+            result = sortedResult;
+            const finalResult = result;
+            if (Array.isArray(that.#json[key])) {
+                try {
+                    if (Array.isArray(finalResult[key])) {
+                        ;
+                        finalResult[key].forEach((arrItem) => {
+                            ;
+                            that.#json[key].push(arrItem);
+                        });
+                    }
+                    else {
+                        ;
+                        that.#json[key].push(finalResult[key]);
+                    }
+                }
+                catch (error) {
+                    // Re-throw error to propagate up
+                    throw error;
+                }
+            }
+            else {
+                that.#json[key] =
+                    rootKey !== undefined
+                        ? finalResult[rootKey][key]
+                        : finalResult[key];
+            }
+            if (that.ctx.git?.enabled &&
+                fileObj.fullName !==
+                    path.join(that.sourceDir, that.metaDir, `main.${that.ctx.format}`)) {
+                if (that.metadataDefinition.package !== undefined &&
+                    path.dirname(fileObj.fullName).split('/').pop() in
+                        that.metadataDefinition.package) {
+                    that.addPkg.addMember(that.metadataDefinition.package[path.dirname(fileObj.fullName).split('/').pop()], that.#fileName.shortName +
+                        '.' +
+                        fileObj.shortName.replace(`.${that.ctx.format}`, ''), that.ctx.format);
+                }
+                else if (that.metadataDefinition.packageTypeIsDirectory) {
+                    that.addPkg.addMember(that.metadataDefinition.type, fileObj.shortName.replace(`.${that.ctx.format}`, ''));
+                }
+            }
+            // Function to merge arrays without duplicates
+            function mergeIpRanges(array1, array2) {
+                const combined = array1;
+                array2.loginIpRanges.forEach((item2) => {
+                    if (!combined.loginIpRanges.some((item1) => JSON.stringify(item1) === JSON.stringify(item2))) {
+                        combined.loginIpRanges.push(item2);
+                    }
+                });
+                return combined;
+            }
+            const fileInfoResult = await fileUtils.fileInfo(fileObj.fullName, fs, that.ctx.basedir);
+            updateFileStatsInternal(that, fileObj.fullName, fileInfoResult.stats);
+            return true;
+        }
+        function hydrateObject(that, json, key, _fileObj) {
+            const sortKey = that.metadataDefinition.sortKeys[key];
+            const object = json.object;
+            json[key].forEach((arrItem) => {
+                const typedItem = arrItem;
+                typedItem[sortKey] = `${object}.${typedItem[sortKey]}`.replace('.undefined', '');
+                // add object key if previously existed
+                if (that.metadataDefinition.keyOrder?.[key] !== undefined &&
+                    that.metadataDefinition.keyOrder[key].includes('order')) {
+                    typedItem.object = object;
+                }
+            });
+            // delete object key that we added to the part file
+            delete json.object;
+            return json;
+        }
+        function updateFileStatsInternal(that, _fileName, stats) {
+            that.#fileStats = updateFileStats(that.#fileStats, stats);
+        }
+        async function saveXML(that) {
+            // Configure builder to match xml2js output format
+            const builder = new XMLBuilder({
+                ignoreAttributes: false, // Keep attributes
+                attributesGroupName: '$', // Group attributes in $ object (matches xml2js format)
+                attributeNamePrefix: '', // No prefix needed when using attributesGroupName
+                format: true, // Pretty print
+                suppressEmptyNode: false, // Keep empty nodes
+            });
+            await fileUtils.createDirectory(that.targetDir);
+            Object.keys(that.#json).forEach((key) => {
+                if (that.#json[key] === undefined)
+                    delete that.#json[key];
+            });
+            // Build XML from JSON object - always wrap in root tag if root is defined
+            // This ensures split can find the expected root tag
+            let jsonToBuild;
+            if (that.#root) {
+                // If root key exists in JSON, use it
+                if (that.#json[that.#root] !== undefined &&
+                    that.#json[that.#root] !== null) {
+                    jsonToBuild = { [that.#root]: that.#json[that.#root] };
+                }
+                else {
+                    // Root key not found in JSON - this is an error condition
+                    // Log warning and create empty root to prevent split failures
+                    const warning = `Root key "${that.#root}" not found in JSON structure for ${that.#fileName.shortName}. Creating empty root tag.`;
+                    const progressTracker = getGlobalProgressTracker();
+                    if (progressTracker) {
+                        progressTracker.logWarning(warning);
+                    }
+                    else {
+                        if (!that.ctx.consoleTransport ||
+                            !that.ctx.consoleTransport.silent) {
+                            that.ctx.logger.warn(warning);
+                        }
+                    }
+                    // Create root wrapper with all JSON data (excluding root key if it exists as undefined)
+                    // This ensures split can find the expected root tag
+                    const jsonWithoutRoot = { ...that.#json };
+                    delete jsonWithoutRoot[that.#root]; // Remove undefined root key
+                    jsonToBuild = { [that.#root]: jsonWithoutRoot };
+                }
+            }
+            else {
+                // No root defined - use JSON as-is
+                jsonToBuild = that.#json;
+            }
+            // Add XML declaration manually since fast-xml-parser doesn't have xmlDeclaration option
+            const xml = `<?xml version="1.0" encoding="UTF-8"?>\n${builder.build(jsonToBuild)}`;
+            await fileUtils.writeFile(that.ctx, that.#fileName.fullName || '', xml, that.#fileStats.atime, that.#fileStats.mtime);
+            // display the finish message
+            finishMessage(that);
+        }
+        function finishMessage(that) {
+            // Progress is handled by ProgressTracker
+            // Errors are logged via ctx.logger
+            if (that.#errorMessage !== '') {
+                that.ctx.logger.error(`Error processing ${that.#fileName.shortName || 'unknown'}: ${that.#errorMessage}`);
+            }
+        }
+        // end of functions
+        // end of combine
+    }
+}
+/**
+ * Sorts a JSON array by a specified key
+ * @param json JSON value (should be an array)
+ * @param key Key to sort by
+ * @returns Sorted JSON array
+ */
+export function sortJSON(json, key) {
+    if (Array.isArray(json) && key !== undefined) {
+        json.sort((a, b) => {
+            if (a[key] < b[key])
+                return -1;
+            if (a[key] > b[key])
+                return 1;
+            return 0;
+        });
+    }
+    return json;
+}
+function sortAndArrange(that, json, key, _topLevel = true) {
+    // sort and order keys
+    const sortKey = that.metadataDefinition.sortKeys[key || ''];
+    json = arrangeKeys(that, json, key);
+    json = sortJSON(json, sortKey);
+    if (json && typeof json === 'object' && !Array.isArray(json)) {
+        Object.keys(json).forEach((subKey) => {
+            const jsonObj = json;
+            if (typeof jsonObj[subKey] === 'object' &&
+                jsonObj[subKey] !== null) {
+                if (!Array.isArray(jsonObj[subKey])) {
+                    if (Object.keys(jsonObj[subKey])
+                        .length > 1) {
+                        // call recursively on object
+                        jsonObj[subKey] = sortAndArrange(that, jsonObj[subKey], subKey, false);
+                    }
+                }
+                else {
+                    // iterate array for objects
+                    ;
+                    jsonObj[subKey].forEach((arrItem, index) => {
+                        if (typeof arrItem === 'object' &&
+                            arrItem !== null) {
+                            ;
+                            jsonObj[subKey][index] =
+                                sortAndArrange(that, arrItem, subKey, false);
+                        }
+                    });
+                }
+            }
+        });
+    }
+    return json;
+}
+/**
+ * Compares two keys for sorting based on xmlOrder
+ * @param a First key
+ * @param b Second key
+ * @param xmlOrder Array defining the order of keys
+ * @returns Comparison result: -1 if a < b, 1 if a > b, 0 if equal
+ */
+export function compareKeysForXmlOrder(a, b, xmlOrder) {
+    if (xmlOrder !== undefined) {
+        let aIndex = xmlOrder.indexOf(a);
+        let bIndex = xmlOrder.indexOf(b);
+        if (aIndex === -1)
+            aIndex = 99;
+        if (bIndex === -1)
+            bIndex = 99;
+        if (aIndex < bIndex && aIndex !== 99)
+            return -1;
+        if (aIndex > bIndex && bIndex !== 99)
+            return 1;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function arrangeKeys(that, json, key) {
+    if (!json || typeof json !== 'object' || Array.isArray(json)) {
+        return json;
+    }
+    const jsonObj = json;
+    const xmlOrderForKey = that.metadataDefinition.xmlOrder?.[key || ''];
+    const sortedKeys = Object.keys(jsonObj)
+        .sort((a, b) => compareKeysForXmlOrder(a, b, xmlOrderForKey))
+        .reduce((accumulator, keyName) => {
+        accumulator[keyName] = jsonObj[keyName];
+        return accumulator;
+    }, {});
+    return sortedKeys;
+}
+//# sourceMappingURL=combine.js.map