@multiplatform.one/frappe 6.1.0 → 6.3.0

package/dist/esm/sync/merge.spec.mjs

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