@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/merge.spec.native.js

@@ -0,0 +1,937 @@
+"use strict";
+
+var import_vitest = require("vitest");
+var import_merge = require("./merge.native.js");
+(0, import_vitest.describe)("mergeChildTable", function () {
+  var createChildRow = function createChildRow2(name, idx, value) {
+    return {
+      name,
+      doctype: "Item",
+      idx,
+      parent: "parent",
+      parentfield: "items",
+      parenttype: "Invoice",
+      value: value !== null && value !== void 0 ? value : `value-${idx}`
+    };
+  };
+  (0, import_vitest.describe)("2-way merge", function () {
+    (0, import_vitest.it)("should merge child table arrays by name", function () {
+      var baseArray = [createChildRow("row-1", 1, "old"), createChildRow("row-2", 2)];
+      var incomingArray = [createChildRow("row-1", 1, "new"), createChildRow("row-3", 3)];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
+      (0, import_vitest.expect)(result).toHaveLength(3);
+      (0, import_vitest.expect)(result[0]).toMatchObject({
+        name: "row-1",
+        value: "new"
+      });
+      (0, import_vitest.expect)(result[1]).toMatchObject({
+        name: "row-2",
+        value: "value-2"
+      });
+      (0, import_vitest.expect)(result[2]).toMatchObject({
+        name: "row-3",
+        value: "value-3"
+      });
+    });
+    (0, import_vitest.it)("should handle empty base array", function () {
+      var baseArray = [];
+      var incomingArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
+      (0, import_vitest.expect)(result).toEqual(incomingArray);
+    });
+    (0, import_vitest.it)("should handle empty incoming array", function () {
+      var baseArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
+      var incomingArray = [];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
+      (0, import_vitest.expect)(result).toEqual(baseArray);
+    });
+    (0, import_vitest.it)("should sort child table rows by idx", function () {
+      var baseArray = [createChildRow("row-3", 3), createChildRow("row-1", 1)];
+      var incomingArray = [createChildRow("row-2", 2)];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
+      (0, import_vitest.expect)(result[0]).toMatchObject({
+        name: "row-1",
+        idx: 1
+      });
+      (0, import_vitest.expect)(result[1]).toMatchObject({
+        name: "row-2",
+        idx: 2
+      });
+      (0, import_vitest.expect)(result[2]).toMatchObject({
+        name: "row-3",
+        idx: 3
+      });
+    });
+  });
+  (0, import_vitest.describe)("3-way merge", function () {
+    (0, import_vitest.it)("should handle concurrent updates to different rows", function () {
+      var baseArray = [createChildRow("row-1", 1, "original-1"), createChildRow("row-2", 2, "original-2")];
+      var incomingArray = [createChildRow("row-1", 1, "client-1"), createChildRow("row-2", 2, "original-2")];
+      var serverArray = [createChildRow("row-1", 1, "original-1"), createChildRow("row-2", 2, "server-2")];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toHaveLength(2);
+      (0, import_vitest.expect)(result[0]).toMatchObject({
+        name: "row-1",
+        value: "client-1"
+      });
+      (0, import_vitest.expect)(result[1]).toMatchObject({
+        name: "row-2",
+        value: "server-2"
+      });
+    });
+    (0, import_vitest.it)("should handle additions from both client and server", function () {
+      var baseArray = [createChildRow("row-1", 1)];
+      var incomingArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
+      var serverArray = [createChildRow("row-1", 1), createChildRow("row-3", 3)];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toHaveLength(3);
+      (0, import_vitest.expect)(result.map(function (r) {
+        return r.name;
+      })).toContain("row-1");
+      (0, import_vitest.expect)(result.map(function (r) {
+        return r.name;
+      })).toContain("row-2");
+      (0, import_vitest.expect)(result.map(function (r) {
+        return r.name;
+      })).toContain("row-3");
+    });
+    (0, import_vitest.it)("should handle deletions", function () {
+      var baseArray = [createChildRow("row-1", 1), createChildRow("row-2", 2), createChildRow("row-3", 3)];
+      var incomingArray = [createChildRow("row-1", 1), createChildRow("row-3", 3)];
+      var serverArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toHaveLength(1);
+      (0, import_vitest.expect)(result[0]).toMatchObject({
+        name: "row-1"
+      });
+    });
+    (0, import_vitest.it)("should prefer server values on conflicts", function () {
+      var baseArray = [createChildRow("row-1", 1, "original")];
+      var incomingArray = [createChildRow("row-1", 1, "client-update")];
+      var serverArray = [createChildRow("row-1", 1, "server-update")];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toHaveLength(1);
+      (0, import_vitest.expect)(result[0]).toMatchObject({
+        name: "row-1",
+        value: "server-update"
+      });
+    });
+  });
+  (0, import_vitest.describe)("non-child-table arrays", function () {
+    (0, import_vitest.it)("should return incoming array for non-child-table 2-way merge", function () {
+      var baseArray = [1, 2, 3];
+      var incomingArray = [4, 5, 6];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
+      (0, import_vitest.expect)(result).toEqual(incomingArray);
+    });
+    (0, import_vitest.it)("should return server array for non-child-table 3-way merge", function () {
+      var baseArray = [1, 2, 3];
+      var incomingArray = [4, 5, 6];
+      var serverArray = [7, 8, 9];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toEqual(serverArray);
+    });
+    (0, import_vitest.it)("should handle mixed evidence correctly", function () {
+      var baseArray = [];
+      var incomingArray = [createChildRow("row-1", 1)];
+      var serverArray = [{
+        some: "object"
+      }];
+      var result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
+      (0, import_vitest.expect)(result).toEqual(serverArray);
+    });
+  });
+});
+(0, import_vitest.describe)("mergeFieldValue", function () {
+  (0, import_vitest.it)("should handle null and undefined values", function () {
+    var base = "value";
+    (0, import_vitest.expect)((0, import_merge.mergeFieldValue)(base, null)).toBe(null);
+    (0, import_vitest.expect)((0, import_merge.mergeFieldValue)(base, void 0)).toBe(void 0);
+  });
+  (0, import_vitest.it)("should merge objects", function () {
+    var base = {
+      d: 3
+    };
+    var incoming = {
+      e: 4
+    };
+    var result = (0, import_merge.mergeFieldValue)(base, incoming);
+    (0, import_vitest.expect)(result).toEqual({
+      d: 3,
+      e: 4
+    });
+  });
+  (0, import_vitest.it)("should detect and merge child tables in arrays", function () {
+    var base = [{
+      name: "row-1",
+      doctype: "Item",
+      idx: 1,
+      parent: "p",
+      parentfield: "f",
+      parenttype: "t",
+      value: "old"
+    }];
+    var incoming = [{
+      name: "row-1",
+      doctype: "Item",
+      idx: 1,
+      parent: "p",
+      parentfield: "f",
+      parenttype: "t",
+      value: "new"
+    }];
+    var result = (0, import_merge.mergeFieldValue)(base, incoming, {
+      isChildTable: true
+    });
+    (0, import_vitest.expect)(Array.isArray(result)).toBe(true);
+    (0, import_vitest.expect)(result[0].value).toBe("new");
+  });
+  (0, import_vitest.it)("should return incoming value for primitives", function () {
+    (0, import_vitest.expect)((0, import_merge.mergeFieldValue)("old", "new")).toBe("new");
+    (0, import_vitest.expect)((0, import_merge.mergeFieldValue)(1, 2)).toBe(2);
+    (0, import_vitest.expect)((0, import_merge.mergeFieldValue)(true, false)).toBe(false);
+  });
+  (0, import_vitest.it)("should return incoming array for non-child-table arrays", function () {
+    var base = [1, 2, 3];
+    var incoming = [4, 5, 6];
+    var result = (0, import_merge.mergeFieldValue)(base, incoming);
+    (0, import_vitest.expect)(result).toEqual([4, 5, 6]);
+  });
+});
+(0, import_vitest.describe)("merge (3-way merge)", function () {
+  (0, import_vitest.it)("should detect and merge non-conflicting changes", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "original",
+      field2: "original"
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "client-update",
+      field2: "original"
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "original",
+      field2: "server-update"
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged).toEqual({
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "client-update",
+      field2: "server-update"
+    });
+    (0, import_vitest.expect)(conflicts).toEqual([]);
+  });
+  (0, import_vitest.it)("should detect conflicts when both modify same field", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "original"
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "client-update"
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "server-update"
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged.field1).toBe("server-update");
+    (0, import_vitest.expect)(conflicts).toContain("field1");
+  });
+  (0, import_vitest.it)("should handle field additions", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1"
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      clientField: "client"
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      serverField: "server"
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged).toEqual({
+      doctype: "TestDoc",
+      name: "doc-1",
+      clientField: "client",
+      serverField: "server"
+    });
+    (0, import_vitest.expect)(conflicts).toEqual([]);
+  });
+  (0, import_vitest.it)("should handle field deletions", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "value1",
+      field2: "value2"
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field2: "value2"
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      field1: "value1"
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged).toEqual({
+      doctype: "TestDoc",
+      name: "doc-1"
+    });
+    (0, import_vitest.expect)(conflicts).toEqual([]);
+  });
+  (0, import_vitest.it)("should intelligently merge child table conflicts", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      items: [{
+        name: "row-1",
+        doctype: "Item",
+        idx: 1,
+        parent: "doc-1",
+        parentfield: "items",
+        parenttype: "Doc",
+        value: "original"
+      }]
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      items: [{
+        name: "row-1",
+        doctype: "Item",
+        idx: 1,
+        parent: "doc-1",
+        parentfield: "items",
+        parenttype: "Doc",
+        value: "client"
+      }, {
+        name: "row-2",
+        doctype: "Item",
+        idx: 2,
+        parent: "doc-1",
+        parentfield: "items",
+        parenttype: "Doc",
+        value: "new-client"
+      }]
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      items: [{
+        name: "row-1",
+        doctype: "Item",
+        idx: 1,
+        parent: "doc-1",
+        parentfield: "items",
+        parenttype: "Doc",
+        value: "server"
+      }, {
+        name: "row-3",
+        doctype: "Item",
+        idx: 3,
+        parent: "doc-1",
+        parentfield: "items",
+        parenttype: "Doc",
+        value: "new-server"
+      }]
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged.items).toHaveLength(3);
+    (0, import_vitest.expect)(conflicts).toEqual([]);
+  });
+  (0, import_vitest.it)("should handle array conflicts that are not child tables", function () {
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "b"]
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "c"]
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "d"]
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server);
+    (0, import_vitest.expect)(merged.tags).toEqual(["a", "d"]);
+    (0, import_vitest.expect)(conflicts).toContain("tags");
+  });
+});
+(0, import_vitest.describe)("deepEqual", function () {
+  (0, import_vitest.it)("should compare primitive values correctly", function () {
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(1, 1)).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(1, 2)).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)("test", "test")).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)("test", "other")).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(true, true)).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(true, false)).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(null, null)).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(void 0, void 0)).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(null, void 0)).toBe(false);
+  });
+  (0, import_vitest.it)("should compare arrays correctly", function () {
+    (0, import_vitest.expect)((0, import_merge.deepEqual)([1, 2, 3], [1, 2, 3])).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)([1, 2, 3], [1, 2, 4])).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)([1, 2, 3], [1, 2])).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)([], [])).toBe(true);
+  });
+  (0, import_vitest.it)("should compare objects correctly", function () {
+    (0, import_vitest.expect)((0, import_merge.deepEqual)({
+      a: 1,
+      b: 2
+    }, {
+      a: 1,
+      b: 2
+    })).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)({
+      a: 1,
+      b: 2
+    }, {
+      a: 1,
+      b: 3
+    })).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)({
+      a: 1
+    }, {
+      a: 1,
+      b: 2
+    })).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)({}, {})).toBe(true);
+  });
+  (0, import_vitest.it)("should compare nested structures", function () {
+    var obj1 = {
+      a: 1,
+      b: [2, 3],
+      c: {
+        d: 4,
+        e: [5, 6]
+      }
+    };
+    var obj2 = {
+      a: 1,
+      b: [2, 3],
+      c: {
+        d: 4,
+        e: [5, 6]
+      }
+    };
+    var obj3 = {
+      a: 1,
+      b: [2, 3],
+      c: {
+        d: 4,
+        e: [5, 7]
+      }
+    };
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(obj1, obj2)).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.deepEqual)(obj1, obj3)).toBe(false);
+  });
+});
+(0, import_vitest.describe)("isObject", function () {
+  (0, import_vitest.it)("should identify objects correctly", function () {
+    (0, import_vitest.expect)((0, import_merge.isObject)({})).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.isObject)({
+      a: 1
+    })).toBe(true);
+    (0, import_vitest.expect)((0, import_merge.isObject)(null)).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.isObject)(void 0)).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.isObject)([])).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.isObject)("string")).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.isObject)(123)).toBe(false);
+    (0, import_vitest.expect)((0, import_merge.isObject)(true)).toBe(false);
+  });
+});
+(0, import_vitest.describe)("applyMergeStrategy", function () {
+  (0, import_vitest.describe)("Sum", function () {
+    (0, import_vitest.it)("should sum client and server deltas from base", function () {
+      var result = (0, import_merge.applyMergeStrategy)("amount", 10, 15, 12, import_merge.FieldMergeStrategy.Sum);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 17,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle zero base", function () {
+      var result = (0, import_merge.applyMergeStrategy)("amount", 0, 5, 3, import_merge.FieldMergeStrategy.Sum);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 8,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle null base as zero", function () {
+      var result = (0, import_merge.applyMergeStrategy)("amount", null, 5, 3, import_merge.FieldMergeStrategy.Sum);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 8,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should throw TypeError for non-numeric values", function () {
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("amount", "ten", 15, 12, import_merge.FieldMergeStrategy.Sum);
+      }).toThrow(TypeError);
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("amount", 10, "fifteen", 12, import_merge.FieldMergeStrategy.Sum);
+      }).toThrow(TypeError);
+    });
+  });
+  (0, import_vitest.describe)("Max", function () {
+    (0, import_vitest.it)("should return the largest of base, client, and server", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", 5, 10, 7, import_merge.FieldMergeStrategy.Max);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 10,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle server being the max", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", 5, 7, 10, import_merge.FieldMergeStrategy.Max);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 10,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle null values as zero", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", null, 3, null, import_merge.FieldMergeStrategy.Max);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 3,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should throw TypeError for non-numeric values", function () {
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("priority", "low", "high", "medium", import_merge.FieldMergeStrategy.Max);
+      }).toThrow(TypeError);
+    });
+  });
+  (0, import_vitest.describe)("Min", function () {
+    (0, import_vitest.it)("should return the smallest of base, client, and server", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", 5, 2, 7, import_merge.FieldMergeStrategy.Min);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 2,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle server being the min", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", 5, 7, 1, import_merge.FieldMergeStrategy.Min);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 1,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should handle null values as zero", function () {
+      var result = (0, import_merge.applyMergeStrategy)("priority", null, 3, 5, import_merge.FieldMergeStrategy.Min);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 0,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should throw TypeError for non-numeric values", function () {
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("priority", "a", "b", "c", import_merge.FieldMergeStrategy.Min);
+      }).toThrow(TypeError);
+    });
+  });
+  (0, import_vitest.describe)("UnionSet", function () {
+    (0, import_vitest.it)("should return union of client and server arrays with no duplicates", function () {
+      var result = (0, import_merge.applyMergeStrategy)("tags", ["a", "b"], ["a", "b", "c"], ["a", "b", "d"], import_merge.FieldMergeStrategy.UnionSet);
+      (0, import_vitest.expect)(result.hasConflict).toBe(false);
+      var arr = result.value;
+      (0, import_vitest.expect)(arr).toContain("a");
+      (0, import_vitest.expect)(arr).toContain("b");
+      (0, import_vitest.expect)(arr).toContain("c");
+      (0, import_vitest.expect)(arr).toContain("d");
+      (0, import_vitest.expect)(new Set(arr).size).toBe(arr.length);
+    });
+    (0, import_vitest.it)("should only remove items deleted by both sides", function () {
+      var result = (0, import_merge.applyMergeStrategy)("tags", ["a", "b", "c"], ["a"], ["a"], import_merge.FieldMergeStrategy.UnionSet);
+      var arr = result.value;
+      (0, import_vitest.expect)(arr).toEqual(["a"]);
+    });
+    (0, import_vitest.it)("should keep items removed by only one side", function () {
+      var result = (0, import_merge.applyMergeStrategy)("tags", ["a", "b", "c"], ["a", "c"], ["a", "b"], import_merge.FieldMergeStrategy.UnionSet);
+      var arr = result.value;
+      (0, import_vitest.expect)(arr).toContain("a");
+      (0, import_vitest.expect)(arr).toContain("b");
+      (0, import_vitest.expect)(arr).toContain("c");
+    });
+    (0, import_vitest.it)("should handle null base as empty array", function () {
+      var result = (0, import_merge.applyMergeStrategy)("tags", null, ["a", "b"], ["b", "c"], import_merge.FieldMergeStrategy.UnionSet);
+      var arr = result.value;
+      (0, import_vitest.expect)(arr).toContain("a");
+      (0, import_vitest.expect)(arr).toContain("b");
+      (0, import_vitest.expect)(arr).toContain("c");
+    });
+    (0, import_vitest.it)("should throw TypeError for non-array values", function () {
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("tags", "not-array", ["a"], ["b"], import_merge.FieldMergeStrategy.UnionSet);
+      }).toThrow(TypeError);
+      (0, import_vitest.expect)(function () {
+        return (0, import_merge.applyMergeStrategy)("tags", ["a"], 42, ["b"], import_merge.FieldMergeStrategy.UnionSet);
+      }).toThrow(TypeError);
+    });
+  });
+  (0, import_vitest.describe)("Custom function", function () {
+    (0, import_vitest.it)("should invoke the custom function with base, client, server", function () {
+      var customFn = function customFn2(base, client, server) {
+        return client + server;
+      };
+      var result = (0, import_merge.applyMergeStrategy)("score", 0, 10, 20, customFn);
+      (0, import_vitest.expect)(result).toEqual({
+        value: 30,
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should pass correct arguments to custom function", function () {
+      var calls = [];
+      var spy = function spy2(base, client, server) {
+        calls.push([base, client, server]);
+        return server;
+      };
+      (0, import_merge.applyMergeStrategy)("field", "base-val", "client-val", "server-val", spy);
+      (0, import_vitest.expect)(calls).toHaveLength(1);
+      (0, import_vitest.expect)(calls[0]).toEqual(["base-val", "client-val", "server-val"]);
+    });
+  });
+  (0, import_vitest.describe)("ClientWins / ServerWins", function () {
+    (0, import_vitest.it)("should return client value for ClientWins", function () {
+      var result = (0, import_merge.applyMergeStrategy)("f", "base", "client", "server", import_merge.FieldMergeStrategy.ClientWins);
+      (0, import_vitest.expect)(result).toEqual({
+        value: "client",
+        hasConflict: false
+      });
+    });
+    (0, import_vitest.it)("should return server value for ServerWins", function () {
+      var result = (0, import_merge.applyMergeStrategy)("f", "base", "client", "server", import_merge.FieldMergeStrategy.ServerWins);
+      (0, import_vitest.expect)(result).toEqual({
+        value: "server",
+        hasConflict: false
+      });
+    });
+  });
+});
+(0, import_vitest.describe)("getFieldMergeStrategy", function () {
+  (0, import_vitest.it)("should return ServerWins when no config is provided", function () {
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("amount")).toBe(import_merge.FieldMergeStrategy.ServerWins);
+  });
+  (0, import_vitest.it)("should return field-specific strategy when configured", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        Invoice: {
+          fields: {
+            total: import_merge.FieldMergeStrategy.Sum,
+            priority: import_merge.FieldMergeStrategy.Max
+          }
+        }
+      }
+    };
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("total", config, "Invoice")).toBe(import_merge.FieldMergeStrategy.Sum);
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("priority", config, "Invoice")).toBe(import_merge.FieldMergeStrategy.Max);
+  });
+  (0, import_vitest.it)("should return global default when field is not in config", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ClientWins,
+      doctypes: {
+        Invoice: {
+          fields: {
+            total: import_merge.FieldMergeStrategy.Sum
+          }
+        }
+      }
+    };
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("unknown_field", config, "Invoice")).toBe(import_merge.FieldMergeStrategy.ClientWins);
+  });
+  (0, import_vitest.it)("should fall back to doctype default strategy when field not configured", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        Invoice: {
+          defaultStrategy: import_merge.MergeStrategy.ClientWins,
+          fields: {}
+        }
+      }
+    };
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("some_field", config, "Invoice")).toBe(import_merge.FieldMergeStrategy.ClientWins);
+  });
+  (0, import_vitest.it)("should fall back to global default when doctype has no config", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ClientWins,
+      doctypes: {
+        Invoice: {
+          fields: {
+            total: import_merge.FieldMergeStrategy.Sum
+          }
+        }
+      }
+    };
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("total", config, "UnknownDoctype")).toBe(import_merge.FieldMergeStrategy.ClientWins);
+  });
+  (0, import_vitest.it)("should return a custom function strategy correctly", function () {
+    var customFn = function customFn2(base, client, _server) {
+      return base + client;
+    };
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        Invoice: {
+          fields: {
+            computed: customFn
+          }
+        }
+      }
+    };
+    var result = (0, import_merge.getFieldMergeStrategy)("computed", config, "Invoice");
+    (0, import_vitest.expect)(result).toBe(customFn);
+  });
+  (0, import_vitest.it)("should return ServerWins when config has no doctype and global is ServerWins", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins
+    };
+    (0, import_vitest.expect)((0, import_merge.getFieldMergeStrategy)("field", config, "AnyDoctype")).toBe(import_merge.FieldMergeStrategy.ServerWins);
+  });
+});
+(0, import_vitest.describe)("merge with MergeConfig", function () {
+  (0, import_vitest.it)("should use Max strategy for a numeric field instead of default server-wins", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        TestDoc: {
+          fields: {
+            priority: import_merge.FieldMergeStrategy.Max
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 5
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 10
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 7
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server, config);
+    (0, import_vitest.expect)(merged.priority).toBe(10);
+    (0, import_vitest.expect)(conflicts).not.toContain("priority");
+  });
+  (0, import_vitest.it)("should use Sum strategy to combine concurrent numeric changes", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        TestDoc: {
+          fields: {
+            amount: import_merge.FieldMergeStrategy.Sum
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 100
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 150
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 120
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server, config);
+    (0, import_vitest.expect)(merged.amount).toBe(170);
+    (0, import_vitest.expect)(conflicts).not.toContain("amount");
+  });
+  (0, import_vitest.it)("should use UnionSet strategy for an array field", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        TestDoc: {
+          fields: {
+            tags: import_merge.FieldMergeStrategy.UnionSet
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "b"]
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "b", "c"]
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      tags: ["a", "b", "d"]
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server, config);
+    var tags = merged.tags;
+    (0, import_vitest.expect)(tags).toContain("a");
+    (0, import_vitest.expect)(tags).toContain("b");
+    (0, import_vitest.expect)(tags).toContain("c");
+    (0, import_vitest.expect)(tags).toContain("d");
+    (0, import_vitest.expect)(conflicts).not.toContain("tags");
+  });
+  (0, import_vitest.it)("should not apply config meant for a different doctype", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        OtherDoc: {
+          fields: {
+            priority: import_merge.FieldMergeStrategy.Max
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 5
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 10
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      priority: 7
+    };
+    var {
+      merged
+    } = (0, import_merge.merge)(base, client, server, config);
+    (0, import_vitest.expect)(merged.priority).toBe(7);
+  });
+  (0, import_vitest.it)("should apply custom function strategy through merge", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        TestDoc: {
+          fields: {
+            score: function score(_base, client2, server2) {
+              return client2 * server2;
+            }
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      score: 1
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      score: 3
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      score: 4
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server, config);
+    (0, import_vitest.expect)(merged.score).toBe(12);
+    (0, import_vitest.expect)(conflicts).not.toContain("score");
+  });
+  (0, import_vitest.it)("should resolve configured fields without conflict while defaulting others to server-wins", function () {
+    var config = {
+      defaultStrategy: import_merge.MergeStrategy.ServerWins,
+      doctypes: {
+        TestDoc: {
+          fields: {
+            amount: import_merge.FieldMergeStrategy.Sum
+          }
+        }
+      }
+    };
+    var base = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 100,
+      status: "draft"
+    };
+    var client = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 150,
+      status: "submitted"
+    };
+    var server = {
+      doctype: "TestDoc",
+      name: "doc-1",
+      amount: 120,
+      status: "cancelled"
+    };
+    var {
+      merged,
+      conflicts
+    } = (0, import_merge.merge)(base, client, server, config);
+    (0, import_vitest.expect)(merged.amount).toBe(170);
+    (0, import_vitest.expect)(merged.status).toBe("cancelled");
+    (0, import_vitest.expect)(conflicts).not.toContain("amount");
+    (0, import_vitest.expect)(conflicts).not.toContain("status");
+  });
+});
+//# sourceMappingURL=merge.spec.native.js.map