@multiplatform.one/frappe 6.0.0

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

@@ -0,0 +1,717 @@
+"use strict";
+
+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);
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var MergeStrategy = /* @__PURE__ */function (MergeStrategy2) {
+  MergeStrategy2["ClientWins"] = "client-wins";
+  MergeStrategy2["ServerWins"] = "server-wins";
+  return MergeStrategy2;
+}({});
+var FieldMergeStrategy = /* @__PURE__ */function (FieldMergeStrategy2) {
+  FieldMergeStrategy2["ClientWins"] = "client-wins";
+  FieldMergeStrategy2["ServerWins"] = "server-wins";
+  FieldMergeStrategy2["Sum"] = "sum";
+  FieldMergeStrategy2["Max"] = "max";
+  FieldMergeStrategy2["Min"] = "min";
+  FieldMergeStrategy2["UnionSet"] = "union-set";
+  return FieldMergeStrategy2;
+}({});
+function isObject(value) {
+  return (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null && !Array.isArray(value);
+}
+function isFrappeDoc(value) {
+  return (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null && "name" in value && "doctype" in value && typeof value.name === "string" && typeof value.doctype === "string";
+}
+function getFieldMergeStrategy(fieldName, config, doctype) {
+  var _config_doctypes_doctype_fields, _config_doctypes_doctype, _config_doctypes, _config_doctypes_doctype1, _config_doctypes1;
+  if (!config) return "server-wins";
+  var fieldStrategy = doctype ? (_config_doctypes = config.doctypes) === null || _config_doctypes === void 0 ? void 0 : (_config_doctypes_doctype = _config_doctypes[doctype]) === null || _config_doctypes_doctype === void 0 ? void 0 : (_config_doctypes_doctype_fields = _config_doctypes_doctype.fields) === null || _config_doctypes_doctype_fields === void 0 ? void 0 : _config_doctypes_doctype_fields[fieldName] : void 0;
+  if (fieldStrategy) return fieldStrategy;
+  var doctypeDefault = doctype ? (_config_doctypes1 = config.doctypes) === null || _config_doctypes1 === void 0 ? void 0 : (_config_doctypes_doctype1 = _config_doctypes1[doctype]) === null || _config_doctypes_doctype1 === void 0 ? void 0 : _config_doctypes_doctype1.defaultStrategy : void 0;
+  if (doctypeDefault) {
+    return doctypeDefault === "client-wins" ? "client-wins" : "server-wins";
+  }
+  return config.defaultStrategy === "client-wins" ? "client-wins" : "server-wins";
+}
+function applyMergeStrategy(fieldName, base, client, server, strategy) {
+  if (typeof strategy === "function") {
+    return {
+      value: strategy(base, client, server),
+      hasConflict: false
+    };
+  }
+  switch (strategy) {
+    case "client-wins":
+      return {
+        value: client,
+        hasConflict: false
+      };
+    case "server-wins":
+      return {
+        value: server,
+        hasConflict: false
+      };
+    case "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}`);
+        }
+        var baseNum = typeof base === "number" ? base : 0;
+        var clientNum = typeof client === "number" ? client : 0;
+        var serverNum = typeof server === "number" ? server : 0;
+        var clientDelta = clientNum - baseNum;
+        var serverDelta = serverNum - baseNum;
+        return {
+          value: baseNum + clientDelta + serverDelta,
+          hasConflict: false
+        };
+      }
+    case "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}`);
+        }
+        var baseNum1 = typeof base === "number" ? base : 0;
+        var clientNum1 = typeof client === "number" ? client : 0;
+        var serverNum1 = typeof server === "number" ? server : 0;
+        return {
+          value: Math.max(baseNum1, clientNum1, serverNum1),
+          hasConflict: false
+        };
+      }
+    case "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}`);
+        }
+        var baseNum2 = typeof base === "number" ? base : 0;
+        var clientNum2 = typeof client === "number" ? client : 0;
+        var serverNum2 = typeof server === "number" ? server : 0;
+        return {
+          value: Math.min(baseNum2, clientNum2, serverNum2),
+          hasConflict: false
+        };
+      }
+    case "union-set":
+      {
+        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}`);
+        }
+        var baseArray = Array.isArray(base) ? base : [];
+        var baseSet = new Set(baseArray);
+        var clientSet = new Set(Array.isArray(client) ? client : []);
+        var serverSet = new Set(Array.isArray(server) ? server : []);
+        var result = new Set(baseArray);
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = clientSet[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var item = _step.value;
+            if (!baseSet.has(item)) {
+              result.add(item);
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = serverSet[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var item1 = _step1.value;
+            if (!baseSet.has(item1)) {
+              result.add(item1);
+            }
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = baseArray[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var item2 = _step2.value;
+            if (!clientSet.has(item2) && !serverSet.has(item2)) {
+              result.delete(item2);
+            }
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+        return {
+          value: Array.from(result),
+          hasConflict: false
+        };
+      }
+    default:
+      return {
+        value: server,
+        hasConflict: true
+      };
+  }
+}
+function mergeFieldValue(base, client) {
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  if (client === null || client === void 0) {
+    return client;
+  }
+  if (Array.isArray(client)) {
+    var baseArray = Array.isArray(base) ? base : [];
+    if (options.isChildTable || isChildTableArray(baseArray, client)) {
+      return mergeChildTable(baseArray, client);
+    }
+    return client;
+  }
+  if ((typeof client === "undefined" ? "undefined" : _type_of(client)) === "object" && client !== null) {
+    return {
+      ...((typeof base === "undefined" ? "undefined" : _type_of(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 === null || base === void 0 ? void 0 : base.doctype);
+  var merged = {};
+  var conflicts = [];
+  var allKeys = /* @__PURE__ */new Set();
+  if (base) Object.keys(base).forEach(function (key2) {
+    return allKeys.add(key2);
+  });
+  Object.keys(client).forEach(function (key2) {
+    return allKeys.add(key2);
+  });
+  Object.keys(server).forEach(function (key2) {
+    return allKeys.add(key2);
+  });
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = allKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var key = _step.value;
+      var baseValue = base === null || base === void 0 ? void 0 : base[key];
+      var clientValue = client[key];
+      var serverValue = server[key];
+      var clientChanged = !deepEqual(baseValue, clientValue);
+      var 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)) {
+            var baseObject = isObject(baseValue) ? baseValue : {};
+            var objectMergeResult = mergeObject(baseObject, clientValue, serverValue, config, doctype);
+            merged[key] = objectMergeResult.merged;
+            if (objectMergeResult.hasConflicts) {
+              conflicts.push(key);
+            }
+          } else {
+            var strategy = getFieldMergeStrategy(key, config, doctype);
+            var result = applyMergeStrategy(key, baseValue, clientValue, serverValue, strategy);
+            merged[key] = result.value;
+            if (result.hasConflict || !config || !doctype) {
+              conflicts.push(key);
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return {
+    merged,
+    conflicts,
+    hasConflicts: conflicts.length > 0
+  };
+}
+function mergeObject(base, client, server, config, doctype) {
+  var merged = {};
+  var allKeys = /* @__PURE__ */new Set([...Object.keys(base), ...Object.keys(client), ...Object.keys(server)]);
+  var hasConflicts = false;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = allKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var key = _step.value;
+      var baseValue = base[key];
+      var clientValue = client[key];
+      var serverValue = server[key];
+      var clientChanged = !deepEqual(baseValue, clientValue);
+      var 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 {
+        var strategy = getFieldMergeStrategy(key, config, doctype);
+        var result = applyMergeStrategy(key, baseValue, clientValue, serverValue, strategy);
+        merged[key] = result.value;
+        if (result.hasConflict) hasConflicts = true;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return {
+    merged,
+    hasConflicts
+  };
+}
+function mergeChildTable(baseArray, clientArray, serverArray, config) {
+  var isChildTable = isChildTableArray(baseArray, clientArray, serverArray);
+  if (!isChildTable) return serverArray !== null && serverArray !== void 0 ? serverArray : clientArray;
+  if (!serverArray) {
+    var rowsByName = /* @__PURE__ */new Map();
+    var result = [];
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = baseArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var row = _step.value;
+        if (isChildTableRow(row)) {
+          rowsByName.set(row.name, {
+            ...row
+          });
+          result.push(rowsByName.get(row.name));
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = clientArray[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var row1 = _step1.value;
+        if (isChildTableRow(row1)) {
+          var existingRow = rowsByName.get(row1.name);
+          if (existingRow && isObject(existingRow)) {
+            Object.assign(existingRow, row1);
+          } else {
+            rowsByName.set(row1.name, {
+              ...row1
+            });
+            result.push(rowsByName.get(row1.name));
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+    return sortChildTableByIdx(result);
+  }
+  var result1 = [];
+  var baseRowsByName = /* @__PURE__ */new Map();
+  var clientRowsByName = /* @__PURE__ */new Map();
+  var serverRowsByName = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = baseArray[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var row2 = _step2.value;
+      if (isChildTableRow(row2)) baseRowsByName.set(row2.name, row2);
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var _iteratorNormalCompletion3 = true,
+    _didIteratorError3 = false,
+    _iteratorError3 = void 0;
+  try {
+    for (var _iterator3 = clientArray[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      var row3 = _step3.value;
+      if (isChildTableRow(row3)) clientRowsByName.set(row3.name, row3);
+    }
+  } catch (err) {
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+        _iterator3.return();
+      }
+    } finally {
+      if (_didIteratorError3) {
+        throw _iteratorError3;
+      }
+    }
+  }
+  var _iteratorNormalCompletion4 = true,
+    _didIteratorError4 = false,
+    _iteratorError4 = void 0;
+  try {
+    for (var _iterator4 = serverArray[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      var row4 = _step4.value;
+      if (isChildTableRow(row4)) serverRowsByName.set(row4.name, row4);
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+  var allRowNames = /* @__PURE__ */new Set([...baseRowsByName.keys(), ...clientRowsByName.keys(), ...serverRowsByName.keys()]);
+  var _iteratorNormalCompletion5 = true,
+    _didIteratorError5 = false,
+    _iteratorError5 = void 0;
+  try {
+    for (var _iterator5 = allRowNames[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+      var rowName = _step5.value;
+      var baseRow = baseRowsByName.get(rowName);
+      var clientRow = clientRowsByName.get(rowName);
+      var serverRow = serverRowsByName.get(rowName);
+      var clientDeleted = baseRow && !clientRow;
+      var serverDeleted = baseRow && !serverRow;
+      var clientAdded = !baseRow && clientRow;
+      var serverAdded = !baseRow && serverRow;
+      if (clientDeleted && serverDeleted || clientDeleted && !serverDeleted || !clientDeleted && serverDeleted) {
+        continue;
+      }
+      if (clientAdded && !serverAdded) {
+        if (clientRow && isObject(clientRow)) {
+          result1.push({
+            ...clientRow
+          });
+        }
+      } else if (!clientAdded && serverAdded) {
+        if (serverRow && isObject(serverRow)) {
+          result1.push({
+            ...serverRow
+          });
+        }
+      } else if (clientAdded && serverAdded) {
+        if (isFrappeDoc(clientRow) && isFrappeDoc(serverRow)) {
+          var childDoctype = serverRow.doctype || clientRow.doctype;
+          if (childDoctype) {
+            var merged = merge(void 0, clientRow, serverRow, config, childDoctype);
+            result1.push(merged.merged);
+          }
+        }
+      } else if (baseRow && clientRow && serverRow) {
+        if (isFrappeDoc(baseRow) && isFrappeDoc(clientRow) && isFrappeDoc(serverRow)) {
+          var childDoctype1 = serverRow.doctype || clientRow.doctype || baseRow.doctype;
+          if (childDoctype1) {
+            var merged1 = merge(baseRow, clientRow, serverRow, config, childDoctype1);
+            result1.push(merged1.merged);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError5 = true;
+    _iteratorError5 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+        _iterator5.return();
+      }
+    } finally {
+      if (_didIteratorError5) {
+        throw _iteratorError5;
+      }
+    }
+  }
+  return sortChildTableByIdx(result1);
+}
+function sortChildTableByIdx(value) {
+  var hasIndexField = value.some(function (row) {
+    return isChildTableRow(row) && row.idx !== null && typeof row.idx === "number";
+  });
+  if (hasIndexField) {
+    value.sort(function (a, b) {
+      var indexA = isChildTableRow(a) && typeof a.idx === "number" ? a.idx : Number.MAX_SAFE_INTEGER;
+      var 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 === "undefined" ? "undefined" : _type_of(valueA)) !== (typeof valueB === "undefined" ? "undefined" : _type_of(valueB))) return false;
+  if (Array.isArray(valueA) && Array.isArray(valueB)) {
+    if (valueA.length !== valueB.length) return false;
+    return valueA.every(function (value, index) {
+      return deepEqual(value, valueB[index]);
+    });
+  }
+  if (isObject(valueA) && isObject(valueB)) {
+    var keysA = Object.keys(valueA);
+    var keysB = Object.keys(valueB);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(function (key) {
+      return deepEqual(valueA[key], valueB[key]);
+    });
+  }
+  return false;
+}
+function isChildTableRow(value) {
+  if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== "object" || value === null) return false;
+  var 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() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  if (values.length === 1) {
+    var value = values[0];
+    if (!Array.isArray(value)) return false;
+    if (value.length === 0) return null;
+    var validRows = value.filter(function (row) {
+      return 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(function (row) {
+      return isChildTableRow(row);
+    });
+  }
+  var validArrays = values.filter(function (arr2) {
+    return Array.isArray(arr2);
+  });
+  if (validArrays.length === 0) return false;
+  var hasChildTableEvidence = false;
+  var hasNonChildTableEvidence = false;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = validArrays[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var arr = _step.value;
+      if (!Array.isArray(arr)) return false;
+      if (arr.length === 0) continue;
+      var validRows1 = arr.filter(function (row) {
+        return row !== null && row !== void 0;
+      });
+      if (validRows1.length === 0) continue;
+      if ([validRows1[0], validRows1.length >= 2 ? validRows1[validRows1.length - 1] : null, validRows1.length >= 3 ? validRows1[Math.floor(validRows1.length / 2)] : null].filter(Boolean).every(function (row) {
+        return isChildTableRow(row);
+      })) {
+        hasChildTableEvidence = true;
+      } else {
+        hasNonChildTableEvidence = true;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return hasChildTableEvidence && !hasNonChildTableEvidence;
+}
+function stripNullsFromChildRow(row) {
+  var cleaned = {};
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.entries(row)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [key, value] = _step.value;
+      if (value !== null) {
+        cleaned[key] = value;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return cleaned;
+}
+//# sourceMappingURL=merge.native.js.map