@ls-stack/utils 2.0.0 → 2.1.0

package/dist/arrayUtils.cjs

@@ -23,6 +23,8 @@ __export(arrayUtils_exports, {
   arrayWithPrev: () => arrayWithPrev,
   arrayWithPrevAndIndex: () => arrayWithPrevAndIndex,
   filterAndMap: () => filterAndMap,
+  findAfterIndex: () => findAfterIndex,
+  findBeforeIndex: () => findBeforeIndex,
   isInArray: () => isInArray,
   sortBy: () => sortBy
 });
@@ -81,11 +83,33 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function findAfterIndex(array, index, predicate) {
+  for (let i = index + 1; i < array.length; i++) {
+    if (predicate(array[i])) {
+      return array[i];
+    }
+  }
+  return void 0;
+}
+function findBeforeIndex(array, index, predicate) {
+  let indexToUse = index;
+  if (indexToUse >= array.length) {
+    indexToUse = array.length;
+  }
+  for (let i = indexToUse - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      return array[i];
+    }
+  }
+  return void 0;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
+  findAfterIndex,
+  findBeforeIndex,
   isInArray,
   sortBy
 });

package/dist/arrayUtils.d.cts

@@ -47,5 +47,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
+declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, isInArray, sortBy };
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, sortBy };

package/dist/arrayUtils.d.ts

@@ -47,5 +47,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
+declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, isInArray, sortBy };
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, sortBy };

package/dist/arrayUtils.js

@@ -2,13 +2,17 @@ import {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
+  findAfterIndex,
+  findBeforeIndex,
   isInArray,
   sortBy
-} from "./chunk-AZBBTE33.js";
+} from "./chunk-QMFZE2VO.js";
 export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
+  findAfterIndex,
+  findBeforeIndex,
   isInArray,
   sortBy
 };

package/dist/{chunk-JOBPQAI3.js → chunk-3PXKYWJF.js}

@@ -6,6 +6,21 @@ import {
 function okUnwrapOr() {
   return this.value;
 }
+function okMap(mapFn) {
+  return this.ok ? ok(mapFn(this.value)) : this;
+}
+function errMap(mapFn) {
+  return this.ok ? this : err(mapFn(this.error));
+}
+function mapOkAndErr({
+  ok: mapFn,
+  err: mapErrFn
+}) {
+  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
+}
+function returnResult() {
+  return this;
+}
 function ok(value = void 0) {
   return {
     ok: true,
@@ -13,7 +28,10 @@ function ok(value = void 0) {
     value,
     unwrapOrNull: okUnwrapOr,
     unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr
   };
 }
 function err(error) {
@@ -29,25 +47,25 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      if (Array.isArray(error)) {
-        throw new Error(error.join("\n"), { cause: error });
-      }
-      throw new Error(
-        isObject(error) && "message" in error && error.message ? String(error.message) : "Unwrap failed",
-        { cause: error }
-      );
-    }
+      throw normalizeError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr
   };
 }
 function unknownToError(error) {
   return err(normalizeError(error));
 }
-async function unwrap(result) {
+async function asyncUnwrap(result) {
   const unwrapped = await result;
   if (unwrapped.ok) {
     return unwrapped.value;
   }
-  throw unwrapped.error;
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw normalizeError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -68,29 +86,12 @@ function asyncMap(resultPromise) {
     }
   };
 }
-function syncMap(result) {
-  return {
-    err: (mapFn) => {
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: (mapFn) => {
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
 var Result = {
   ok,
   err,
   unknownToError,
-  unwrap,
-  asyncMap,
-  map: syncMap
+  asyncUnwrap,
+  asyncMap
 };
 function resultify(fn, errorNormalizer) {
   try {
@@ -117,7 +118,7 @@ function normalizeError(error) {
   }
   if (isObject(error)) {
     return new Error(
-      "message" in error && error.message ? String(error.message) : safeJsonStringify(error) ?? "unknown",
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
       { cause: error }
     );
   }

package/dist/{chunk-KCOXGSRA.js → chunk-JQFUKJU5.js}

@@ -1,19 +1,21 @@
 // src/deepEqual.ts
 var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, key) {
-  for (key of iter.keys()) {
-    if (deepEqual(key, tar)) return key;
+function find(iter, tar, maxDepth) {
+  for (const key of iter.keys()) {
+    if (deepEqual(key, tar, maxDepth)) return key;
   }
 }
-function deepEqual(foo, bar) {
+function deepEqual(foo, bar, maxDepth = 20) {
   let ctor, len, tmp;
   if (foo === bar) return true;
+  if (maxDepth && maxDepth <= 0) return false;
   if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime());
+    if (ctor === Date)
+      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
     if (ctor === RegExp) return foo.toString() === bar.toString();
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len])) ;
+        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
       }
       return len === -1;
     }
@@ -24,7 +26,7 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len;
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
         if (!bar.has(tmp)) return false;
@@ -38,10 +40,10 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len[0];
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
-        if (!deepEqual(len[1], bar.get(tmp))) {
+        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
           return false;
         }
       }
@@ -51,14 +53,19 @@ function deepEqual(foo, bar) {
       len = 0;
       for (ctor in foo) {
         if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
+          return false;
       }
       return Object.keys(bar).length === len;
     }
   }
   return foo !== foo && bar !== bar;
 }
