@multiplatform.one/frappe 6.1.0 → 6.3.0

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

@@ -1,908 +0,0 @@
-var import_vitest = require("vitest");
-var import_merge = require("./merge.cjs");
-(0, import_vitest.describe)("mergeChildTable", () => {
-  const createChildRow = (name, idx, value) => ({
-    name,
-    doctype: "Item",
-    idx,
-    parent: "parent",
-    parentfield: "items",
-    parenttype: "Invoice",
-    value: value ?? `value-${idx}`
-  });
-  (0, import_vitest.describe)("2-way merge", () => {
-    (0, import_vitest.it)("should merge child table arrays by name", () => {
-      const baseArray = [createChildRow("row-1", 1, "old"), createChildRow("row-2", 2)];
-      const incomingArray = [createChildRow("row-1", 1, "new"), createChildRow("row-3", 3)];
-      const 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", () => {
-      const baseArray = [];
-      const incomingArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
-      const result = (0, import_merge.mergeChildTable)(baseArray, incomingArray);
-      (0, import_vitest.expect)(result).toEqual(incomingArray);
-    });
-    (0, import_vitest.it)("should handle empty incoming array", () => {
-      const baseArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
-      const incomingArray = [];
-      const 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", () => {
-      const baseArray = [createChildRow("row-3", 3), createChildRow("row-1", 1)];
-      const incomingArray = [createChildRow("row-2", 2)];
-      const 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", () => {
-    (0, import_vitest.it)("should handle concurrent updates to different rows", () => {
-      const baseArray = [createChildRow("row-1", 1, "original-1"), createChildRow("row-2", 2, "original-2")];
-      const incomingArray = [createChildRow("row-1", 1, "client-1"), createChildRow("row-2", 2, "original-2")];
-      const serverArray = [createChildRow("row-1", 1, "original-1"), createChildRow("row-2", 2, "server-2")];
-      const 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", () => {
-      const baseArray = [createChildRow("row-1", 1)];
-      const incomingArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
-      const serverArray = [createChildRow("row-1", 1), createChildRow("row-3", 3)];
-      const result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
-      (0, import_vitest.expect)(result).toHaveLength(3);
-      (0, import_vitest.expect)(result.map(r => r.name)).toContain("row-1");
-      (0, import_vitest.expect)(result.map(r => r.name)).toContain("row-2");
-      (0, import_vitest.expect)(result.map(r => r.name)).toContain("row-3");
-    });
-    (0, import_vitest.it)("should handle deletions", () => {
-      const baseArray = [createChildRow("row-1", 1), createChildRow("row-2", 2), createChildRow("row-3", 3)];
-      const incomingArray = [createChildRow("row-1", 1), createChildRow("row-3", 3)];
-      const serverArray = [createChildRow("row-1", 1), createChildRow("row-2", 2)];
-      const 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", () => {
-      const baseArray = [createChildRow("row-1", 1, "original")];
-      const incomingArray = [createChildRow("row-1", 1, "client-update")];
-      const serverArray = [createChildRow("row-1", 1, "server-update")];
-      const 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", () => {
-    (0, import_vitest.it)("should return incoming array for non-child-table 2-way merge", () => {
-      const baseArray = [1, 2, 3];
-      const incomingArray = [4, 5, 6];
-      const 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", () => {
-      const baseArray = [1, 2, 3];
-      const incomingArray = [4, 5, 6];
-      const serverArray = [7, 8, 9];
-      const result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
-      (0, import_vitest.expect)(result).toEqual(serverArray);
-    });
-    (0, import_vitest.it)("should handle mixed evidence correctly", () => {
-      const baseArray = [];
-      const incomingArray = [createChildRow("row-1", 1)];
-      const serverArray = [{
-        some: "object"
-      }];
-      const result = (0, import_merge.mergeChildTable)(baseArray, incomingArray, serverArray);
-      (0, import_vitest.expect)(result).toEqual(serverArray);
-    });
-  });
-});
-(0, import_vitest.describe)("mergeFieldValue", () => {
-  (0, import_vitest.it)("should handle null and undefined values", () => {
-    const 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", () => {
-    const base = {
-      d: 3
-    };
-    const incoming = {
-      e: 4
-    };
-    const 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", () => {
-    const base = [{
-      name: "row-1",
-      doctype: "Item",
-      idx: 1,
-      parent: "p",
-      parentfield: "f",
-      parenttype: "t",
-      value: "old"
-    }];
-    const incoming = [{
-      name: "row-1",
-      doctype: "Item",
-      idx: 1,
-      parent: "p",
-      parentfield: "f",
-      parenttype: "t",
-      value: "new"
-    }];
-    const 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", () => {
-    (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", () => {
-    const base = [1, 2, 3];
-    const incoming = [4, 5, 6];
-    const result = (0, import_merge.mergeFieldValue)(base, incoming);
-    (0, import_vitest.expect)(result).toEqual([4, 5, 6]);
-  });
-});
-(0, import_vitest.describe)("merge (3-way merge)", () => {
-  (0, import_vitest.it)("should detect and merge non-conflicting changes", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "original",
-      field2: "original"
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "client-update",
-      field2: "original"
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "original",
-      field2: "server-update"
-    };
-    const {
-      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", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "original"
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "client-update"
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "server-update"
-    };
-    const {
-      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", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1"
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      clientField: "client"
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      serverField: "server"
-    };
-    const {
-      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", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "value1",
-      field2: "value2"
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field2: "value2"
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      field1: "value1"
-    };
-    const {
-      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", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      items: [{
-        name: "row-1",
-        doctype: "Item",
-        idx: 1,
-        parent: "doc-1",
-        parentfield: "items",
-        parenttype: "Doc",
-        value: "original"
-      }]
-    };
-    const 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"
-      }]
-    };
-    const 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"
-      }]
-    };
-    const {
-      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", () => {
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "b"]
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "c"]
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "d"]
-    };
-    const {
-      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", () => {
-  (0, import_vitest.it)("should compare primitive values correctly", () => {
-    (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", () => {
-    (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", () => {
-    (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", () => {
-    const obj1 = {
-      a: 1,
-      b: [2, 3],
-      c: {
-        d: 4,
-        e: [5, 6]
-      }
-    };
-    const obj2 = {
-      a: 1,
-      b: [2, 3],
-      c: {
-        d: 4,
-        e: [5, 6]
-      }
-    };
-    const 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", () => {
-  (0, import_vitest.it)("should identify objects correctly", () => {
-    (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", () => {
-  (0, import_vitest.describe)("Sum", () => {
-    (0, import_vitest.it)("should sum client and server deltas from base", () => {
-      const 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", () => {
-      const 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", () => {
-      const 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", () => {
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("amount", "ten", 15, 12, import_merge.FieldMergeStrategy.Sum)).toThrow(TypeError);
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("amount", 10, "fifteen", 12, import_merge.FieldMergeStrategy.Sum)).toThrow(TypeError);
-    });
-  });
-  (0, import_vitest.describe)("Max", () => {
-    (0, import_vitest.it)("should return the largest of base, client, and server", () => {
-      const 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", () => {
-      const 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", () => {
-      const 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", () => {
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("priority", "low", "high", "medium", import_merge.FieldMergeStrategy.Max)).toThrow(TypeError);
-    });
-  });
-  (0, import_vitest.describe)("Min", () => {
-    (0, import_vitest.it)("should return the smallest of base, client, and server", () => {
-      const 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", () => {
-      const 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", () => {
-      const 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", () => {
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("priority", "a", "b", "c", import_merge.FieldMergeStrategy.Min)).toThrow(TypeError);
-    });
-  });
-  (0, import_vitest.describe)("UnionSet", () => {
-    (0, import_vitest.it)("should return union of client and server arrays with no duplicates", () => {
-      const 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);
-      const 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", () => {
-      const result = (0, import_merge.applyMergeStrategy)("tags", ["a", "b", "c"], ["a"], ["a"], import_merge.FieldMergeStrategy.UnionSet);
-      const arr = result.value;
-      (0, import_vitest.expect)(arr).toEqual(["a"]);
-    });
-    (0, import_vitest.it)("should keep items removed by only one side", () => {
-      const result = (0, import_merge.applyMergeStrategy)("tags", ["a", "b", "c"], ["a", "c"], ["a", "b"], import_merge.FieldMergeStrategy.UnionSet);
-      const 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", () => {
-      const result = (0, import_merge.applyMergeStrategy)("tags", null, ["a", "b"], ["b", "c"], import_merge.FieldMergeStrategy.UnionSet);
-      const 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", () => {
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("tags", "not-array", ["a"], ["b"], import_merge.FieldMergeStrategy.UnionSet)).toThrow(TypeError);
-      (0, import_vitest.expect)(() => (0, import_merge.applyMergeStrategy)("tags", ["a"], 42, ["b"], import_merge.FieldMergeStrategy.UnionSet)).toThrow(TypeError);
-    });
-  });
-  (0, import_vitest.describe)("Custom function", () => {
-    (0, import_vitest.it)("should invoke the custom function with base, client, server", () => {
-      const customFn = (base, client, server) => client + server;
-      const 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", () => {
-      const calls = [];
-      const spy = (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", () => {
-    (0, import_vitest.it)("should return client value for ClientWins", () => {
-      const 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", () => {
-      const 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", () => {
-  (0, import_vitest.it)("should return ServerWins when no config is provided", () => {
-    (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", () => {
-    const 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", () => {
-    const 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", () => {
-    const 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", () => {
-    const 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", () => {
-    const customFn = (base, client, _server) => base + client;
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        Invoice: {
-          fields: {
-            computed: customFn
-          }
-        }
-      }
-    };
-    const 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", () => {
-    const 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", () => {
-  (0, import_vitest.it)("should use Max strategy for a numeric field instead of default server-wins", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        TestDoc: {
-          fields: {
-            priority: import_merge.FieldMergeStrategy.Max
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 5
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 10
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 7
-    };
-    const {
-      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", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        TestDoc: {
-          fields: {
-            amount: import_merge.FieldMergeStrategy.Sum
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 100
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 150
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 120
-    };
-    const {
-      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", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        TestDoc: {
-          fields: {
-            tags: import_merge.FieldMergeStrategy.UnionSet
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "b"]
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "b", "c"]
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      tags: ["a", "b", "d"]
-    };
-    const {
-      merged,
-      conflicts
-    } = (0, import_merge.merge)(base, client, server, config);
-    const 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", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        OtherDoc: {
-          fields: {
-            priority: import_merge.FieldMergeStrategy.Max
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 5
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 10
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      priority: 7
-    };
-    const {
-      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", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        TestDoc: {
-          fields: {
-            score: (_base, client2, server2) => client2 * server2
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      score: 1
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      score: 3
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      score: 4
-    };
-    const {
-      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", () => {
-    const config = {
-      defaultStrategy: import_merge.MergeStrategy.ServerWins,
-      doctypes: {
-        TestDoc: {
-          fields: {
-            amount: import_merge.FieldMergeStrategy.Sum
-          }
-        }
-      }
-    };
-    const base = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 100,
-      status: "draft"
-    };
-    const client = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 150,
-      status: "submitted"
-    };
-    const server = {
-      doctype: "TestDoc",
-      name: "doc-1",
-      amount: 120,
-      status: "cancelled"
-    };
-    const {
-      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");
-  });
-});