sf-git-merge-driver 1.0.0-dev-3.13990972267-1 → 1.0.0-dev-3.14022905562-1

package/lib/merger/JsonMerger.js

@@ -1,560 +1,179 @@
-import { castArray, isEqual, isNil, keyBy, unionWith } from 'lodash-es'; // , differenceWith
-import { KEY_FIELD_METADATA } from '../constant/metadataConstant.js';
+import { isEmpty, isEqual, keyBy, unionWith } from 'lodash-es';
+import { MetadataService } from '../service/MetadataService.js';
+import { NamespaceHandler } from '../service/NamespaceHandler.js';
+import { MergeScenario, getScenario } from '../types/mergeScenario.js';
+import { ensureArray, getUniqueSortedProps, isObject, } from '../utils/mergeUtils.js';
+import { addConflictMarkers } from './conflictMarker.js';
+import { mergeTextAttribute } from './textAttribute.js';
 export class JsonMerger {
-    /**
-     * Main entry point for merging JSON values
-     */
-    mergeObjects(ancestor, ours, theirs, parent //,
-    // attrib?: string
-    ) {
-        // Get all properties from three ways
-        const arrProperties = [];
-        let caseCode = 0;
-        if (ancestor && !isEqual(ancestor, {})) {
-            caseCode += 100;
-            arrProperties.push(...Object.keys(ancestor));
-        }
-        else {
-            ancestor = {};
-        }
-        if (ours && !isEqual(ours, {})) {
-            caseCode += 10;
-            arrProperties.push(...Object.keys(ours));
-        }
-        else {
-            ours = {};
-        }
-        if (theirs && !isEqual(theirs, {})) {
-            caseCode += 1;
-            arrProperties.push(...Object.keys(theirs));
-        }
-        else {
-            theirs = {};
-        }
-        const allProperties = new Set(arrProperties.sort());
-        // TODO filter the namespace here and reapply it in the end of the loop if necessary
-        // Process each property
-        const mergedContent = [];
-        for (const property of allProperties) {
-            // console.info('property: '+property+'\ntypeof: '+this.getAttributePrimarytype(
-            //   ancestor[property],
-            //   ours[property],
-            //   theirs[property]
-            // ))
-            switch (this.getAttributePrimarytype(ancestor[property], ours[property], theirs[property])) {
-                case 'object': {
-                    if (parent) {
-                        mergedContent.push(...this.mergeArrays(this.ensureArray(ancestor[property]), this.ensureArray(ours[property]), this.ensureArray(theirs[property]), this.ensureArray(parent), property, this.getKeyField(property)));
-                    }
-                    else {
-                        let propObject = {};
-                        switch (caseCode) {
-                            case 100:
-                                return [];
-                            case 11:
-                                if (isEqual(ours, theirs)) {
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, ours[property], {}, propObject));
-                                    mergedContent.push(propObject);
-                                }
-                                else {
-                                    mergedContent.push({ '#text': '\n<<<<<<< LOCAL' });
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, ours[property], {}, propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '||||||| BASE' });
-                                    mergedContent.push({ '#text': '\n' });
-                                    mergedContent.push({ '#text': '=======' });
-                                    propObject = {};
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, {}, theirs[property], propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '>>>>>>> REMOTE' });
-                                }
-                                break;
-                            case 101:
-                                if (isEqual(ancestor, theirs)) {
-                                    return [];
-                                }
-                                else {
-                                    mergedContent.push({ '#text': '\n<<<<<<< LOCAL' });
-                                    mergedContent.push({ '#text': '\n' });
-                                    mergedContent.push({ '#text': '||||||| BASE' });
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, ancestor[property], {}, propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '=======' });
-                                    propObject = {};
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, {}, theirs[property], propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '>>>>>>> REMOTE' });
-                                }
-                                break;
-                            case 110:
-                                if (isEqual(ancestor, ours)) {
-                                    return [];
-                                }
-                                else {
-                                    mergedContent.push({ '#text': '\n<<<<<<< LOCAL' });
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, ours[property], {}, propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '||||||| BASE' });
-                                    propObject = {};
-                                    propObject[property] = [];
-                                    propObject[property].push(...this.mergeObjects({}, {}, ancestor[property], propObject));
-                                    mergedContent.push(propObject);
-                                    mergedContent.push({ '#text': '=======' });
-                                    mergedContent.push({ '#text': '\n' });
-                                    mergedContent.push({ '#text': '>>>>>>> REMOTE' });
-                                }
-                                break;
-                            default:
-                                propObject[property] = [];
-                                propObject[property].push(...this.mergeObjects(ancestor[property], ours[property], theirs[property], propObject));
-                                mergedContent.push(propObject);
-                                break;
-                        }
-                    }
+    merge(ancestor, ours, theirs) {
+        const namespaceHandler = new NamespaceHandler();
+        const namespaces = namespaceHandler.processNamespaces(ancestor, ours, theirs);
+        const scenario = getScenario(ancestor, ours, theirs);
+        const acc = [];
+        const props = getUniqueSortedProps(ancestor, ours, theirs);
+        for (const key of props) {
+            switch (scenario) {
+                case MergeScenario.ANCESTOR_ONLY:
                     break;
-                }
-                default:
-                    if (property.startsWith('@_') && parent) {
-                        if (parent[':@']) {
-                            parent[':@'][property] = ancestor[property];
-                        }
-                        else {
-                            parent[':@'] = {};
-                            parent[':@'][property] = ancestor[property];
-                        }
-                    }
-                    else {
-                        mergedContent.push(...this.mergeTextAttribute(property, ancestor[property], ours[property], theirs[property]));
-                    }
+                case MergeScenario.OURS_AND_THEIRS:
+                    acc.push(handleOursAndTheirs(key, ours, theirs));
+                    break;
+                case MergeScenario.ANCESTOR_AND_THEIRS:
+                    acc.push(handleAncestorAndTheirs(key, ancestor, theirs));
                     break;
+                case MergeScenario.ANCESTOR_AND_OURS:
+                    acc.push(handleAncestorAndOurs(key, ancestor, ours));
+                    break;
+                default: {
+                    const obj = {
+                        [key]: mergeMetadata(ancestor[key], ours[key], theirs[key]),
+                    };
+                    acc.push([obj]);
+                    break;
+                }
             }
         }
