objwalk 1.5.0 → 1.7.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   clone: () => clone,
+  diff: () => diff,
   each: () => each,
   equally: () => equally,
   extract: () => extract,
@@ -34,6 +35,38 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/helpers/createPath.ts
+var createPath = (parentPath, key, parentIsArray) => {
+  if (parentIsArray) {
+    return parentPath + "[" + key + "]";
+  }
+  return parentPath ? parentPath + "." + key : String(key);
+};
+
+// src/helpers/isWalkable.ts
+var isWalkable = (value) => {
+  return value !== null && typeof value === "object";
+};
+
+// src/each.ts
+var each = (data, callback, { root = false, descend } = {}) => {
+  const walk = (value, path, segments, key) => {
+    const proceed = segments.length > 0 || root ? callback(key, value, path, [...segments]) !== false : true;
+    if (proceed && isWalkable(value) && (descend === void 0 || descend({ key, value, path, segments: [...segments] }))) {
+      if (Array.isArray(value)) {
+        return value.every(
+          (item, index) => walk(item, createPath(path, index, true), [...segments, index], index)
+        );
+      }
+      return Object.keys(value).every(
+        (childKey) => walk(value[childKey], createPath(path, childKey, false), [...segments, childKey], childKey)
+      );
+    }
+    return proceed;
+  };
+  walk(data, "", [], void 0);
+};
+
 // src/helpers/getValueByKey.ts
 var getValueByKey = (object, key, { inherited = true, ignore = [] } = {}) => {
   if (object === null || object === void 0 || ignore.includes(key) || !inherited && !Object.hasOwn(object, key)) {
@@ -85,51 +118,6 @@ var parsePathSelection = (path = "") => {
   };
 };
 
-// src/helpers/createPath.ts
-var createPath = (parentPath, key, parentIsArray) => {
-  if (parentIsArray) {
-    return parentPath + "[" + key + "]";
-  }
-  return parentPath ? parentPath + "." + key : String(key);
-};
-
-// src/helpers/isWalkable.ts
-var isWalkable = (value) => {
-  return value !== null && typeof value === "object";
-};
-
-// src/each.ts
-var each = (data, callback) => {
-  const walk = (value, path, key, parentIsArray) => {
-    const currentPath = path || createPath("", key, parentIsArray);
-    callback(key, value, currentPath);
-    if (!isWalkable(value)) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        walk(item, createPath(currentPath, index, true), index, true);
-      });
-      return;
-    }
-    Object.entries(value).forEach(([childKey, item]) => {
-      walk(item, createPath(currentPath, childKey, false), childKey, false);
-    });
-  };
-  if (!isWalkable(data)) {
-    return;
-  }
-  if (Array.isArray(data)) {
-    data.forEach((item, index) => {
-      walk(item, createPath("", index, true), index, true);
-    });
-    return;
-  }
-  Object.entries(data).forEach(([key, value]) => {
-    walk(value, createPath("", key, false), key, false);
-  });
-};
-
 // src/pick.ts
 var pick = (data = {}, path = "", options = {}) => {
   const { cleanPath, keys } = parsePathSelection(path);
@@ -223,13 +211,13 @@ var extract = (source, mapping) => {
       return;
     }
     if (Array.isArray(sourcePath)) {
-      for (const item of sourcePath) {
+      each(sourcePath, (_key, item) => {
         const value = pick(source, item);
         if (value !== void 0) {
           set(result, destinationPath, value);
-          break;
+          return false;
         }
-      }
+      });
       return;
     }
     set(result, destinationPath, pick(source, sourcePath));
@@ -245,114 +233,144 @@ var map = (data, callback, store = {}) => {
   return store;
 };
 
-// src/merge.ts
-var unsafeKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+// src/helpers/isPlainObject.ts
 var isPlainObject = (value) => {
-  if (value === null || typeof value !== "object") {
-    return false;
+  if (value !== null && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
   }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+  return false;
 };
+
+// src/merge.ts
+var unsafeKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var merge = (target, ...sources) => {
   const targetRecord = target;
-  for (const source of sources) {
-    if (!isPlainObject(source)) {
-      continue;
-    }
-    for (const [key, sourceValue] of Object.entries(source)) {
-      if (unsafeKeys.has(key)) {
-        continue;
-      }
-      const targetValue = targetRecord[key];
-      if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
-        merge(targetValue, sourceValue);
-      } else {
-        targetRecord[key] = sourceValue;
-      }
+  each(sources, (_index, source) => {
+    if (isPlainObject(source)) {
+      each(Object.entries(source), (_index2, [key, sourceValue]) => {
+        if (unsafeKeys.has(key) === false) {
+          const targetValue = targetRecord[key];
+          if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+            merge(targetValue, sourceValue);
+          } else {
+            targetRecord[key] = sourceValue;
+          }
+        }
+      }, { descend: ({ segments }) => segments.length === 0 });
     }
-  }
+  }, { descend: ({ segments }) => segments.length === 0 });
   return target;
 };
 
 // src/flush.ts
 var flush = (data = {}, path) => {
-  if (path.length > 0) {
-    const keys = path.split(".");
-    const lastKey = keys.pop() ?? "";
-    const match = lastKey.match(/^(\w+)\[(\d+)\]$/);
-    let parent = getValueByPath(data, keys.join("."), { inherited: false });
-    let key = lastKey;
-    if (match) {
-      const [, arrayKey, index] = match;
-      const array = getValueByKey(parent, arrayKey, { inherited: false });
-      parent = Array.isArray(array) ? array : void 0;
-      key = index;
-    }
-    if (parent !== null && typeof parent === "object" && Object.hasOwn(parent, key)) {
-      delete parent[key];
+  const paths = Array.isArray(path) ? path : [path];
+  each(paths, (_key, path2) => {
+    if (path2.length > 0) {
+      const keys = path2.split(".");
+      const lastKey = keys.pop() ?? "";
+      const match = lastKey.match(/^(\w+)\[(\d+)\]$/);
+      let parent = getValueByPath(data, keys.join("."), { inherited: false });
+      let key = lastKey;
+      if (match) {
+        const [, arrayKey, index] = match;
+        const array = getValueByKey(parent, arrayKey, { inherited: false });
+        parent = Array.isArray(array) ? array : void 0;
+        key = index;
+      }
+      if (parent !== null && typeof parent === "object" && Object.hasOwn(parent, key)) {
+        delete parent[key];
+      }
     }
-  }
+  });
   return data;
 };
 
 // src/deepEqual.ts
 var deepEqual = (x, y, store) => {
-  if (Number.isNaN(x) && Number.isNaN(y)) {
+  if (x === y || Number.isNaN(x) && Number.isNaN(y)) {
     return true;
   }
-  if (x === y) {
-    return true;
-  }
-  if (x == null || y == null) {
-    return false;
-  }
-  if (typeof x !== "object" || typeof y !== "object") {
-    return false;
-  }
-  let seen = store.get(x);
-  if (seen !== void 0 && seen.has(y)) {
-    return true;
-  }
-  if (seen === void 0) {
-    seen = /* @__PURE__ */ new WeakSet();
-    store.set(x, seen);
-  }
-  seen.add(y);
-  if (x instanceof Date && y instanceof Date) {
-    return x.getTime() === y.getTime();
-  }
-  if (x instanceof RegExp && y instanceof RegExp) {
-    return x.toString() === y.toString();
-  }
-  const isArrayX = Array.isArray(x);
-  const isArrayY = Array.isArray(y);
-  if (isArrayX !== isArrayY) {
-    return false;
-  }
-  if (isArrayX) {
-    return equalArrays(x, y, store);
+  if (x !== null && y !== null && typeof x === "object" && typeof y === "object") {
+    let seen = store.get(x);
+    if (seen !== void 0 && seen.has(y)) {
+      return true;
+    }
+    if (seen === void 0) {
+      seen = /* @__PURE__ */ new WeakSet();
+      store.set(x, seen);
+    }
+    seen.add(y);
+    if (x instanceof Date || y instanceof Date) {
+      return x instanceof Date && y instanceof Date && x.getTime() === y.getTime();
+    }
+    if (x instanceof RegExp || y instanceof RegExp) {
+      return x instanceof RegExp && y instanceof RegExp && x.toString() === y.toString();
+    }
+    if (Array.isArray(x) && Array.isArray(y)) {
+      const { length } = x;
+      let equal = length === y.length;
+      let index = 0;
+      while (equal && index < length) {
+        equal = deepEqual(x[index], y[index], store);
+        index += 1;
+      }
+      return equal;
+    } else if (Array.isArray(x) === false && Array.isArray(y) === false) {
+      const keysX = Reflect.ownKeys(x);
+      const keysY = Reflect.ownKeys(y);
+      return keysX.length === keysY.length && keysX.every(
+        (key) => Object.hasOwn(y, key) && deepEqual(x[key], y[key], store)
+      );
+    }
   }
-  return equalObjects(x, y, store);
+  return false;
 };
-var equalArrays = (x, y, store) => x.length === y.length && x.every((value, index) => deepEqual(value, y[index], store));
-var equalObjects = (x, y, store) => {
-  const keysX = Reflect.ownKeys(x);
-  const keysY = Reflect.ownKeys(y);
-  if (keysX.length !== keysY.length) {
-    return false;
+
+// src/equally.ts
+var equally = (a, b, paths) => {
+  if (paths !== void 0) {
+    return paths.every((path) => equally(getValueByPath(a, path), getValueByPath(b, path)));
   }
-  return keysX.every((key) => {
-    if (!Object.hasOwn(y, key)) {
-      return false;
+  return deepEqual(a, b, /* @__PURE__ */ new WeakMap());
+};
+
+// src/diff.ts
+var diff = (first, last) => {
+  const operations = [];
+  const frames = [];
+  const finish = (depth) => {
+    each(frames.splice(depth).reverse(), (_index, { first: first2, last: last2, path }) => {
+      each(Object.keys(first2), (_index2, key) => {
+        if (Object.prototype.propertyIsEnumerable.call(last2, key) === false) {
+          operations.push({ type: "delete", path: [...path, key] });
+        }
+      });
+    }, { descend: ({ segments }) => segments.length === 0 });
+    return frames.at(-1);
+  };
+  let descend = false;
+  each(last, (key, value, _path, segments) => {
+    const path = segments.map(String);
+    const frame = finish(segments.length);
+    const present = key === void 0 || frame !== void 0 && Object.prototype.propertyIsEnumerable.call(frame.first, key);
+    const previous = key === void 0 ? first : present ? frame?.first[key] : void 0;
+    descend = false;
+    if (present && isPlainObject(previous) && isPlainObject(value)) {
+      frames.push({ first: previous, last: value, path });
+      descend = true;
+    } else if (present === false || equally(previous, value) === false) {
+      operations.push({ type: "set", path, value });
     }
-    return deepEqual(x[key], y[key], store);
+  }, {
+    root: true,
+    descend: () => descend
   });
+  finish(0);
+  return operations;
 };
 
-// src/equally.ts
-var equally = (a, b) => deepEqual(a, b, /* @__PURE__ */ new WeakMap());
-
 // src/clone.ts
 var clone = (value) => {
   const store = /* @__PURE__ */ new WeakMap();
@@ -380,9 +398,9 @@ var clone = (value) => {
     }
     const result = {};
     store.set(obj, result);
-    for (const key of Reflect.ownKeys(obj)) {
+    each(Reflect.ownKeys(obj), (_index, key) => {
       result[key] = cloneValue(obj[key]);
-    }
+    });
     return result;
   };
   return cloneValue(value);
@@ -423,6 +441,7 @@ var stringify = (value, { fallback, onError, replacer, space } = {}) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   clone,
+  diff,
   each,
   equally,
   extract,

package/dist/index.d.cts

@@ -1,4 +1,12 @@
 type WalkKey = string | number;
+type DiffOperation = {
+    type: 'set';
+    path: string[];
+    value: unknown;
+} | {
+    type: 'delete';
+    path: string[];
+};
 type PickOptions = {
     inherited?: boolean;
     ignore?: readonly string[];
@@ -15,8 +23,24 @@ type StringifyOptions = {
     space?: string | number;
 };
 
-type EachCallback = (key: WalkKey, value: any, path: string) => void;
-declare const each: (data: any, callback: EachCallback) => void;
+type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => unknown;
+type EachEntry = {
+    key: WalkKey | undefined;
+    value: any;
+    path: string;
+    segments: WalkKey[];
+};
+type EachOptions = {
+    root?: boolean;
+    descend?: (entry: EachEntry) => boolean;
+};
+type Each = {
+    (data: any, callback: EachCallback, options?: EachOptions & {
+        root?: false;
+    }): void;
+    (data: any, callback: EachCallback<WalkKey | undefined>, options: EachOptions): void;
+};
+declare const each: Each;
 
 type ObjwalkObject$1 = Record<string, any>;
 declare const pick: (data?: ObjwalkObject$1, path?: string, options?: PickOptions) => any;
@@ -32,9 +56,11 @@ declare const merge: <T extends ObjwalkObject$1>(target: T, ...sources: unknown[
 type ObjwalkObject = Record<string, any>;
 declare const set: (data: ObjwalkObject | undefined, path: string, value: any) => ObjwalkObject;
 
-declare const flush: (data: ObjwalkObject$1 | undefined, path: string) => ObjwalkObject$1;
+declare const flush: (data: ObjwalkObject$1 | undefined, path: string | string[]) => ObjwalkObject$1;
+
+declare const equally: (a: unknown, b: unknown, paths?: string[]) => boolean;
 
-declare const equally: (a: unknown, b: unknown) => boolean;
+declare const diff: (first: unknown, last: unknown) => DiffOperation[];
 
 declare const clone: <T>(value: T) => T;
 
@@ -42,4 +68,4 @@ declare const parse: (raw: unknown, { fallback, onError, reviver }?: ParseOption
 
 declare const stringify: (value: unknown, { fallback, onError, replacer, space }?: StringifyOptions) => string | undefined;
 
-export { type EachCallback, type ExtractMapping, type MapCallback, type ObjwalkObject$1 as ObjwalkObject, type ParseOptions, type PickOptions, type StringifyOptions, type WalkKey, clone, each, equally, extract, flush, map, merge, parse, pick, set, stringify };
+export { type DiffOperation, type EachCallback, type EachEntry, type EachOptions, type ExtractMapping, type MapCallback, type ObjwalkObject$1 as ObjwalkObject, type ParseOptions, type PickOptions, type StringifyOptions, type WalkKey, clone, diff, each, equally, extract, flush, map, merge, parse, pick, set, stringify };

package/dist/index.d.ts

@@ -1,4 +1,12 @@
 type WalkKey = string | number;
+type DiffOperation = {
+    type: 'set';
+    path: string[];
+    value: unknown;
+} | {
+    type: 'delete';
+    path: string[];
+};
 type PickOptions = {
     inherited?: boolean;
     ignore?: readonly string[];
@@ -15,8 +23,24 @@ type StringifyOptions = {
     space?: string | number;
 };
 
-type EachCallback = (key: WalkKey, value: any, path: string) => void;
-declare const each: (data: any, callback: EachCallback) => void;
+type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => unknown;
+type EachEntry = {
+    key: WalkKey | undefined;
+    value: any;
+    path: string;
+    segments: WalkKey[];
+};
+type EachOptions = {
+    root?: boolean;
+    descend?: (entry: EachEntry) => boolean;
+};
+type Each = {
+    (data: any, callback: EachCallback, options?: EachOptions & {
+        root?: false;
+    }): void;
+    (data: any, callback: EachCallback<WalkKey | undefined>, options: EachOptions): void;
+};
+declare const each: Each;
 
 type ObjwalkObject$1 = Record<string, any>;
 declare const pick: (data?: ObjwalkObject$1, path?: string, options?: PickOptions) => any;
@@ -32,9 +56,11 @@ declare const merge: <T extends ObjwalkObject$1>(target: T, ...sources: unknown[
 type ObjwalkObject = Record<string, any>;
 declare const set: (data: ObjwalkObject | undefined, path: string, value: any) => ObjwalkObject;
 
-declare const flush: (data: ObjwalkObject$1 | undefined, path: string) => ObjwalkObject$1;
+declare const flush: (data: ObjwalkObject$1 | undefined, path: string | string[]) => ObjwalkObject$1;
+
+declare const equally: (a: unknown, b: unknown, paths?: string[]) => boolean;
 
-declare const equally: (a: unknown, b: unknown) => boolean;
+declare const diff: (first: unknown, last: unknown) => DiffOperation[];
 
 declare const clone: <T>(value: T) => T;
 
@@ -42,4 +68,4 @@ declare const parse: (raw: unknown, { fallback, onError, reviver }?: ParseOption
 
 declare const stringify: (value: unknown, { fallback, onError, replacer, space }?: StringifyOptions) => string | undefined;
 
-export { type EachCallback, type ExtractMapping, type MapCallback, type ObjwalkObject$1 as ObjwalkObject, type ParseOptions, type PickOptions, type StringifyOptions, type WalkKey, clone, each, equally, extract, flush, map, merge, parse, pick, set, stringify };
+export { type DiffOperation, type EachCallback, type EachEntry, type EachOptions, type ExtractMapping, type MapCallback, type ObjwalkObject$1 as ObjwalkObject, type ParseOptions, type PickOptions, type StringifyOptions, type WalkKey, clone, diff, each, equally, extract, flush, map, merge, parse, pick, set, stringify };