@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/merge.cjs

@@ -0,0 +1,435 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var merge_exports = {};
+__export(merge_exports, {
+  FieldMergeStrategy: () => FieldMergeStrategy,
+  MergeStrategy: () => MergeStrategy,
+  applyMergeStrategy: () => applyMergeStrategy,
+  deepEqual: () => deepEqual,
+  getFieldMergeStrategy: () => getFieldMergeStrategy,
+  isChildTableArray: () => isChildTableArray,
+  isChildTableRow: () => isChildTableRow,
+  isFrappeDoc: () => isFrappeDoc,
+  isObject: () => isObject,
+  merge: () => merge,
+  mergeChildTable: () => mergeChildTable,
+  mergeFieldValue: () => mergeFieldValue,
+  mergeObject: () => mergeObject,
+  sortChildTableByIdx: () => sortChildTableByIdx,
+  stripNullsFromChildRow: () => stripNullsFromChildRow
+});
+module.exports = __toCommonJS(merge_exports);
+var MergeStrategy = /* @__PURE__ */(MergeStrategy2 => {
+  MergeStrategy2["ClientWins"] = "client-wins";
+  MergeStrategy2["ServerWins"] = "server-wins";
+  return MergeStrategy2;
+})(MergeStrategy || {});
+var FieldMergeStrategy = /* @__PURE__ */(FieldMergeStrategy2 => {
+  FieldMergeStrategy2["ClientWins"] = "client-wins";
+  FieldMergeStrategy2["ServerWins"] = "server-wins";
+  FieldMergeStrategy2["Sum"] = "sum";
+  FieldMergeStrategy2["Max"] = "max";
+  FieldMergeStrategy2["Min"] = "min";
+  FieldMergeStrategy2["UnionSet"] = "union-set";
+  return FieldMergeStrategy2;
+})(FieldMergeStrategy || {});
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFrappeDoc(value) {
+  return typeof value === "object" && value !== null && "name" in value && "doctype" in value && typeof value.name === "string" && typeof value.doctype === "string";
+}
+function getFieldMergeStrategy(fieldName, config, doctype) {
+  if (!config) return "server-wins" /* ServerWins */;
+  const fieldStrategy = doctype ? config.doctypes?.[doctype]?.fields?.[fieldName] : void 0;
+  if (fieldStrategy) return fieldStrategy;
+  const doctypeDefault = doctype ? config.doctypes?.[doctype]?.defaultStrategy : void 0;
+  if (doctypeDefault) {
+    return doctypeDefault === "client-wins" /* ClientWins */ ? "client-wins" /* ClientWins */ : "server-wins" /* ServerWins */;
+  }
+  return config.defaultStrategy === "client-wins" /* ClientWins */ ? "client-wins" /* ClientWins */ : "server-wins" /* ServerWins */;
+}
+function applyMergeStrategy(fieldName, base, client, server, strategy) {
+  if (typeof strategy === "function") {
+    return {
+      value: strategy(base, client, server),
+      hasConflict: false
+    };
+  }
+  switch (strategy) {
+    case "client-wins" /* ClientWins */:
+      return {
+        value: client,
+        hasConflict: false
+      };
+    case "server-wins" /* ServerWins */:
+      return {
+        value: server,
+        hasConflict: false
+      };
+    case "sum" /* Sum */:
+      {
+        if (typeof base !== "number" && base !== null && base !== void 0 || typeof client !== "number" && client !== null && client !== void 0 || typeof server !== "number" && server !== null && server !== void 0) {
+          throw new TypeError(`merge strategy sum requires numeric values for field ${fieldName}`);
+        }
+        const baseNum = typeof base === "number" ? base : 0;
+        const clientNum = typeof client === "number" ? client : 0;
+        const serverNum = typeof server === "number" ? server : 0;
+        const clientDelta = clientNum - baseNum;
+        const serverDelta = serverNum - baseNum;
+        return {
+          value: baseNum + clientDelta + serverDelta,
+          hasConflict: false
+        };
+      }
+    case "max" /* Max */:
+      {
+        if (typeof base !== "number" && base !== null && base !== void 0 || typeof client !== "number" && client !== null && client !== void 0 || typeof server !== "number" && server !== null && server !== void 0) {
+          throw new TypeError(`merge strategy max requires numeric values for field ${fieldName}`);
+        }
+        const baseNum = typeof base === "number" ? base : 0;
+        const clientNum = typeof client === "number" ? client : 0;
+        const serverNum = typeof server === "number" ? server : 0;
+        return {
+          value: Math.max(baseNum, clientNum, serverNum),
+          hasConflict: false
+        };
+      }
+    case "min" /* Min */:
+      {
+        if (typeof base !== "number" && base !== null && base !== void 0 || typeof client !== "number" && client !== null && client !== void 0 || typeof server !== "number" && server !== null && server !== void 0) {
+          throw new TypeError(`merge strategy min requires numeric values for field ${fieldName}`);
+        }
+        const baseNum = typeof base === "number" ? base : 0;
+        const clientNum = typeof client === "number" ? client : 0;
+        const serverNum = typeof server === "number" ? server : 0;
+        return {
+          value: Math.min(baseNum, clientNum, serverNum),
+          hasConflict: false
+        };
+      }
+    case "union-set" /* UnionSet */:
+      {
+        if (!Array.isArray(base) && base !== null && base !== void 0 || !Array.isArray(client) && client !== null && client !== void 0 || !Array.isArray(server) && server !== null && server !== void 0) {
+          throw new TypeError(`merge strategy union requires array values for field ${fieldName}`);
+        }
+        const baseArray = Array.isArray(base) ? base : [];
+        const baseSet = new Set(baseArray);
+        const clientSet = new Set(Array.isArray(client) ? client : []);
+        const serverSet = new Set(Array.isArray(server) ? server : []);
+        const result = new Set(baseArray);
+        for (const item of clientSet) {
+          if (!baseSet.has(item)) {
+            result.add(item);
+          }
+        }
+        for (const item of serverSet) {
+          if (!baseSet.has(item)) {
+            result.add(item);
+          }
+        }
+        for (const item of baseArray) {
+          if (!clientSet.has(item) && !serverSet.has(item)) {
+            result.delete(item);
+          }
+        }
+        return {
+          value: Array.from(result),
+          hasConflict: false
+        };
+      }
+    default:
+      return {
+        value: server,
+        hasConflict: true
+      };
+  }
+}
+function mergeFieldValue(base, client, options = {}) {
+  if (client === null || client === void 0) {
+    return client;
+  }
+  if (Array.isArray(client)) {
+    const baseArray = Array.isArray(base) ? base : [];
+    if (options.isChildTable || isChildTableArray(baseArray, client)) {
+      return mergeChildTable(baseArray, client);
+    }
+    return client;
+  }
+  if (typeof client === "object" && client !== null) {
+    return {
+      ...(typeof base === "object" && base !== null && !Array.isArray(base) ? base : {}),
+      ...client
+    };
+  }
+  return client;
+}
+function merge(base, client, server, config, doctype) {
+  doctype = doctype || server.doctype || client.doctype || base?.doctype;
+  const merged = {};
+  const conflicts = [];
+  const allKeys = /* @__PURE__ */new Set();
+  if (base) Object.keys(base).forEach(key => allKeys.add(key));
+  Object.keys(client).forEach(key => allKeys.add(key));
+  Object.keys(server).forEach(key => allKeys.add(key));
+  for (const key of allKeys) {
+    const baseValue = base?.[key];
+    const clientValue = client[key];
+    const serverValue = server[key];
+    const clientChanged = !deepEqual(baseValue, clientValue);
+    const serverChanged = !deepEqual(baseValue, serverValue);
+    if (!clientChanged && !serverChanged) {
+      merged[key] = baseValue;
+    } else if (clientChanged && !serverChanged) {
+      merged[key] = mergeFieldValue(baseValue, clientValue);
+    } else if (!clientChanged && serverChanged) {
+      merged[key] = mergeFieldValue(baseValue, serverValue);
+    } else {
+      if (deepEqual(clientValue, serverValue)) {
+        merged[key] = serverValue;
+      } else {
+        if (isChildTableArray(baseValue, clientValue, serverValue)) {
+          merged[key] = mergeChildTable(Array.isArray(baseValue) ? baseValue : [], Array.isArray(clientValue) ? clientValue : [], Array.isArray(serverValue) ? serverValue : [], config);
+        } else if (isObject(clientValue) && isObject(serverValue)) {
+          const baseObject = isObject(baseValue) ? baseValue : {};
+          const objectMergeResult = mergeObject(baseObject, clientValue, serverValue, config, doctype);
+          merged[key] = objectMergeResult.merged;
+          if (objectMergeResult.hasConflicts) {
+            conflicts.push(key);
+          }
+        } else {
+          const strategy = getFieldMergeStrategy(key, config, doctype);
+          const result = applyMergeStrategy(key, baseValue, clientValue, serverValue, strategy);
+          merged[key] = result.value;
+          if (result.hasConflict || !config || !doctype) {
+            conflicts.push(key);
+          }
+        }
+      }
+    }
+  }
+  return {
+    merged,
+    conflicts,
+    hasConflicts: conflicts.length > 0
+  };
+}
+function mergeObject(base, client, server, config, doctype) {
+  const merged = {};
+  const allKeys = /* @__PURE__ */new Set([...Object.keys(base), ...Object.keys(client), ...Object.keys(server)]);
+  let hasConflicts = false;
+  for (const key of allKeys) {
+    const baseValue = base[key];
+    const clientValue = client[key];
+    const serverValue = server[key];
+    const clientChanged = !deepEqual(baseValue, clientValue);
+    const serverChanged = !deepEqual(baseValue, serverValue);
+    if (!clientChanged && !serverChanged) {
+      merged[key] = baseValue;
+    } else if (clientChanged && !serverChanged) {
+      merged[key] = clientValue;
+    } else if (!clientChanged && serverChanged) {
+      merged[key] = serverValue;
+    } else if (deepEqual(clientValue, serverValue)) {
+      merged[key] = serverValue;
+    } else {
+      const strategy = getFieldMergeStrategy(key, config, doctype);
+      const result = applyMergeStrategy(key, baseValue, clientValue, serverValue, strategy);
+      merged[key] = result.value;
+      if (result.hasConflict) hasConflicts = true;
+    }
+  }
+  return {
+    merged,
+    hasConflicts
+  };
+}
+function mergeChildTable(baseArray, clientArray, serverArray, config) {
+  const isChildTable = isChildTableArray(baseArray, clientArray, serverArray);
+  if (!isChildTable) return serverArray ?? clientArray;
+  if (!serverArray) {
+    const rowsByName = /* @__PURE__ */new Map();
+    const result2 = [];
+    for (const row of baseArray) {
+      if (isChildTableRow(row)) {
+        rowsByName.set(row.name, {
+          ...row
+        });
+        result2.push(rowsByName.get(row.name));
+      }
+    }
+    for (const row of clientArray) {
+      if (isChildTableRow(row)) {
+        const existingRow = rowsByName.get(row.name);
+        if (existingRow && isObject(existingRow)) {
+          Object.assign(existingRow, row);
+        } else {
+          rowsByName.set(row.name, {
+            ...row
+          });
+          result2.push(rowsByName.get(row.name));
+        }
+      }
+    }
+    return sortChildTableByIdx(result2);
+  }
+  const result = [];
+  const baseRowsByName = /* @__PURE__ */new Map();
+  const clientRowsByName = /* @__PURE__ */new Map();
+  const serverRowsByName = /* @__PURE__ */new Map();
+  for (const row of baseArray) {
+    if (isChildTableRow(row)) baseRowsByName.set(row.name, row);
+  }
+  for (const row of clientArray) {
+    if (isChildTableRow(row)) clientRowsByName.set(row.name, row);
+  }
+  for (const row of serverArray) {
+    if (isChildTableRow(row)) serverRowsByName.set(row.name, row);
+  }
+  const allRowNames = /* @__PURE__ */new Set([...baseRowsByName.keys(), ...clientRowsByName.keys(), ...serverRowsByName.keys()]);
+  for (const rowName of allRowNames) {
+    const baseRow = baseRowsByName.get(rowName);
+    const clientRow = clientRowsByName.get(rowName);
+    const serverRow = serverRowsByName.get(rowName);
+    const clientDeleted = baseRow && !clientRow;
+    const serverDeleted = baseRow && !serverRow;
+    const clientAdded = !baseRow && clientRow;
+    const serverAdded = !baseRow && serverRow;
+    if (clientDeleted && serverDeleted || clientDeleted && !serverDeleted || !clientDeleted && serverDeleted) {
+      continue;
+    }
+    if (clientAdded && !serverAdded) {
+      if (clientRow && isObject(clientRow)) {
+        result.push({
+          ...clientRow
+        });
+      }
+    } else if (!clientAdded && serverAdded) {
+      if (serverRow && isObject(serverRow)) {
+        result.push({
+          ...serverRow
+        });
+      }
+    } else if (clientAdded && serverAdded) {
+      if (isFrappeDoc(clientRow) && isFrappeDoc(serverRow)) {
+        const childDoctype = serverRow.doctype || clientRow.doctype;
+        if (childDoctype) {
+          const merged = merge(void 0, clientRow, serverRow, config, childDoctype);
+          result.push(merged.merged);
+        }
+      }
+    } else if (baseRow && clientRow && serverRow) {
+      if (isFrappeDoc(baseRow) && isFrappeDoc(clientRow) && isFrappeDoc(serverRow)) {
+        const childDoctype = serverRow.doctype || clientRow.doctype || baseRow.doctype;
+        if (childDoctype) {
+          const merged = merge(baseRow, clientRow, serverRow, config, childDoctype);
+          result.push(merged.merged);
+        }
+      }
+    }
+  }
+  return sortChildTableByIdx(result);
+}
+function sortChildTableByIdx(value) {
+  const hasIndexField = value.some(row => isChildTableRow(row) && row.idx !== null && typeof row.idx === "number");
+  if (hasIndexField) {
+    value.sort((a, b) => {
+      const indexA = isChildTableRow(a) && typeof a.idx === "number" ? a.idx : Number.MAX_SAFE_INTEGER;
+      const indexB = isChildTableRow(b) && typeof b.idx === "number" ? b.idx : Number.MAX_SAFE_INTEGER;
+      return indexA - indexB;
+    });
+  }
+  return value;
+}
+function deepEqual(valueA, valueB) {
+  if (valueA === valueB) return true;
+  if (valueA == null || valueB == null) return valueA === valueB;
+  if (typeof valueA !== typeof valueB) return false;
+  if (Array.isArray(valueA) && Array.isArray(valueB)) {
+    if (valueA.length !== valueB.length) return false;
+    return valueA.every((value, index) => deepEqual(value, valueB[index]));
+  }
+  if (isObject(valueA) && isObject(valueB)) {
+    const keysA = Object.keys(valueA);
+    const keysB = Object.keys(valueB);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(key => deepEqual(valueA[key], valueB[key]));
+  }
+  return false;
+}
+function isChildTableRow(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const row = value;
+  if (typeof row.name !== "string") return false;
+  if (!("idx" in row) || row.idx !== null && typeof row.idx !== "number") {
+    return false;
+  }
+  if (!("parent" in row) || row.parent !== null && typeof row.parent !== "string") {
+    return false;
+  }
+  if (!("parentfield" in row) || row.parentfield !== null && typeof row.parentfield !== "string") {
+    return false;
+  }
+  if (!("parenttype" in row) || row.parenttype !== null && typeof row.parenttype !== "string") {
+    return false;
+  }
+  if ("doctype" in row && row.doctype !== null && typeof row.doctype !== "string") {
+    return false;
+  }
+  return true;
+}
+function isChildTableArray(...values) {
+  if (values.length === 1) {
+    const value = values[0];
+    if (!Array.isArray(value)) return false;
+    if (value.length === 0) return null;
+    const validRows = value.filter(row => row !== null && row !== void 0);
+    if (validRows.length === 0) return null;
+    return [validRows[0], validRows[validRows.length - 1], validRows[Math.floor(validRows.length / 2)]].filter(Boolean).every(row => isChildTableRow(row));
+  }
+  const validArrays = values.filter(arr => Array.isArray(arr));
+  if (validArrays.length === 0) return false;
+  let hasChildTableEvidence = false;
+  let hasNonChildTableEvidence = false;
+  for (const arr of validArrays) {
+    if (!Array.isArray(arr)) return false;
+    if (arr.length === 0) continue;
+    const validRows = arr.filter(row => row !== null && row !== void 0);
+    if (validRows.length === 0) continue;
+    if ([validRows[0], validRows.length >= 2 ? validRows[validRows.length - 1] : null, validRows.length >= 3 ? validRows[Math.floor(validRows.length / 2)] : null].filter(Boolean).every(row => isChildTableRow(row))) {
+      hasChildTableEvidence = true;
+    } else {
+      hasNonChildTableEvidence = true;
+    }
+  }
+  return hasChildTableEvidence && !hasNonChildTableEvidence;
+}
+function stripNullsFromChildRow(row) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (value !== null) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}