-        return mergedContent;
-        // Handle root object (e.g., Profile)
-        // if (
-        //   typeof ours === 'object' &&
-        //   ours !== null &&
-        //   !Array.isArray(ours) &&
-        //   typeof theirs === 'object' &&
-        //   theirs !== null &&
-        //   !Array.isArray(theirs)
-        // ) {
-        //   // Get the base attribute (e.g., Profile)
-        //   const baseKey = Object.keys(ours)[0]
-        //   if (baseKey && Object.keys(theirs)[0] === baseKey) {
-        //     const result = { ...ours } as JsonObject
-        //     // Get the content of the base attribute
-        //     const ourContent = ours[baseKey] as JsonObject
-        //     const theirContent = theirs[baseKey] as JsonObject
-        //     const ancestorContent =
-        //       ancestor &&
-        //       typeof ancestor === 'object' &&
-        //       !Array.isArray(ancestor) &&
-        //       baseKey in ancestor
-        //         ? ((ancestor as JsonObject)[baseKey] as JsonObject)
-        //         : {}
-        //     // Get all properties from both contents
-        //     const allProperties = new Set([
-        //       ...Object.keys(ourContent),
-        //       ...Object.keys(theirContent),
-        //     ])
-        //     // Process each property
-        //     const mergedContent = { ...ourContent } as JsonObject
-        //     for (const property of allProperties) {
-        //       // Skip if property doesn't exist in their content
-        //       if (!(property in theirContent)) continue
-        //       // Use their version if property doesn't exist in our content
-        //       if (!(property in mergedContent)) {
-        //         mergedContent[property] = this.ensureArray(theirContent[property])
-        //         continue
-        //       }
-        //       // Ensure both values are arrays
-        //       const ourArray = this.ensureArray(mergedContent[property])
-        //       const theirArray = this.ensureArray(theirContent[property])
-        //       const ancestorArray =
-        //         property in ancestorContent
-        //           ? this.ensureArray(ancestorContent[property])
-        //           : []
-        //       // Get the key field for this property if available
-        //       const keyField = this.getKeyField(property)
-        //       // Merge the arrays
-        //       mergedContent[property] = this.mergeArrays(
-        //         ancestorArray,
-        //         ourArray,
-        //         theirArray,
-        //         keyField
-        //       )
-        //     }
-        //     result[baseKey] = mergedContent
-        //     return result
-        //   }
-        // }
-        // // Default to our version for other cases
-        // return ours
+        const result = acc.flat();
+        namespaceHandler.addNamespacesToResult(result, namespaces);
+        return result;
     }
