@fluixi/utils 1.0.0-alpha.100

package/dist/lib/object/diff.mjs

@@ -0,0 +1,550 @@
+// src/lib/object/utils.ts
+var isObject = (value) => {
+  if (value == null) return false;
+  if (Array.isArray(value)) return false;
+  if (typeof value === "function") return false;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof Error) return false;
+  return typeof value === "object";
+};
+
+// src/lib/object/diff.ts
+var defaultEqualityFn = (a, b) => a === b;
+var deepArrayEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) return false;
+  for (let i = 0; i < arr1.length; i++) {
+    if (Array.isArray(arr1[i]) && Array.isArray(arr2[i])) {
+      if (!deepArrayEqual(arr1[i], arr2[i])) return false;
+    } else if (isObject(arr1[i]) && isObject(arr2[i])) {
+      if (!deepObjectEqual(arr1[i], arr2[i])) return false;
+    } else if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+var deepObjectEqual = (obj1, obj2) => {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!(key in obj2)) return false;
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+      if (!deepArrayEqual(val1, val2)) return false;
+    } else if (isObject(val1) && isObject(val2)) {
+      if (!deepObjectEqual(val1, val2)) return false;
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+  return true;
+};
+var diffObject = (oldObj, newObj, options = {}) => {
+  const {
+    includeDeleted = false,
+    includeAdded = true,
+    deepArrayComparison = true,
+    equalityFn = defaultEqualityFn,
+    preserveStructure = false
+  } = options;
+  if (oldObj == null && newObj == null) {
+    return {};
+  }
+  if (oldObj == null) {
+    return includeAdded ? { ...newObj } : {};
+  }
+  if (newObj == null) {
+    if (includeDeleted) {
+      const result2 = {};
+      for (const key in oldObj) {
+        result2[key] = void 0;
+      }
+      return result2;
+    }
+    return {};
+  }
+  if (!isObject(oldObj) || !isObject(newObj)) {
+    return equalityFn(oldObj, newObj) ? {} : newObj;
+  }
+  const result = {};
+  const processedKeys = /* @__PURE__ */ new Set();
+  for (const key in newObj) {
+    processedKeys.add(key);
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      if (includeAdded) {
+        result[key] = newValue;
+      }
+      continue;
+    }
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+      if (deepArrayComparison) {
+        if (!deepArrayEqual(oldValue, newValue)) {
+          result[key] = newValue;
+        } else if (preserveStructure) {
+          result[key] = void 0;
+        }
+      } else {
+        if (oldValue !== newValue) {
+          result[key] = newValue;
+        } else if (preserveStructure) {
+          result[key] = void 0;
+        }
+      }
+      continue;
+    }
+    if (isObject(oldValue) && isObject(newValue)) {
+      const nestedDiff = diffObject(oldValue, newValue, options);
+      if (Object.keys(nestedDiff).length > 0) {
+        result[key] = nestedDiff;
+      } else if (preserveStructure) {
+        result[key] = void 0;
+      }
+      continue;
+    }
+    if (!equalityFn(oldValue, newValue)) {
+      result[key] = newValue;
+    } else if (preserveStructure) {
+      result[key] = void 0;
+    }
+  }
+  if (includeDeleted) {
+    for (const key in oldObj) {
+      if (!processedKeys.has(key)) {
+        result[key] = void 0;
+      }
+    }
+  }
+  return result;
+};
+var diffObjectDetailed = (oldObj, newObj, options = {}) => {
+  const added = [];
+  const deleted = [];
+  const modified = [];
+  const changes = {};
+  const {
+    includeDeleted = false,
+    includeAdded = true,
+    deepArrayComparison = true,
+    equalityFn = defaultEqualityFn
+  } = options;
+  if (Array.isArray(oldObj) && Array.isArray(newObj)) {
+    const maxLength = Math.max(oldObj.length, newObj.length);
+    const arrayChanges = [];
+    let hasArrayChanges = false;
+    for (let i = 0; i < maxLength; i++) {
+      const indexPath = `[${i}]`;
+      if (i >= oldObj.length) {
+        added.push(indexPath);
+        arrayChanges[i] = newObj[i];
+        hasArrayChanges = true;
+      } else if (i >= newObj.length) {
+        deleted.push(indexPath);
+        hasArrayChanges = true;
+      } else {
+        const oldElement = oldObj[i];
+        const newElement = newObj[i];
+        if (isObject(oldElement) && isObject(newElement)) {
+          const nestedDiff = diffObjectDetailed(
+            oldElement,
+            newElement,
+            options
+          );
+          if (nestedDiff.hasChanges) {
+            modified.push(indexPath);
+            arrayChanges[i] = newElement;
+            hasArrayChanges = true;
+          } else {
+            arrayChanges[i] = oldElement;
+          }
+        } else if (Array.isArray(oldElement) && Array.isArray(newElement)) {
+          const nestedDiff = diffObjectDetailed(
+            oldElement,
+            newElement,
+            options
+          );
+          if (nestedDiff.hasChanges) {
+            modified.push(indexPath);
+            arrayChanges[i] = newElement;
+            hasArrayChanges = true;
+          } else {
+            arrayChanges[i] = oldElement;
+          }
+        } else if (!equalityFn(oldElement, newElement)) {
+          modified.push(indexPath);
+          arrayChanges[i] = newElement;
+          hasArrayChanges = true;
+        } else {
+          arrayChanges[i] = oldElement;
+        }
+      }
+    }
+    return {
+      changes: hasArrayChanges ? arrayChanges : {},
+      added,
+      deleted,
+      modified,
+      hasChanges: hasArrayChanges || deleted.length > 0
+    };
+  }
+  const collectDetailedPaths = (old, newVal, currentPath = "") => {
+    const result = {
+      added: [],
+      deleted: [],
+      modified: []
+    };
+    if (Array.isArray(old) && Array.isArray(newVal)) {
+      const maxLength = Math.max(old.length, newVal.length);
+      for (let i = 0; i < maxLength; i++) {
+        const indexPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;
+        if (i >= old.length) {
+          result.added.push(indexPath);
+        } else if (i >= newVal.length) {
+          result.deleted.push(indexPath);
+        } else {
+          const oldElement = old[i];
+          const newElement = newVal[i];
+          if (isObject(oldElement) && isObject(newElement)) {
+            const nested = collectDetailedPaths(
+              oldElement,
+              newElement,
+              indexPath
+            );
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          } else if (Array.isArray(oldElement) && Array.isArray(newElement)) {
+            const nested = collectDetailedPaths(
+              oldElement,
+              newElement,
+              indexPath
+            );
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          } else if (oldElement !== newElement) {
+            result.modified.push(indexPath);
+          }
+        }
+      }
+      return result;
+    }
+    if (isObject(old) && isObject(newVal)) {
+      const allKeys = /* @__PURE__ */ new Set([
+        ...Object.keys(old || {}),
+        ...Object.keys(newVal || {})
+      ]);
+      for (const key of allKeys) {
+        const oldValue = old?.[key];
+        const newValue = newVal?.[key];
+        const path = currentPath ? `${currentPath}.${key}` : key;
+        if (!(key in (old || {}))) {
+          result.added.push(path);
+        } else if (!(key in (newVal || {}))) {
+          result.deleted.push(path);
+        } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+          if (!deepArrayEqual(oldValue, newValue)) {
+            const nested = collectDetailedPaths(oldValue, newValue, path);
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          }
+        } else if (isObject(oldValue) && isObject(newValue)) {
+          const nested = collectDetailedPaths(oldValue, newValue, path);
+          result.added.push(...nested.added);
+          result.deleted.push(...nested.deleted);
+          result.modified.push(...nested.modified);
+        } else if (oldValue !== newValue) {
+          result.modified.push(path);
+        }
+      }
+    }
+    return result;
+  };
+  if (oldObj == null && newObj == null) {
+    return { changes: {}, added, deleted, modified, hasChanges: false };
+  }
+  if (oldObj == null) {
+    if (includeAdded && newObj) {
+      for (const key in newObj) {
+        added.push(key);
+        changes[key] = newObj[key];
+      }
+    }
+    return {
+      changes,
+      added,
+      deleted,
+      modified,
+      hasChanges: added.length > 0
+    };
+  }
+  if (newObj == null) {
+    if (includeDeleted) {
+      for (const key in oldObj) {
+        deleted.push(key);
+        changes[key] = void 0;
+      }
+    }
+    return {
+      changes,
+      added,
+      deleted,
+      modified,
+      hasChanges: deleted.length > 0
+    };
+  }
+  const processedKeys = /* @__PURE__ */ new Set();
+  for (const key in newObj) {
+    processedKeys.add(key);
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      if (includeAdded) {
+        added.push(key);
+        changes[key] = newValue;
+      }
+      continue;
+    }
+    let isDifferent = false;
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+      isDifferent = deepArrayComparison ? !deepArrayEqual(oldValue, newValue) : oldValue !== newValue;
+      if (isDifferent) {
+        const paths = collectDetailedPaths(oldValue, newValue, key);
+        added.push(...paths.added);
+        deleted.push(...paths.deleted);
+        modified.push(...paths.modified);
+        changes[key] = newValue;
+      }
+    } else if (isObject(oldValue) && isObject(newValue)) {
+      const nestedDiff = diffObject(oldValue, newValue, options);
+      isDifferent = Object.keys(nestedDiff).length > 0;
+      if (isDifferent) {
+        const paths = collectDetailedPaths(oldValue, newValue, key);
+        added.push(...paths.added);
+        deleted.push(...paths.deleted);
+        modified.push(...paths.modified);
+        changes[key] = nestedDiff;
+      }
+    } else {
+      isDifferent = !equalityFn(oldValue, newValue);
+      if (isDifferent) {
+        modified.push(key);
+        changes[key] = newValue;
+      }
+    }
+  }
+  for (const key in oldObj) {
+    if (!processedKeys.has(key)) {
+      deleted.push(key);
+      changes[key] = void 0;
+    }
+  }
+  return {
+    changes,
+    added,
+    deleted,
+    modified,
+    hasChanges: added.length > 0 || deleted.length > 0 || modified.length > 0
+  };
+};
+var hasObjectChanges = (oldObj, newObj, options = {}) => {
+  const diff = diffObject(oldObj, newObj, options);
+  return Object.keys(diff).length > 0;
+};
+function isApplyDiff(value) {
+  if (value && (value.diff || value.changes) && (value.modified || value.deleted || value.hasChanges)) {
+    return true;
+  }
+  return false;
+}
+var applyDiff = (baseObj, option, keepRefParam) => {
+  if (!isApplyDiff(option)) {
+    const diff2 = option;
+    const shouldKeepRef2 = keepRefParam || false;
+    if (Array.isArray(baseObj) && Array.isArray(diff2)) {
+      const result3 = shouldKeepRef2 ? baseObj : [...baseObj];
+      if (diff2.length < result3.length) {
+        result3.length = diff2.length;
+      }
+      for (let i = 0; i < diff2.length; i++) {
+        const diffValue = diff2[i];
+        if (diffValue === void 0) {
+          continue;
+        }
+        if (isObject(result3[i]) && isObject(diffValue)) {
+          result3[i] = applyDiff(result3[i], diffValue, shouldKeepRef2);
+        } else if (Array.isArray(result3[i]) && Array.isArray(diffValue)) {
+          result3[i] = applyDiff(
+            result3[i],
+            diffValue,
+            shouldKeepRef2
+          );
+        } else {
+          result3[i] = diffValue;
+        }
+      }
+      return result3;
+    }
+    if (!isObject(baseObj)) return diff2;
+    if (!isObject(diff2)) return baseObj;
+    const result2 = shouldKeepRef2 ? baseObj : { ...baseObj };
+    for (const key in diff2) {
+      const diffValue = diff2[key];
+      if (diffValue === void 0) {
+        delete result2[key];
+      } else if (Array.isArray(result2[key]) && Array.isArray(diffValue)) {
+        result2[key] = applyDiff(result2[key], diffValue, shouldKeepRef2);
+      } else if (isObject(result2[key]) && isObject(diffValue)) {
+        result2[key] = applyDiff(result2[key], diffValue, shouldKeepRef2);
+      } else {
+        result2[key] = diffValue;
+      }
+    }
+    return result2;
+  }
+  const {
+    diff,
+    added = [],
+    deleted = [],
+    modified = [],
+    changes,
+    keepRef: keepRefOption
+  } = option;
+  const shouldKeepRef = keepRefParam !== void 0 ? keepRefParam : keepRefOption;
+  const diffToApply = changes || diff;
+  if (!diffToApply) return baseObj;
+  const addedSet = new Set(added);
+  const deletedSet = new Set(deleted);
+  const modifiedSet = new Set(modified);
+  const shouldApplyPath = (path) => {
+    if (added.length === 0 && deleted.length === 0 && modified.length === 0) {
+      return true;
+    }
+    const pathParts = path.split(/[.\[\]]+/).filter(Boolean);
+    for (let i = 0; i <= pathParts.length; i++) {
+      const partialPath = pathParts.slice(0, i).join(".");
+      const bracketPath = pathParts.slice(0, i).map((p, idx) => /^\d+$/.test(p) ? `[${p}]` : idx > 0 ? `.${p}` : p).join("");
+      if (addedSet.has(partialPath) || addedSet.has(bracketPath) || deletedSet.has(partialPath) || deletedSet.has(bracketPath) || modifiedSet.has(partialPath) || modifiedSet.has(bracketPath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  if (Array.isArray(baseObj) && Array.isArray(diffToApply)) {
+    const result2 = shouldKeepRef ? baseObj : [...baseObj];
+    result2.length = diffToApply.length;
+    for (let i = 0; i < diffToApply.length; i++) {
+      const indexPath = `[${i}]`;
+      const diffValue = diffToApply[i];
+      if (diffValue === void 0) {
+        continue;
+      }
+      if (!shouldApplyPath(indexPath)) {
+        continue;
+      }
+      if (isObject(result2[i]) && isObject(diffValue)) {
+        result2[i] = applyDiff(result2[i], diffValue, shouldKeepRef);
+      } else if (Array.isArray(result2[i]) && Array.isArray(diffValue)) {
+        result2[i] = applyDiff(
+          result2[i],
+          diffValue,
+          shouldKeepRef
+        );
+      } else {
+        result2[i] = diffValue;
+      }
+    }
+    return result2;
+  }
+  if (!isObject(baseObj)) return diffToApply;
+  if (!isObject(diffToApply)) return baseObj;
+  const result = shouldKeepRef ? baseObj : { ...baseObj };
+  for (const path of deleted) {
+    if (path.includes(".") || path.includes("[")) continue;
+    if (shouldApplyPath(path)) {
+      delete result[path];
+    }
+  }
+  for (const key in diffToApply) {
+    const diffValue = diffToApply[key];
+    if (!shouldApplyPath(key)) {
+      continue;
+    }
+    if (diffValue === void 0) {
+      delete result[key];
+    } else if (Array.isArray(result[key]) && Array.isArray(diffValue)) {
+      result[key] = applyDiff(result[key], diffValue, shouldKeepRef);
+    } else if (isObject(result[key]) && isObject(diffValue)) {
+      result[key] = applyDiff(result[key], diffValue, shouldKeepRef);
+    } else {
+      result[key] = diffValue;
+    }
+  }
+  return result;
+};
+var getChangedPaths = (oldObj, newObj, options = {}) => {
+  const paths = [];
+  const collectPaths = (old, newVal, currentPath = "") => {
+    if (old === newVal) return;
+    if (Array.isArray(old) && Array.isArray(newVal)) {
+      const maxLength = Math.max(old.length, newVal.length);
+      for (let i = 0; i < maxLength; i++) {
+        const indexPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;
+        if (i >= old.length) {
+          paths.push(indexPath);
+        } else if (i >= newVal.length) {
+          paths.push(indexPath);
+        } else {
+          const oldElement = old[i];
+          const newElement = newVal[i];
+          if (isObject(oldElement) && isObject(newElement)) {
+            collectPaths(oldElement, newElement, indexPath);
+          } else if (Array.isArray(oldElement) && Array.isArray(newElement)) {
+            collectPaths(oldElement, newElement, indexPath);
+          } else if (oldElement !== newElement) {
+            paths.push(indexPath);
+          }
+        }
+      }
+      return;
+    }
+    if (!isObject(old) || !isObject(newVal)) {
+      if (currentPath) paths.push(currentPath);
+      return;
+    }
+    const allKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(old || {}),
+      ...Object.keys(newVal || {})
+    ]);
+    for (const key of allKeys) {
+      const oldValue = old?.[key];
+      const newValue = newVal?.[key];
+      const path = currentPath ? `${currentPath}.${key}` : key;
+      if (!(key in (old || {})) || !(key in (newVal || {}))) {
+        paths.push(path);
+      } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        collectPaths(oldValue, newValue, path);
+      } else if (isObject(oldValue) && isObject(newValue)) {
+        collectPaths(oldValue, newValue, path);
+      } else if (oldValue !== newValue) {
+        paths.push(path);
+      }
+    }
+  };
+  collectPaths(oldObj, newObj);
+  return paths;
+};
+export {
+  applyDiff,
+  diffObject,
+  diffObjectDetailed,
+  getChangedPaths,
+  hasObjectChanges
+};