+function deepEqualWithMaxDepth(maxDepth) {
+  return (foo, bar) => deepEqual(foo, bar, maxDepth);
+}
 
 export {
-  deepEqual
+  deepEqual,
+  deepEqualWithMaxDepth
 };

package/dist/{chunk-AZBBTE33.js → chunk-QMFZE2VO.js}

@@ -53,11 +53,33 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function findAfterIndex(array, index, predicate) {
+  for (let i = index + 1; i < array.length; i++) {
+    if (predicate(array[i])) {
+      return array[i];
+    }
+  }
+  return void 0;
+}
+function findBeforeIndex(array, index, predicate) {
+  let indexToUse = index;
+  if (indexToUse >= array.length) {
+    indexToUse = array.length;
+  }
+  for (let i = indexToUse - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      return array[i];
+    }
+  }
+  return void 0;
+}
 
 export {
   filterAndMap,
   sortBy,
   arrayWithPrev,
   arrayWithPrevAndIndex,
-  isInArray
+  isInArray,
+  findAfterIndex,
+  findBeforeIndex
 };

package/dist/deepEqual.cjs

@@ -20,24 +20,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/deepEqual.ts
 var deepEqual_exports = {};
 __export(deepEqual_exports, {
-  deepEqual: () => deepEqual
+  deepEqual: () => deepEqual,
+  deepEqualWithMaxDepth: () => deepEqualWithMaxDepth
 });
 module.exports = __toCommonJS(deepEqual_exports);
 var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, key) {
-  for (key of iter.keys()) {
-    if (deepEqual(key, tar)) return key;
+function find(iter, tar, maxDepth) {
+  for (const key of iter.keys()) {
+    if (deepEqual(key, tar, maxDepth)) return key;
   }
 }
-function deepEqual(foo, bar) {
+function deepEqual(foo, bar, maxDepth = 20) {
   let ctor, len, tmp;
   if (foo === bar) return true;
+  if (maxDepth && maxDepth <= 0) return false;
   if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime());
+    if (ctor === Date)
+      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
     if (ctor === RegExp) return foo.toString() === bar.toString();
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len])) ;
+        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
       }
       return len === -1;
     }
@@ -48,7 +51,7 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len;
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
         if (!bar.has(tmp)) return false;
@@ -62,10 +65,10 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len[0];
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
-        if (!deepEqual(len[1], bar.get(tmp))) {
+        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
           return false;
         }
       }
@@ -75,14 +78,19 @@ function deepEqual(foo, bar) {
       len = 0;
       for (ctor in foo) {
         if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
+          return false;
       }
       return Object.keys(bar).length === len;
     }
   }
   return foo !== foo && bar !== bar;
 }
+function deepEqualWithMaxDepth(maxDepth) {
+  return (foo, bar) => deepEqual(foo, bar, maxDepth);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  deepEqual
+  deepEqual,
+  deepEqualWithMaxDepth
 });

package/dist/deepEqual.d.cts

@@ -1,4 +1,20 @@
-/** forked from https://github.com/lukeed/dequal to consider invalid dates as equal */
-declare function deepEqual(foo: any, bar: any): boolean;
+/**
+ * Deep equality comparison between two values
+ * @param foo First value to compare
+ * @param bar Second value to compare
+ * @param maxDepth Maximum comparison depth (default: 20)
+ * @returns True if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```ts
+ * deepEqual({a: 1}, {a: 1}) // true
+ * deepEqual({a: 1}, {a: 2}) // false
+ * deepEqual([1, {b: 2}], [1, {b: 2}]) // true
+ * deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
+ * deepEqual(new Set([1, 2]), new Set([1, 2])) // true
+ * ```
+ */
+declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
+declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;
 
-export { deepEqual };
+export { deepEqual, deepEqualWithMaxDepth };

package/dist/deepEqual.d.ts

