objwalk 1.6.0 → 1.8.0

package/dist/index.cjs

@@ -51,20 +51,18 @@ var isWalkable = (value) => {
 // src/each.ts
 var each = (data, callback, { root = false, descend } = {}) => {
   const walk = (value, path, segments, key) => {
-    if (segments.length > 0 || root) {
-      callback(key, value, path, [...segments]);
-    }
-    if (isWalkable(value) && (descend === void 0 || descend({ key, value, path, segments: [...segments] }))) {
+    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)) {
-        value.forEach((item, index) => {
-          walk(item, createPath(path, index, true), [...segments, index], index);
-        });
-      } else {
-        Object.entries(value).forEach(([childKey, item]) => {
-          walk(item, createPath(path, childKey, false), [...segments, childKey], childKey);
-        });
+        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);
 };
@@ -213,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));
@@ -227,14 +225,6 @@ var extract = (source, mapping) => {
   return result;
 };
 
-// src/map.ts
-var map = (data, callback, store = {}) => {
-  each(data, (key, value, path) => {
-    callback(key, value, store, path);
-  });
-  return store;
-};
-
 // src/helpers/isPlainObject.ts
 var isPlainObject = (value) => {
   if (value !== null && typeof value === "object") {
@@ -244,119 +234,136 @@ var isPlainObject = (value) => {
   return false;
 };
 
+// src/map.ts
+var map = (data, callback, { descend, shallow = false } = {}) => {
+  const walk = (value, key, path, segments) => {
+    const root = key === void 0;
+    let mapped = root ? Array.isArray(value) ? [] : {} : value;
+    if ((root || Array.isArray(value) || isPlainObject(value)) && (root || shallow === false) && (descend === void 0 || descend({ key, value, path, segments: [...segments] }))) {
+      mapped = Array.isArray(value) ? Array(value.length) : {};
+      each(value, (key2, value2) => {
+        const childPath = createPath(path, key2, Array.isArray(mapped));
+        const childSegments = [...segments, key2];
+        const result = walk(value2, key2, childPath, childSegments);
+        Object.defineProperty(mapped, key2, {
+          value: result,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }, { descend: ({ segments: segments2 }) => segments2.length === 0 });
+    }
+    return key !== void 0 ? callback(key, mapped, path) : mapped;
+  };
+  return walk(data, void 0, "", []);
+};
+
 // 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)) {
-    return true;
-  }
-  if (x === y) {
+  if (x === y || Number.isNaN(x) && Number.isNaN(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);
-  }
-  return equalObjects(x, y, store);
-};
-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;
-  }
-  return keysX.every((key) => {
-    if (!Object.hasOwn(y, key)) {
-      return false;
+  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;
     }
-    return deepEqual(x[key], y[key], store);
-  });
+    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 false;
 };
 
 // src/equally.ts
-var equally = (a, b) => deepEqual(a, b, /* @__PURE__ */ new WeakMap());
+var equally = (a, b, paths) => {
+  if (paths !== void 0) {
+    return paths.every((path) => equally(getValueByPath(a, path), getValueByPath(b, path)));
+  }
+  return deepEqual(a, b, /* @__PURE__ */ new WeakMap());
+};
 
 // src/diff.ts
 var diff = (first, last) => {
   const operations = [];
   const frames = [];
   const finish = (depth) => {
-    for (const { first: first2, last: last2, path } of frames.splice(depth).reverse()) {
-      for (const key of Object.keys(first2)) {
+    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;
@@ -407,9 +414,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);

package/dist/index.d.cts

@@ -23,7 +23,7 @@ type StringifyOptions = {
     space?: string | number;
 };
 
-type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => void;
+type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => unknown;
 type EachEntry = {
     key: WalkKey | undefined;
     value: any;
@@ -48,17 +48,32 @@ declare const pick: (data?: ObjwalkObject$1, path?: string, options?: PickOption
 type ExtractMapping = Record<string, string | string[]>;
 declare const extract: (source: ObjwalkObject$1, mapping: ExtractMapping) => ObjwalkObject$1;
 
-type MapCallback<TStore extends Record<string, any> = Record<string, any>> = (key: WalkKey, value: any, store: TStore, path: string) => void;
-declare const map: <TStore extends Record<string, any> = Record<string, any>>(data: any, callback: MapCallback<TStore>, store?: TStore) => TStore;
+type MapCallback<TResult = unknown, TKey extends WalkKey = WalkKey> = (key: TKey, value: any, path: string) => TResult;
+type MapOptions = {
+    descend?: EachOptions['descend'];
+    shallow?: boolean;
+};
+type Map = {
+    <TResult>(data: readonly unknown[], callback: MapCallback<TResult, number>, options: MapOptions & {
+        shallow: true;
+    }): TResult[];
+    <TResult>(data: Record<string, unknown>, callback: MapCallback<TResult, string>, options: MapOptions & {
+        shallow: true;
+    }): Record<string, TResult>;
+    <TResult>(data: readonly unknown[], callback: MapCallback<TResult>, options?: MapOptions): TResult[];
+    <TResult>(data: Record<string, unknown>, callback: MapCallback<TResult>, options?: MapOptions): Record<string, TResult>;
+    <TResult>(data: Record<string, unknown> | readonly unknown[], callback: MapCallback<TResult>, options?: MapOptions): Record<string, TResult> | TResult[];
+};
+declare const map: Map;
 
 declare const merge: <T extends ObjwalkObject$1>(target: T, ...sources: unknown[]) => T;
 
 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) => boolean;
+declare const equally: (a: unknown, b: unknown, paths?: string[]) => boolean;
 
 declare const diff: (first: unknown, last: unknown) => DiffOperation[];
 
@@ -68,4 +83,4 @@ declare const parse: (raw: unknown, { fallback, onError, reviver }?: ParseOption
 
 declare const stringify: (value: unknown, { fallback, onError, replacer, space }?: StringifyOptions) => string | undefined;
 
-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 };
+export { type DiffOperation, type EachCallback, type EachEntry, type EachOptions, type ExtractMapping, type MapCallback, type MapOptions, 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

@@ -23,7 +23,7 @@ type StringifyOptions = {
     space?: string | number;
 };
 
-type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => void;
+type EachCallback<TKey extends WalkKey | undefined = WalkKey> = (key: TKey, value: any, path: string, segments: WalkKey[]) => unknown;
 type EachEntry = {
     key: WalkKey | undefined;
     value: any;
@@ -48,17 +48,32 @@ declare const pick: (data?: ObjwalkObject$1, path?: string, options?: PickOption
 type ExtractMapping = Record<string, string | string[]>;
 declare const extract: (source: ObjwalkObject$1, mapping: ExtractMapping) => ObjwalkObject$1;
 
-type MapCallback<TStore extends Record<string, any> = Record<string, any>> = (key: WalkKey, value: any, store: TStore, path: string) => void;
-declare const map: <TStore extends Record<string, any> = Record<string, any>>(data: any, callback: MapCallback<TStore>, store?: TStore) => TStore;
+type MapCallback<TResult = unknown, TKey extends WalkKey = WalkKey> = (key: TKey, value: any, path: string) => TResult;
+type MapOptions = {
+    descend?: EachOptions['descend'];
+    shallow?: boolean;
+};
+type Map = {
+    <TResult>(data: readonly unknown[], callback: MapCallback<TResult, number>, options: MapOptions & {
+        shallow: true;
+    }): TResult[];
+    <TResult>(data: Record<string, unknown>, callback: MapCallback<TResult, string>, options: MapOptions & {
+        shallow: true;
+    }): Record<string, TResult>;
+    <TResult>(data: readonly unknown[], callback: MapCallback<TResult>, options?: MapOptions): TResult[];
+    <TResult>(data: Record<string, unknown>, callback: MapCallback<TResult>, options?: MapOptions): Record<string, TResult>;
+    <TResult>(data: Record<string, unknown> | readonly unknown[], callback: MapCallback<TResult>, options?: MapOptions): Record<string, TResult> | TResult[];
+};
+declare const map: Map;
 
 declare const merge: <T extends ObjwalkObject$1>(target: T, ...sources: unknown[]) => T;
 
 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) => boolean;
+declare const equally: (a: unknown, b: unknown, paths?: string[]) => boolean;
 
 declare const diff: (first: unknown, last: unknown) => DiffOperation[];
 
@@ -68,4 +83,4 @@ declare const parse: (raw: unknown, { fallback, onError, reviver }?: ParseOption
 
 declare const stringify: (value: unknown, { fallback, onError, replacer, space }?: StringifyOptions) => string | undefined;
 
-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 };
+export { type DiffOperation, type EachCallback, type EachEntry, type EachOptions, type ExtractMapping, type MapCallback, type MapOptions, 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 };