-    mergeTextAttribute(attrib, ancestor, ours, theirs) {
-        const objAnc = {};
-        const objOurs = {};
-        const objTheirs = {};
-        let caseCode = 0;
-        if (!isNil(ancestor)) {
-            objAnc[attrib] = [{ '#text': ancestor }];
-            caseCode += 100;
-        }
-        if (!isNil(ours)) {
-            objOurs[attrib] = [{ '#text': ours }];
-            caseCode += 10;
+}
+const mergeMetadata = (ancestor, ours, theirs) => {
+    const acc = [];
+    const props = getUniqueSortedProps(ancestor, ours, theirs);
+    for (const key of props) {
+        let values = [];
+        if (isObject(ancestor[key], ours[key], theirs[key])) {
+            const [ancestorkey, ourkey, theirkey] = [
+                ancestor[key],
+                ours[key],
+                theirs[key],
+            ].map(ensureArray);
+            values = mergeArrays(ancestorkey, ourkey, theirkey, key);
         }
-        if (!isNil(theirs)) {
-            objTheirs[attrib] = [{ '#text': theirs }];
-            caseCode += 1;
+        else {
+            values = mergeTextAttribute(ancestor[key], ours[key], theirs[key], key);
         }
-        const finalArray = [];
-        switch (caseCode) {
-            case 1:
-                finalArray.push(objTheirs);
+        acc.push(values);
+    }
+    return acc.flat();
+};
+const handleOursAndTheirs = (key, ours, theirs) => {
+    const obj = {};
+    obj[key] = mergeMetadata({}, ours[key], {});
+    const acc = [];
+    if (!isEqual(ours, theirs)) {
+        const theirsProp = {
+            [key]: mergeMetadata({}, {}, theirs[key]),
+        };
+        addConflictMarkers(acc, obj, {}, theirsProp);
+    }
+    else {
+        acc.push(obj);
+    }
+    return acc;
+};
+const handleAncestorAndTheirs = (key, ancestor, theirs) => {
+    const acc = [];
+    if (!isEqual(ancestor, theirs)) {
+        const ancestorProp = {
+            [key]: mergeMetadata({}, {}, ancestor[key]),
+        };
+        const theirsProp = {
+            [key]: mergeMetadata({}, {}, theirs[key]),
+        };
+        addConflictMarkers(acc, {}, ancestorProp, theirsProp);
+    }
+    return acc;
+};
+const handleAncestorAndOurs = (key, ancestor, ours) => {
+    const acc = [];
+    if (!isEqual(ancestor, ours)) {
+        const oursProp = {
+            [key]: mergeMetadata({}, {}, ours[key]),
+        };
+        const ancestorProp = {
+            [key]: mergeMetadata({}, {}, ancestor[key]),
+        };
+        addConflictMarkers(acc, oursProp, ancestorProp, {});
+    }
+    return acc;
+};
+const mergeArrays = (ancestor, ours, theirs, attribute) => {
+    const keyField = MetadataService.getKeyFieldExtractor(attribute);
+    if (!keyField) {
+        const obj = {};
+        obj[attribute] = unionWith(ours, theirs, isEqual);
+        return [obj];
+    }
+    const [keyedAnc, keyedOurs, keyedTheirs] = [ancestor, ours, theirs].map(arr => keyBy(arr, keyField));
+    return mergeByKeyField(keyedAnc, keyedOurs, keyedTheirs, attribute);
+};
+const mergeByKeyField = (ancestor, ours, theirs, attribute) => {
+    const acc = [];
+    const props = getUniqueSortedProps(ancestor, ours, theirs);
+    for (const key of props) {
+        const scenario = getScenario(ancestor[key], ours[key], theirs[key]);
+        const obj = {};
+        switch (scenario) {
+            case MergeScenario.THEIRS_ONLY:
+                obj[attribute] = mergeMetadata({}, {}, theirs[key]);
                 break;
-            case 10:
-                finalArray.push(objOurs);
+            case MergeScenario.OURS_ONLY:
+                obj[attribute] = mergeMetadata({}, ours[key], {});
                 break;
-            case 11:
-                if (ours === theirs) {
-                    finalArray.push(objOurs);
+            case MergeScenario.ANCESTOR_ONLY:
+                break;
+            case MergeScenario.OURS_AND_THEIRS:
+                if (isEqual(ours, theirs)) {
+                    obj[attribute] = mergeMetadata({}, {}, theirs[key]);
                 }
                 else {
-                    finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                    finalArray.push(objOurs);
-                    finalArray.push({ '#text': '||||||| BASE' });
-                    finalArray.push({ '#text': '\n' });
-                    finalArray.push({ '#text': '=======' });
-                    finalArray.push(objTheirs);
-                    finalArray.push({ '#text': '>>>>>>> REMOTE' });
+                    obj[attribute] = mergeMetadata({}, ours[key], theirs[key]);
                 }
                 break;
-            case 101:
-                if (ancestor !== theirs) {
-                    finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                    finalArray.push({ '#text': '\n' });
-                    finalArray.push({ '#text': '||||||| BASE' });
-                    finalArray.push(objAnc);
-                    finalArray.push({ '#text': '=======' });
-                    finalArray.push(objTheirs);
-                    finalArray.push({ '#text': '>>>>>>> REMOTE' });
+            case MergeScenario.ANCESTOR_AND_THEIRS:
+                if (!isEqual(ancestor, theirs)) {
+                    const ancestorProp = {
+                        [attribute]: mergeMetadata({}, ancestor[key], {}),
+                    };
+                    const theirsProp = {
+                        [attribute]: mergeMetadata({}, {}, theirs[key]),
+                    };
+                    addConflictMarkers(acc, {}, ancestorProp, theirsProp);
                 }
                 break;
-            case 110:
-                if (ancestor !== ours) {
-                    finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                    finalArray.push(objOurs);
-                    finalArray.push({ '#text': '||||||| BASE' });
-                    finalArray.push(objAnc);
-                    finalArray.push({ '#text': '=======' });
-                    finalArray.push({ '#text': '\n' });
-                    finalArray.push({ '#text': '>>>>>>> REMOTE' });
+            case MergeScenario.ANCESTOR_AND_OURS:
+                if (!isEqual(ancestor, ours)) {
+                    const oursProp = {
+                        [attribute]: mergeMetadata({}, ours[key], {}),
+                    };
+                    const ancestorProp = {
+                        [attribute]: mergeMetadata({}, ancestor[key], {}),
+                    };
+                    addConflictMarkers(acc, oursProp, ancestorProp, {});
                 }
                 break;
-            case 111:
-                if (ours === theirs) {
-                    finalArray.push(objOurs);
+            case MergeScenario.ALL:
+                if (isEqual(ours, theirs)) {
+                    obj[attribute] = mergeMetadata({}, {}, theirs[key]);
                 }
-                else if (ancestor === ours) {
-                    finalArray.push(objTheirs);
+                else if (isEqual(ancestor[key], ours[key])) {
+                    obj[attribute] = mergeMetadata({}, {}, theirs[key]);
                 }
-                else if (ancestor === theirs) {
-                    finalArray.push(objOurs);
+                else if (isEqual(ancestor, theirs)) {
+                    obj[attribute] = mergeMetadata({}, ours[key], {});
                 }
                 else {
-                    finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                    finalArray.push(objOurs);
-                    finalArray.push({ '#text': '||||||| BASE' });
-                    finalArray.push(objAnc);
-                    finalArray.push({ '#text': '=======' });
-                    finalArray.push(objTheirs);
-                    finalArray.push({ '#text': '>>>>>>> REMOTE' });
+                    obj[attribute] = mergeMetadata(ancestor[key], ours[key], theirs[key]);
                 }
                 break;
-            default:
         }
-        return finalArray;
-    }
-    /**
-     * Gets the typeof of the attribute
-     */
-    getAttributePrimarytype(ancestor, ours, theirs) {
-        return typeof [ancestor, theirs, ours].find(ele => !isNil(ele));
-    }
-    /**
-     * Ensures a value is an array
-     */
-    ensureArray(value) {
-        return isNil(value) ? [] : castArray(value);
-    }
-    /**
-     * Gets the key field for a property from KEY_FIELD_METADATA
-     */
-    getKeyField(property) {
-        return property in KEY_FIELD_METADATA
-            ? KEY_FIELD_METADATA[property]
-            : undefined;
-    }
-    /**
-     * Merges arrays using the specified key field if available
-     */
-    mergeArrays(ancestor, ours, theirs, parent, attribute, keyField) {
-        const propObject = {};
-        // If no key field, use unionWith to merge arrays without duplicates
-        if (!keyField) {
-            propObject[attribute] = unionWith([...ours], theirs, isEqual);
-            return [propObject];
-        }
-        // Special case for array position
-        if (keyField === '<array>') {
-            propObject[attribute] = this.mergeByPosition(ancestor, ours, theirs);
-            return [propObject];
-        }
-        // Merge using key field
-        return this.mergeByKeyField(ancestor, ours, theirs, keyField, attribute, parent);
-    }
-    /**
-     * Merges arrays by position
-     */
-    mergeByPosition(ancestor, ours, theirs) {
-        const result = [...ours];
-        // Merge items at the same positions
-        for (let i = 0; i < Math.min(ours.length, theirs.length); i++) {
-            const ancestorItem = i < ancestor.length ? ancestor[i] : undefined;
-            // If they changed it from ancestor but we didn't, use their version
-            if (!isEqual(theirs[i], ancestorItem) && isEqual(ours[i], ancestorItem)) {
-                result[i] = theirs[i];
-            }
-        }
-        // Add items that only exist in their version
-        if (theirs.length > ours.length) {
-            for (let i = ours.length; i < theirs.length; i++) {
-                result.push(theirs[i]);
-            }
-        }
-        return result;
-    }
-    /**
-     * Merges arrays using a key field
-     */
-    mergeByKeyField(ancestor, ours, theirs, keyField, attribute, parent) {
-        const finalArray = [];
-        let caseCode = 0;
-        if (ancestor.length !== 0) {
-            caseCode += 100;
-        }
-        if (ours.length !== 0) {
-            caseCode += 10;
-        }
-        if (theirs.length !== 0) {
-            caseCode += 1;
+        if (!isEmpty(obj)) {
+            acc.push(obj);
         }
-        // console.info(
-        //   'attribute: ' +
-        //     attribute +
-        //     '\nkeyField: ' +
-        //     keyField +
-        //     '\ncaseCode: ' +
-        //     caseCode
-        // )
-        // console.dir(ours, {depth: null})
-        const keyedAnc = keyBy(ancestor, keyField);
-        const keyedOurs = keyBy(ours, keyField);
-        const keyedTheirs = keyBy(theirs, keyField);
-        const allKeys = new Set([
-            ...Object.keys(keyedAnc),
-            ...Object.keys(keyedOurs),
-            ...Object.keys(keyedTheirs),
-        ].sort());
-        for (const key of allKeys) {
-            caseCode = 0;
-            if (keyedAnc[key]) {
-                caseCode += 100;
-            }
-            if (keyedOurs[key]) {
-                caseCode += 10;
-            }
-            if (keyedTheirs[key]) {
-                caseCode += 1;
-            }
-            // console.log('caseCode: ' + caseCode);
-            let propObject = {};
-            switch (caseCode) {
-                case 1:
-                    propObject[attribute] = [
-                        ...this.mergeObjects({}, {}, keyedTheirs[key], parent),
-                    ];
-                    finalArray.push(propObject);
-                    break;
-                case 10:
-                    propObject[attribute] = [
-                        ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                    ];
-                    finalArray.push(propObject);
-                    break;
-                case 100:
-                    break;
-                case 11:
-                    if (isEqual(ours, theirs)) {
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                    }
-                    else {
-                        // finalArray.push({ '#text': '<<<<<<< LOCAL' })
-                        // propObject[attribute] = [
-                        //   ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                        // ]
-                        // finalArray.push(propObject)
-                        // finalArray.push({ '#text': '||||||| BASE' })
-                        // finalArray.push({ '#text': '\n' })
-                        // finalArray.push({ '#text': '=======' })
-                        // propObject[attribute] = [
-                        //   ...this.mergeObjects({}, {}, keyedTheirs[key], parent),
-                        // ]
-                        // finalArray.push(propObject)
-                        // finalArray.push({ '#text': '>>>>>>> REMOTE' })
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, keyedOurs[key], keyedTheirs[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                    }
-                    break;
-                case 101:
-                    if (!isEqual(ancestor, theirs)) {
-                        finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                        finalArray.push({ '#text': '\n' });
-                        finalArray.push({ '#text': '||||||| BASE' });
-                        propObject = {};
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedAnc[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                        finalArray.push({ '#text': '=======' });
-                        propObject = {};
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedTheirs[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                        finalArray.push({ '#text': '>>>>>>> REMOTE' });
-                        // propObject[attribute] = [
-                        //   ...this.mergeObjects(keyedAnc[key], {}, keyedTheirs[key], parent),
-                        // ]
-                        // finalArray.push(propObject)
-                    }
-                    break;
-                case 110:
-                    if (!isEqual(ancestor, ours)) {
-                        finalArray.push({ '#text': '\n<<<<<<< LOCAL' });
-                        propObject = {};
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                        finalArray.push({ '#text': '||||||| BASE' });
-                        propObject = {};
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedAnc[key], parent),
-                        ];
-                        finalArray.push(propObject);
-                        finalArray.push({ '#text': '=======' });
-                        finalArray.push({ '#text': '\n' });
-                        finalArray.push({ '#text': '>>>>>>> REMOTE' });
-                        // propObject[attribute] = [
-                        //   ...this.mergeObjects(keyedAnc[key], keyedOurs[key], {}, parent),
-                        // ]
-                        // finalArray.push(propObject)
-                    }
-                    break;
-                case 111:
-                    if (isEqual(ours, theirs)) {
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                        ];
-                    }
-                    else if (isEqual(ancestor, ours)) {
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedTheirs[key], parent),
-                        ];
-                    }
-                    else if (isEqual(ancestor, theirs)) {
-                        propObject[attribute] = [
-                            ...this.mergeObjects({}, {}, keyedOurs[key], parent),
-                        ];
-                    }
-                    else {
-                        // finalArray.push({ '#text': '<<<<<<< LOCAL' })
-                        // finalArray.push(...this.mergeObjects({}, {}, keyedOurs[key], parent))
-                        // finalArray.push({ '#text': '||||||| BASE' })
-                        // finalArray.push(...this.mergeObjects({}, {}, keyedAnc[key], parent))
-                        // finalArray.push({ '#text': '=======' })
-                        // finalArray.push(...this.mergeObjects({}, {}, keyedTheirs[key], parent))
-                        // finalArray.push({ '#text': '>>>>>>> REMOTE' })
-                        propObject[attribute] = [
-                            ...this.mergeObjects(keyedAnc[key], keyedOurs[key], keyedTheirs[key], parent),
-                        ];
-                    }
-                    finalArray.push(propObject);
-                    break;
-                default:
-            }
-        }
-        return finalArray;
-        // original by scolladon
-        // const result = [...ours]
-        // const processed = new Set<string>()
-        // // Create maps for efficient lookups
-        // const ourMap = new Map<string, JsonValue>()
-        // const theirMap = new Map<string, JsonValue>()
-        // const ancestorMap = new Map<string, JsonValue>()
-        // // Populate maps
-        // for (const item of ours) {
-        //   const key = this.getItemKey(item, keyField)
-        //   if (key) ourMap.set(key, item)
-        // }
-        // for (const item of theirs) {
-        //   const key = this.getItemKey(item, keyField)
-        //   if (key) theirMap.set(key, item)
-        // }
-        // for (const item of ancestor) {
-        //   const key = this.getItemKey(item, keyField)
-        //   if (key) ancestorMap.set(key, item)
-        // }
-        // // Process items in our version
-        // for (let i = 0; i < result.length; i++) {
-        //   const key = this.getItemKey(result[i], keyField)
-        //   if (!key) continue
-        //   processed.add(key)
-        //   // If item exists in both versions
-        //   if (theirMap.has(key)) {
-        //     const theirItem = theirMap.get(key)!
-        //     const ancestorItem = ancestorMap.get(key)
-        //     // If they changed it from ancestor but we didn't, use their version
-        //     if (
-        //       !isEqual(theirItem, ancestorItem) &&
-        //       isEqual(result[i], ancestorItem)
-        //     ) {
-        //       result[i] = theirItem
-        //     }
-        //   }
-        // }
-        // // Add items that only exist in their version
-        // const uniqueTheirItems = differenceWith(
-        //   Array.from(theirMap.values()),
-        //   result,
-        //   (a, b) => this.getItemKey(a, keyField) === this.getItemKey(b, keyField)
-        // )
-        // result.push(...uniqueTheirItems)
-        // return result
     }
-}
+    return acc;
+};
 //# sourceMappingURL=JsonMerger.js.map