@@ -1,4 +1,20 @@
-/** forked from https://github.com/lukeed/dequal to consider invalid dates as equal */
-declare function deepEqual(foo: any, bar: any): boolean;
+/**
+ * Deep equality comparison between two values
+ * @param foo First value to compare
+ * @param bar Second value to compare
+ * @param maxDepth Maximum comparison depth (default: 20)
+ * @returns True if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```ts
+ * deepEqual({a: 1}, {a: 1}) // true
+ * deepEqual({a: 1}, {a: 2}) // false
+ * deepEqual([1, {b: 2}], [1, {b: 2}]) // true
+ * deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
+ * deepEqual(new Set([1, 2]), new Set([1, 2])) // true
+ * ```
+ */
+declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
+declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;
 
-export { deepEqual };
+export { deepEqual, deepEqualWithMaxDepth };

package/dist/deepEqual.js

@@ -1,6 +1,8 @@
 import {
-  deepEqual
-} from "./chunk-KCOXGSRA.js";
+  deepEqual,
+  deepEqualWithMaxDepth
+} from "./chunk-JQFUKJU5.js";
 export {
-  deepEqual
+  deepEqual,
+  deepEqualWithMaxDepth
 };

package/dist/parallelAsyncCalls.cjs

@@ -38,6 +38,21 @@ function isObject(value) {
 function okUnwrapOr() {
   return this.value;
 }
+function okMap(mapFn) {
+  return this.ok ? ok(mapFn(this.value)) : this;
+}
+function errMap(mapFn) {
+  return this.ok ? this : err(mapFn(this.error));
+}
+function mapOkAndErr({
+  ok: mapFn,
+  err: mapErrFn
+}) {
+  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
+}
+function returnResult() {
+  return this;
+}
 function ok(value = void 0) {
   return {
     ok: true,
@@ -45,7 +60,10 @@ function ok(value = void 0) {
     value,
     unwrapOrNull: okUnwrapOr,
     unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr
   };
 }
 function err(error) {
@@ -61,25 +79,25 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      if (Array.isArray(error)) {
-        throw new Error(error.join("\n"), { cause: error });
-      }
-      throw new Error(
-        isObject(error) && "message" in error && error.message ? String(error.message) : "Unwrap failed",
-        { cause: error }
-      );
-    }
+      throw normalizeError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr
   };
 }
 function unknownToError(error) {
   return err(normalizeError(error));
 }
-async function unwrap(result) {
+async function asyncUnwrap(result) {
   const unwrapped = await result;
   if (unwrapped.ok) {
     return unwrapped.value;
   }
-  throw unwrapped.error;
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw normalizeError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -100,29 +118,12 @@ function asyncMap(resultPromise) {
     }
   };
 }
