@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/object/diff.cjs

@@ -1 +1,573 @@
-"use strict";var b=Object.defineProperty;var q=Object.getOwnPropertyDescriptor;var K=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var N=(n,s)=>{for(var u in s)b(n,u,{get:s[u],enumerable:!0})},J=(n,s,u,h)=>{if(s&&typeof s=="object"||typeof s=="function")for(let d of K(s))!M.call(n,d)&&d!==u&&b(n,d,{get:()=>s[d],enumerable:!(h=q(s,d))||h.enumerable});return n};var L=n=>J(b({},"__esModule",{value:!0}),n);var z={};N(z,{applyDiff:()=>x,diffObject:()=>D,diffObjectDetailed:()=>E,getChangedPaths:()=>W,hasObjectChanges:()=>B});module.exports=L(z);var o=n=>n==null||Array.isArray(n)||typeof n=="function"||n instanceof Date||n instanceof RegExp||n instanceof Map||n instanceof Set||n instanceof Error?!1:typeof n=="object";var P=(n,s)=>n===s,C=(n,s)=>{if(n.length!==s.length)return!1;for(let u=0;u<n.length;u++)if(Array.isArray(n[u])&&Array.isArray(s[u])){if(!C(n[u],s[u]))return!1}else if(o(n[u])&&o(s[u])){if(!F(n[u],s[u]))return!1}else if(n[u]!==s[u])return!1;return!0},F=(n,s)=>{let u=Object.keys(n),h=Object.keys(s);if(u.length!==h.length)return!1;for(let d of u){if(!(d in s))return!1;let c=n[d],A=s[d];if(Array.isArray(c)&&Array.isArray(A)){if(!C(c,A))return!1}else if(o(c)&&o(A)){if(!F(c,A))return!1}else if(c!==A)return!1}return!0},D=(n,s,u={})=>{let{includeDeleted:h=!1,includeAdded:d=!0,deepArrayComparison:c=!0,equalityFn:A=P,preserveStructure:R=!1}=u;if(n==null&&s==null)return{};if(n==null)return d?{...s}:{};if(s==null){if(h){let i={};for(let g in n)i[g]=void 0;return i}return{}}if(!o(n)||!o(s))return A(n,s)?{}:s;let S={},T=new Set;for(let i in s){T.add(i);let g=n[i],m=s[i];if(!(i in n)){d&&(S[i]=m);continue}if(Array.isArray(g)&&Array.isArray(m)){c?C(g,m)?R&&(S[i]=void 0):S[i]=m:g!==m?S[i]=m:R&&(S[i]=void 0);continue}if(o(g)&&o(m)){let r=D(g,m,u);Object.keys(r).length>0?S[i]=r:R&&(S[i]=void 0);continue}A(g,m)?R&&(S[i]=void 0):S[i]=m}if(h)for(let i in n)T.has(i)||(S[i]=void 0);return S},E=(n,s,u={})=>{let h=[],d=[],c=[],A={},{includeDeleted:R=!1,includeAdded:S=!0,deepArrayComparison:T=!0,equalityFn:i=P}=u;if(Array.isArray(n)&&Array.isArray(s)){let r=Math.max(n.length,s.length),p=[],y=!1;for(let e=0;e<r;e++){let f=`[${e}]`;if(e>=n.length)h.push(f),p[e]=s[e],y=!0;else if(e>=s.length)d.push(f),y=!0;else{let a=n[e],t=s[e];o(a)&&o(t)||Array.isArray(a)&&Array.isArray(t)?E(a,t,u).hasChanges?(c.push(f),p[e]=t,y=!0):p[e]=a:i(a,t)?p[e]=a:(c.push(f),p[e]=t,y=!0)}}return{changes:y?p:{},added:h,deleted:d,modified:c,hasChanges:y||d.length>0}}let g=(r,p,y="")=>{let e={added:[],deleted:[],modified:[]};if(Array.isArray(r)&&Array.isArray(p)){let f=Math.max(r.length,p.length);for(let a=0;a<f;a++){let t=y?`${y}[${a}]`:`[${a}]`;if(a>=r.length)e.added.push(t);else if(a>=p.length)e.deleted.push(t);else{let l=r[a],k=p[a];if(o(l)&&o(k)){let $=g(l,k,t);e.added.push(...$.added),e.deleted.push(...$.deleted),e.modified.push(...$.modified)}else if(Array.isArray(l)&&Array.isArray(k)){let $=g(l,k,t);e.added.push(...$.added),e.deleted.push(...$.deleted),e.modified.push(...$.modified)}else l!==k&&e.modified.push(t)}}return e}if(o(r)&&o(p)){let f=new Set([...Object.keys(r||{}),...Object.keys(p||{})]);for(let a of f){let t=r?.[a],l=p?.[a],k=y?`${y}.${a}`:a;if(!(a in(r||{})))e.added.push(k);else if(!(a in(p||{})))e.deleted.push(k);else if(Array.isArray(t)&&Array.isArray(l)){if(!C(t,l)){let $=g(t,l,k);e.added.push(...$.added),e.deleted.push(...$.deleted),e.modified.push(...$.modified)}}else if(o(t)&&o(l)){let $=g(t,l,k);e.added.push(...$.added),e.deleted.push(...$.deleted),e.modified.push(...$.modified)}else t!==l&&e.modified.push(k)}}return e};if(n==null&&s==null)return{changes:{},added:h,deleted:d,modified:c,hasChanges:!1};if(n==null){if(S&&s)for(let r in s)h.push(r),A[r]=s[r];return{changes:A,added:h,deleted:d,modified:c,hasChanges:h.length>0}}if(s==null){if(R)for(let r in n)d.push(r),A[r]=void 0;return{changes:A,added:h,deleted:d,modified:c,hasChanges:d.length>0}}let m=new Set;for(let r in s){m.add(r);let p=n[r],y=s[r];if(!(r in n)){S&&(h.push(r),A[r]=y);continue}let e=!1;if(Array.isArray(p)&&Array.isArray(y)){if(e=T?!C(p,y):p!==y,e){let f=g(p,y,r);h.push(...f.added),d.push(...f.deleted),c.push(...f.modified),A[r]=y}}else if(o(p)&&o(y)){let f=D(p,y,u);if(e=Object.keys(f).length>0,e){let a=g(p,y,r);h.push(...a.added),d.push(...a.deleted),c.push(...a.modified),A[r]=f}}else e=!i(p,y),e&&(c.push(r),A[r]=y)}for(let r in n)m.has(r)||(d.push(r),A[r]=void 0);return{changes:A,added:h,deleted:d,modified:c,hasChanges:h.length>0||d.length>0||c.length>0}},B=(n,s,u={})=>{let h=D(n,s,u);return Object.keys(h).length>0};function I(n){return!!(n&&(n.diff||n.changes)&&(n.modified||n.deleted||n.hasChanges))}var x=(n,s,u)=>{if(!I(s)){let e=s,f=u||!1;if(Array.isArray(n)&&Array.isArray(e)){let t=f?n:[...n];e.length<t.length&&(t.length=e.length);for(let l=0;l<e.length;l++){let k=e[l];k!==void 0&&(o(t[l])&&o(k)||Array.isArray(t[l])&&Array.isArray(k)?t[l]=x(t[l],k,f):t[l]=k)}return t}if(!o(n))return e;if(!o(e))return n;let a=f?n:{...n};for(let t in e){let l=e[t];l===void 0?delete a[t]:Array.isArray(a[t])&&Array.isArray(l)||o(a[t])&&o(l)?a[t]=x(a[t],l,f):a[t]=l}return a}let{diff:h,added:d=[],deleted:c=[],modified:A=[],changes:R,keepRef:S}=s,T=u!==void 0?u:S,i=R||h;if(!i)return n;let g=new Set(d),m=new Set(c),r=new Set(A),p=e=>{if(d.length===0&&c.length===0&&A.length===0)return!0;let f=e.split(/[.\[\]]+/).filter(Boolean);for(let a=0;a<=f.length;a++){let t=f.slice(0,a).join("."),l=f.slice(0,a).map((k,$)=>/^\d+$/.test(k)?`[${k}]`:$>0?`.${k}`:k).join("");if(g.has(t)||g.has(l)||m.has(t)||m.has(l)||r.has(t)||r.has(l))return!0}return!1};if(Array.isArray(n)&&Array.isArray(i)){let e=T?n:[...n];e.length=i.length;for(let f=0;f<i.length;f++){let a=`[${f}]`,t=i[f];t!==void 0&&p(a)&&(o(e[f])&&o(t)||Array.isArray(e[f])&&Array.isArray(t)?e[f]=x(e[f],t,T):e[f]=t)}return e}if(!o(n))return i;if(!o(i))return n;let y=T?n:{...n};for(let e of c)e.includes(".")||e.includes("[")||p(e)&&delete y[e];for(let e in i){let f=i[e];p(e)&&(f===void 0?delete y[e]:Array.isArray(y[e])&&Array.isArray(f)||o(y[e])&&o(f)?y[e]=x(y[e],f,T):y[e]=f)}return y},W=(n,s,u={})=>{let h=[],d=(c,A,R="")=>{if(c===A)return;if(Array.isArray(c)&&Array.isArray(A)){let T=Math.max(c.length,A.length);for(let i=0;i<T;i++){let g=R?`${R}[${i}]`:`[${i}]`;if(i>=c.length)h.push(g);else if(i>=A.length)h.push(g);else{let m=c[i],r=A[i];o(m)&&o(r)||Array.isArray(m)&&Array.isArray(r)?d(m,r,g):m!==r&&h.push(g)}}return}if(!o(c)||!o(A)){R&&h.push(R);return}let S=new Set([...Object.keys(c||{}),...Object.keys(A||{})]);for(let T of S){let i=c?.[T],g=A?.[T],m=R?`${R}.${T}`:T;!(T in(c||{}))||!(T in(A||{}))?h.push(m):Array.isArray(i)&&Array.isArray(g)||o(i)&&o(g)?d(i,g,m):i!==g&&h.push(m)}};return d(n,s),h};
+"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);
+
+// src/lib/object/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  applyDiff: () => applyDiff,
+  diffObject: () => diffObject,
+  diffObjectDetailed: () => diffObjectDetailed,
+  getChangedPaths: () => getChangedPaths,
+  hasObjectChanges: () => hasObjectChanges
+});
+module.exports = __toCommonJS(diff_exports);
+
+// 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;
+};