-function syncMap(result) {
-  return {
-    err: (mapFn) => {
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: (mapFn) => {
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
 var Result = {
   ok,
   err,
   unknownToError,
-  unwrap,
-  asyncMap,
-  map: syncMap
+  asyncUnwrap,
+  asyncMap
 };
 function normalizeError(error) {
   if (error instanceof Error) return error;
@@ -131,7 +132,7 @@ function normalizeError(error) {
   }
   if (isObject(error)) {
     return new Error(
-      "message" in error && error.message ? String(error.message) : safeJsonStringify(error) ?? "unknown",
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
       { cause: error }
     );
   }

package/dist/parallelAsyncCalls.js

@@ -1,7 +1,7 @@
 import {
   Result,
   normalizeError
-} from "./chunk-JOBPQAI3.js";
+} from "./chunk-3PXKYWJF.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";

package/dist/rsResult.cjs

@@ -38,6 +38,21 @@ function isObject(value) {
 function okUnwrapOr() {
   return this.value;
 }
+function okMap(mapFn) {
+  return this.ok ? ok(mapFn(this.value)) : this;
+}
+function errMap(mapFn) {
+  return this.ok ? this : err(mapFn(this.error));
+}
+function mapOkAndErr({
+  ok: mapFn,
+  err: mapErrFn
+}) {
+  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
+}
+function returnResult() {
+  return this;
+}
 function ok(value = void 0) {
   return {
     ok: true,
@@ -45,7 +60,10 @@ function ok(value = void 0) {
     value,
     unwrapOrNull: okUnwrapOr,
     unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr
   };
 }
 function err(error) {
@@ -61,25 +79,25 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      if (Array.isArray(error)) {
-        throw new Error(error.join("\n"), { cause: error });
-      }
-      throw new Error(
-        isObject(error) && "message" in error && error.message ? String(error.message) : "Unwrap failed",
-        { cause: error }
-      );
-    }
+      throw normalizeError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr
   };
 }
 function unknownToError(error) {
   return err(normalizeError(error));
 }
-async function unwrap(result) {
+async function asyncUnwrap(result) {
   const unwrapped = await result;
   if (unwrapped.ok) {
     return unwrapped.value;
   }
-  throw unwrapped.error;
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw normalizeError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -100,29 +118,12 @@ function asyncMap(resultPromise) {
     }
   };
 }
-function syncMap(result) {
-  return {
-    err: (mapFn) => {
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: (mapFn) => {
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
 var Result = {
   ok,
   err,
   unknownToError,
-  unwrap,
-  asyncMap,
-  map: syncMap
+  asyncUnwrap,
+  asyncMap
 };
 function resultify(fn, errorNormalizer) {
   try {
@@ -149,7 +150,7 @@ function normalizeError(error) {
   }
   if (isObject(error)) {
     return new Error(
-      "message" in error && error.message ? String(error.message) : safeJsonStringify(error) ?? "unknown",
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
       { cause: error }
     );
   }

package/dist/rsResult.d.cts

@@ -3,20 +3,24 @@ type Ok<T> = {
     error: false;
     value: T;
 };
-type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
     errorResult: () => Result<any, E>;
 };
-type Unwrap<E, T> = IsExactlyAny<E> extends true ? any : E extends Error ? () => T : unknown;
-type ResultMethods<T, E> = {
+type ResultMethods<T, E extends ResultValidErrors> = {
     /** Returns the value if the result is Ok, otherwise returns null */
     unwrapOrNull: () => T | null;
     /** Returns the value if the result is Ok, otherwise returns the provided default value */
     unwrapOr: <R extends T>(defaultValue: R) => T | R;
-    unwrap: Unwrap<E, T>;
+    unwrap: () => T;
+    mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Result<NewValue, NewError>;
 };
 type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
 declare function ok(): OkResult<void, any>;
@@ -25,7 +29,7 @@ type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T,
 declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
 declare function unknownToError(error: unknown): ErrResult<Error, any>;
 /** Unwraps a promise result */
-declare function unwrap<T>(result: Promise<Result<T, Error>>): Promise<T>;
+declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
     err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Promise<Result<T, NewError>>;
     ok: <NewValue>(mapFn: (value: T) => NewValue) => Promise<Result<NewValue, E>>;
@@ -34,14 +38,6 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
         err: (error: E) => NewError;
     }) => Promise<Result<NewValue, NewError>>;
 };
-declare function syncMap<T, E extends ResultValidErrors>(result: Result<T, E>): {
-    err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
-    ok: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
-    okAndErr: <NewValue, NewError extends ResultValidErrors>({ ok: mapFn, err: mapErrFn, }: {
-        ok: (value: T) => NewValue;
-        err: (error: E) => NewError;
-    }) => Result<NewValue, NewError>;
-};
 /**
  * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
  *
@@ -69,9 +65,8 @@ declare const Result: {
     ok: typeof ok;
     err: typeof err;
     unknownToError: typeof unknownToError;
-    unwrap: typeof unwrap;
+    asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
-    map: typeof syncMap;
 };
 /** transform a function in a result function */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;

package/dist/rsResult.d.ts

@@ -3,20 +3,24 @@ type Ok<T> = {
     error: false;
     value: T;
 };
-type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
     errorResult: () => Result<any, E>;
 };
-type Unwrap<E, T> = IsExactlyAny<E> extends true ? any : E extends Error ? () => T : unknown;
-type ResultMethods<T, E> = {
+type ResultMethods<T, E extends ResultValidErrors> = {
     /** Returns the value if the result is Ok, otherwise returns null */
     unwrapOrNull: () => T | null;
     /** Returns the value if the result is Ok, otherwise returns the provided default value */
     unwrapOr: <R extends T>(defaultValue: R) => T | R;
-    unwrap: Unwrap<E, T>;
+    unwrap: () => T;
+    mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Result<NewValue, NewError>;
 };
 type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
 declare function ok(): OkResult<void, any>;
@@ -25,7 +29,7 @@ type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T,
 declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
 declare function unknownToError(error: unknown): ErrResult<Error, any>;
 /** Unwraps a promise result */
-declare function unwrap<T>(result: Promise<Result<T, Error>>): Promise<T>;
+declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
     err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Promise<Result<T, NewError>>;
     ok: <NewValue>(mapFn: (value: T) => NewValue) => Promise<Result<NewValue, E>>;
@@ -34,14 +38,6 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
         err: (error: E) => NewError;
     }) => Promise<Result<NewValue, NewError>>;
 };
-declare function syncMap<T, E extends ResultValidErrors>(result: Result<T, E>): {
-    err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
-    ok: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
-    okAndErr: <NewValue, NewError extends ResultValidErrors>({ ok: mapFn, err: mapErrFn, }: {
-        ok: (value: T) => NewValue;
-        err: (error: E) => NewError;
-    }) => Result<NewValue, NewError>;
-};
 /**
  * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
  *
@@ -69,9 +65,8 @@ declare const Result: {
     ok: typeof ok;
     err: typeof err;
     unknownToError: typeof unknownToError;
-    unwrap: typeof unwrap;
+    asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
-    map: typeof syncMap;
 };
 /** transform a function in a result function */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;

package/dist/rsResult.js

@@ -5,7 +5,7 @@ import {
   normalizeError,
   resultify,
   safeJsonStringify
-} from "./chunk-JOBPQAI3.js";
+} from "./chunk-3PXKYWJF.js";
 import "./chunk-4UGSP3L3.js";
 export {
   Result,

package/dist/testUtils.cjs

@@ -53,20 +53,22 @@ function isObject(value) {
 
 // src/deepEqual.ts
 var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, key) {
-  for (key of iter.keys()) {
-    if (deepEqual(key, tar)) return key;
+function find(iter, tar, maxDepth) {
+  for (const key of iter.keys()) {
+    if (deepEqual(key, tar, maxDepth)) return key;
   }
 }
-function deepEqual(foo, bar) {
+function deepEqual(foo, bar, maxDepth = 20) {
   let ctor, len, tmp;
   if (foo === bar) return true;
+  if (maxDepth && maxDepth <= 0) return false;
   if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime());
+    if (ctor === Date)
+      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
     if (ctor === RegExp) return foo.toString() === bar.toString();
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len])) ;
+        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
       }
       return len === -1;
     }
@@ -77,7 +79,7 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len;
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
         if (!bar.has(tmp)) return false;
@@ -91,10 +93,10 @@ function deepEqual(foo, bar) {
       for (len of foo) {
         tmp = len[0];
         if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp);
+          tmp = find(bar, tmp, maxDepth - 1);
           if (!tmp) return false;
         }
-        if (!deepEqual(len[1], bar.get(tmp))) {
+        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
           return false;
         }
       }
@@ -104,7 +106,8 @@ function deepEqual(foo, bar) {
       len = 0;
       for (ctor in foo) {
         if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
+          return false;
       }
       return Object.keys(bar).length === len;
     }

package/dist/testUtils.js

@@ -1,6 +1,6 @@
 import {
   deepEqual
-} from "./chunk-KCOXGSRA.js";
+} from "./chunk-JQFUKJU5.js";
 import {
   clampMin
 } from "./chunk-NWXBMMHO.js";
@@ -11,7 +11,7 @@ import {
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-AZBBTE33.js";
+} from "./chunk-QMFZE2VO.js";
 import {
   isObject
 } from "./chunk-4UGSP3L3.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "files": [
     "dist"
@@ -165,15 +165,17 @@
   },
   "devDependencies": {
     "@ls-stack/extended-lint": "^0.2.0",
+    "@types/eslint": "^9.6.1",
+    "@types/eslint__js": "^8.42.3",
     "@types/node": "^22.5.5",
     "@typescript-eslint/eslint-plugin": "^8.6.0",
     "@typescript-eslint/parser": "^8.6.0",
     "@vitest/ui": "^2.1.1",
+    "dequal": "^2.0.3",
     "eslint": "^9.10.0",
-    "@types/eslint": "^9.6.1",
-    "@types/eslint__js": "^8.42.3",
     "eslint-plugin-unicorn": "^55.0.0",
     "eslint-plugin-vitest": "^0.5.4",
+    "mitata": "^1.0.17",
     "prettier": "3.3.3",
     "prettier-plugin-organize-imports": "^4.0.0",
     "tsm": "^2.3.0",
@@ -283,6 +285,7 @@
     "build:update-exports": "tsm --no-warnings scripts/updatePackageExports.ts",
     "build-test": "tsup --config tsup.test.config.ts",
     "pre-publish": "./scripts/check-if-is-sync.sh && pnpm build",
-    "test:console-fmt": "tsm --no-warnings scripts/testConsoleFmt.ts"
+    "test:console-fmt": "tsm --no-warnings scripts/testConsoleFmt.ts",
+    "bench:deepEqual": "tsm --no-warnings benchmarks/deepEqual.ts"
   }
 }