@ls-stack/utils 3.3.2 → 3.5.0

package/lib/arrayUtils.cjs

@@ -26,6 +26,7 @@ __export(arrayUtils_exports, {
   findAfterIndex: () => findAfterIndex,
   findBeforeIndex: () => findBeforeIndex,
   isInArray: () => isInArray,
+  rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
   sortBy: () => sortBy
 });
 module.exports = __toCommonJS(arrayUtils_exports);
@@ -103,6 +104,9 @@ function findBeforeIndex(array, index, predicate) {
   }
   return void 0;
 }
+function rejectArrayUndefinedValues(array) {
+  return array.filter((item) => item !== void 0);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   arrayWithPrev,
@@ -111,5 +115,6 @@ function findBeforeIndex(array, index, predicate) {
   findAfterIndex,
   findBeforeIndex,
   isInArray,
+  rejectArrayUndefinedValues,
   sortBy
 });

package/lib/arrayUtils.d.cts

@@ -49,5 +49,6 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
 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;
+declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, sortBy };
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, rejectArrayUndefinedValues, sortBy };

package/lib/arrayUtils.d.ts

@@ -49,5 +49,6 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
 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;
+declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, sortBy };
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findBeforeIndex, isInArray, rejectArrayUndefinedValues, sortBy };

package/lib/arrayUtils.js

@@ -5,8 +5,9 @@ import {
   findAfterIndex,
   findBeforeIndex,
   isInArray,
+  rejectArrayUndefinedValues,
   sortBy
-} from "./chunk-QMFZE2VO.js";
+} from "./chunk-5JQGMNNY.js";
 export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
@@ -14,5 +15,6 @@ export {
   findAfterIndex,
   findBeforeIndex,
   isInArray,
+  rejectArrayUndefinedValues,
   sortBy
 };

package/lib/{chunk-QMFZE2VO.js → chunk-5JQGMNNY.js}

@@ -73,6 +73,9 @@ function findBeforeIndex(array, index, predicate) {
   }
   return void 0;
 }
+function rejectArrayUndefinedValues(array) {
+  return array.filter((item) => item !== void 0);
+}
 
 export {
   filterAndMap,
@@ -81,5 +84,6 @@ export {
   arrayWithPrevAndIndex,
   isInArray,
   findAfterIndex,
-  findBeforeIndex
+  findBeforeIndex,
+  rejectArrayUndefinedValues
 };

package/lib/{chunk-ZE3DLPMN.js → chunk-MWND73GM.js}

@@ -32,6 +32,15 @@ function omit(obj, keys) {
 function looseGetObjectProperty(obj, key) {
   return obj[key];
 }
+function rejectObjUndefinedValues(obj) {
+  const result = {};
+  for (const key in obj) {
+    if (obj[key] !== void 0) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
 
 export {
   objectTypedEntries,
@@ -39,5 +48,6 @@ export {
   mapArrayToObject,
   mapObjectToObject,
   omit,
-  looseGetObjectProperty
+  looseGetObjectProperty,
+  rejectObjUndefinedValues
 };

package/lib/objUtils.cjs

@@ -25,7 +25,8 @@ __export(objUtils_exports, {
   mapObjectToObject: () => mapObjectToObject,
   objectTypedEntries: () => objectTypedEntries,
   omit: () => omit,
-  pick: () => pick
+  pick: () => pick,
+  rejectObjUndefinedValues: () => rejectObjUndefinedValues
 });
 module.exports = __toCommonJS(objUtils_exports);
 function objectTypedEntries(obj) {
@@ -61,6 +62,15 @@ function omit(obj, keys) {
 function looseGetObjectProperty(obj, key) {
   return obj[key];
 }
+function rejectObjUndefinedValues(obj) {
+  const result = {};
+  for (const key in obj) {
+    if (obj[key] !== void 0) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   looseGetObjectProperty,
@@ -68,5 +78,6 @@ function looseGetObjectProperty(obj, key) {
   mapObjectToObject,
   objectTypedEntries,
   omit,
-  pick
+  pick,
+  rejectObjUndefinedValues
 });

package/lib/objUtils.d.cts

@@ -4,5 +4,6 @@ declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (i
 declare function mapObjectToObject<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
 declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 declare function looseGetObjectProperty<T extends Record<string, unknown>>(obj: T, key: string): T[keyof T] | undefined;
+declare function rejectObjUndefinedValues<T extends Record<string, unknown>>(obj: T): T;
 
-export { looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick };
+export { looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues };

package/lib/objUtils.d.ts

@@ -4,5 +4,6 @@ declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (i
 declare function mapObjectToObject<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
 declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 declare function looseGetObjectProperty<T extends Record<string, unknown>>(obj: T, key: string): T[keyof T] | undefined;
+declare function rejectObjUndefinedValues<T extends Record<string, unknown>>(obj: T): T;
 
-export { looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick };
+export { looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues };

package/lib/objUtils.js

@@ -4,13 +4,15 @@ import {
   mapObjectToObject,
   objectTypedEntries,
   omit,
-  pick
-} from "./chunk-ZE3DLPMN.js";
+  pick,
+  rejectObjUndefinedValues
+} from "./chunk-MWND73GM.js";
 export {
   looseGetObjectProperty,
   mapArrayToObject,
   mapObjectToObject,
   objectTypedEntries,
   omit,
-  pick
+  pick,
+  rejectObjUndefinedValues
 };

package/lib/parallelAsyncCalls.cjs

@@ -23,6 +23,7 @@ __export(parallelAsyncCalls_exports, {
   parallelAsyncCalls: () => parallelAsyncCalls
 });
 module.exports = __toCommonJS(parallelAsyncCalls_exports);
+var import_t_result = require("t-result");
 
 // src/assertions.ts
 function invariant(condition, errorMsg = "Invariant violation") {
@@ -39,155 +40,6 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/safeJson.ts
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return void 0;
-  }
-}
-
-// src/tsResult.ts
-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 okOnOk(fn) {
-  if (this.ok) {
-    fn(this.value);
-  }
-  return this;
-}
-function errOnErr(fn) {
-  if (!this.ok) {
-    fn(this.error);
-  }
-  return this;
-}
-function ok(value = void 0) {
-  const methods = {
-    unwrapOrNull: okUnwrapOr,
-    unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr,
-    mapOk: okMap,
-    mapErr: returnResult,
-    mapOkAndErr,
-    ifOk: okOnOk,
-    ifErr: returnResult
-  };
-  return {
-    ok: true,
-    error: false,
-    value,
-    ...methods
-  };
-}
-function err(error) {
-  const methods = {
-    unwrapOrNull: () => null,
-    unwrapOr: (defaultValue) => defaultValue,
-    unwrap: () => {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw unknownToError(error);
-    },
-    mapOk: returnResult,
-    mapErr: errMap,
-    mapOkAndErr,
-    ifOk: returnResult,
-    ifErr: errOnErr
-  };
-  return {
-    ok: false,
-    error,
-    errorResult() {
-      return err(error);
-    },
-    ...methods
-  };
-}
-function unknownToResultError(error) {
-  return err(unknownToError(error));
-}
-async function asyncUnwrap(result) {
-  const unwrapped = await result;
-  if (unwrapped.ok) {
-    return unwrapped.value;
-  }
-  if (unwrapped.error instanceof Error) {
-    throw unwrapped.error;
-  }
-  throw unknownToError(unwrapped.error);
-}
-function asyncMap(resultPromise) {
-  return {
-    err: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: async ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
-var Result = {
-  ok,
-  err,
-  unknownToError: unknownToResultError,
-  asyncUnwrap,
-  asyncMap,
-  getOkErr
-};
-function unknownToError(error) {
-  if (error instanceof Error) return error;
-  if (typeof error === "string") {
-    return new Error(error);
-  }
-  if (isObject(error)) {
-    return new Error(
-      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
-      { cause: error }
-    );
-  }
-  return new Error(safeJsonStringify(error) ?? "unknown", {
-    cause: error
-  });
-}
-var typedResult = {
-  ok,
-  err,
-  get _type() {
-    throw new Error("usage as value is not allowed");
-  }
-};
-function getOkErr() {
-  return typedResult;
-}
-
 // src/parallelAsyncCalls.ts
 var ParallelAsyncResultCalls = class {
   pendingCalls = [];
@@ -224,7 +76,7 @@ var ParallelAsyncResultCalls = class {
           return { result, callMetadata: call.metadata };
         } catch (exception) {
           return {
-            result: Result.unknownToError(exception),
+            result: import_t_result.Result.unknownToError(exception),
             callMetadata: call.metadata
           };
         }
@@ -278,14 +130,14 @@ var ParallelAsyncResultCalls = class {
           } catch (exception) {
             throw {
               metadata: call.metadata,
-              error: unknownToError(exception)
+              error: (0, import_t_result.unknownToError)(exception)
             };
           }
         })
       );
-      return Result.ok(asyncResults);
+      return import_t_result.Result.ok(asyncResults);
     } catch (exception) {
-      return Result.err(
+      return import_t_result.Result.err(
         exception
       );
     } finally {

package/lib/parallelAsyncCalls.d.cts

@@ -1,4 +1,4 @@
-import { Result } from './tsResult.cjs';
+import { Result } from 't-result';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/lib/parallelAsyncCalls.d.ts

@@ -1,4 +1,4 @@
-import { Result } from './tsResult.js';
+import { Result } from 't-result';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/lib/parallelAsyncCalls.js

@@ -1,17 +1,13 @@
-import {
-  Result,
-  unknownToError
-} from "./chunk-J73KJABC.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
-import "./chunk-VAAMRG4K.js";
 import {
   invariant,
   isObject
 } from "./chunk-3XCS7FVO.js";
 
 // src/parallelAsyncCalls.ts
+import { Result, unknownToError } from "t-result";
 var ParallelAsyncResultCalls = class {
   pendingCalls = [];
   alreadyRun = false;

package/lib/testUtils.js

@@ -1,14 +1,14 @@
 import {
   omit,
   pick
-} from "./chunk-ZE3DLPMN.js";
+} from "./chunk-MWND73GM.js";
 import {
   deepEqual
 } from "./chunk-JQFUKJU5.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-QMFZE2VO.js";
+} from "./chunk-5JQGMNNY.js";
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";

package/lib/tsResult.d.cts

@@ -4,30 +4,41 @@ type Ok<T> = {
     value: T;
 } & AnyResultMethods;
 type AnyResultMethods = Record<ResultMethodsKeys, never>;
+/** @deprecated Use `t-result` library instead. */
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | readonly unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
-    errorResult: () => Result<any, E>;
+    /** @deprecated Use `t-result` library instead. */
+    errorResult: () => Err<E>;
 } & AnyResultMethods;
 type ResultMethods<T, E extends ResultValidErrors> = {
-    /** Returns the value if the result is Ok, otherwise returns null */
+    /** @deprecated Use `t-result` library instead. */
     unwrapOrNull: () => T | null;
-    /** Returns the value if the result is Ok, otherwise returns the provided default value */
+    /** @deprecated Use `t-result` library instead. */
     unwrapOr: <R extends T>(defaultValue: R) => T | R;
+    /** @deprecated Use `t-result` library instead. */
     unwrap: () => T;
+    /** @deprecated Use `t-result` library instead. */
     mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    /** @deprecated Use `t-result` library instead. */
     mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    /** @deprecated Use `t-result` library instead. */
     mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
         ok: (value: T) => NewValue;
         err: (error: E) => NewError;
     }) => Result<NewValue, NewError>;
+    /** @deprecated Use `t-result` library instead. */
     ifOk: (fn: (value: T) => void) => Result<T, E>;
+    /** @deprecated Use `t-result` library instead. */
     ifErr: (fn: (error: E) => void) => Result<T, E>;
 };
 type ResultMethodsKeys = keyof ResultMethods<any, any>;
+/** @deprecated Use `t-result` library instead. */
 declare function ok(): Ok<void>;
+/** @deprecated Use `t-result` library instead. */
 declare function ok<T>(value: T): Ok<T>;
+/** @deprecated Use `t-result` library instead. */
 declare function err<E extends ResultValidErrors>(error: E): Err<E>;
 declare function unknownToResultError(error: unknown): Err<Error>;
 /** Unwraps a promise result */
@@ -40,29 +51,9 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
         err: (error: E) => NewError;
     }) => Promise<Result<NewValue, NewError>>;
 };
-/**
- * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
- *
- * Usage:
- *
- * @example
- * function doSomething(): Result<string, Error> {
- *  if (something) {
- *    return ok('success');
- *  }
- *
- *  return err(new Error('something went wrong'));
- * }
- *
- * const result = doSomething();
- *
- * if (result.ok) {
- *   // result.value is a string
- * } else {
- *   // result.error is an Error
- * }
- */
+/** @deprecated Use `t-result` library instead. */
 type Result<T, E extends ResultValidErrors = Error> = (Omit<Ok<T>, ResultMethodsKeys> | Omit<Err<E>, ResultMethodsKeys>) & ResultMethods<T, E>;
+/** @deprecated Use `t-result` library instead. */
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
@@ -71,46 +62,24 @@ declare const Result: {
     asyncMap: typeof asyncMap;
     getOkErr: typeof getOkErr;
 };
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T extends Promise<any> ? never : T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<T, E>>;
-/**
- * Converts an unknown error value into an Error object.
- *
- * @param error - The unknown value to convert to an Error
- * @returns An Error object
- *
- * @example
- * try {
- *   // some code that might throw
- * } catch (err) {
- *   const error = unknownToError(err); // Guaranteed to be Error instance
- * }
- *
- * The function handles different error types:
- * - Returns the error directly if it's already an Error instance
- * - Converts strings into Error objects using the string as the message
- * - For objects, tries to extract a message property or stringifies the object
- * - For other values, stringifies them or uses 'unknown' as fallback
- *
- * The original error value is preserved as the `cause` property of the returned Error.
- */
+/** @deprecated Use `t-result` library instead. */
 declare function unknownToError(error: unknown): Error;
+/** @deprecated Use `t-result` library instead. */
 type TypedResult<T, E extends ResultValidErrors = Error> = {
+    /** @deprecated Use `t-result` library instead. */
     ok: (value: T) => Ok<T>;
+    /** @deprecated Use `t-result` library instead. */
     err: (error: E) => Err<E>;
-    /**
-     * Use in combination with `typeof` to get the return type of the result
-     *
-     * @example
-     * const typedResult = createTypedResult<{ a: 'test' }>();
-     *
-     * function foo(): typeof typedResult.type {
-     *   return typedResult.ok({ a: 'test' });
-     * }
-     */
+    /** @deprecated Use `t-result` library instead. */
     _type: Result<T, E>;
 };
+/** @deprecated Use `t-result` library instead. */
 type GetTypedResult<R extends Result<any, any>> = TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
 declare function getOkErr<F extends (...args: any[]) => Promise<Result<any, any>>>(): TypedResult<Awaited<ReturnType<F>> extends Result<infer T, any> ? T : never, Awaited<ReturnType<F>> extends Result<any, infer E> ? E : never>;
 declare function getOkErr<F extends (...args: any[]) => Result<any, any>>(): TypedResult<ReturnType<F> extends Result<infer T, any> ? T : never, ReturnType<F> extends Result<any, infer E> ? E : never>;

package/lib/tsResult.d.ts

@@ -4,30 +4,41 @@ type Ok<T> = {
     value: T;
 } & AnyResultMethods;
 type AnyResultMethods = Record<ResultMethodsKeys, never>;
+/** @deprecated Use `t-result` library instead. */
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | readonly unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
-    errorResult: () => Result<any, E>;
+    /** @deprecated Use `t-result` library instead. */
+    errorResult: () => Err<E>;
 } & AnyResultMethods;
 type ResultMethods<T, E extends ResultValidErrors> = {
-    /** Returns the value if the result is Ok, otherwise returns null */
+    /** @deprecated Use `t-result` library instead. */
     unwrapOrNull: () => T | null;
-    /** Returns the value if the result is Ok, otherwise returns the provided default value */
+    /** @deprecated Use `t-result` library instead. */
     unwrapOr: <R extends T>(defaultValue: R) => T | R;
+    /** @deprecated Use `t-result` library instead. */
     unwrap: () => T;
+    /** @deprecated Use `t-result` library instead. */
     mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    /** @deprecated Use `t-result` library instead. */
     mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    /** @deprecated Use `t-result` library instead. */
     mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
         ok: (value: T) => NewValue;
         err: (error: E) => NewError;
     }) => Result<NewValue, NewError>;
+    /** @deprecated Use `t-result` library instead. */
     ifOk: (fn: (value: T) => void) => Result<T, E>;
+    /** @deprecated Use `t-result` library instead. */
     ifErr: (fn: (error: E) => void) => Result<T, E>;
 };
 type ResultMethodsKeys = keyof ResultMethods<any, any>;
+/** @deprecated Use `t-result` library instead. */
 declare function ok(): Ok<void>;
+/** @deprecated Use `t-result` library instead. */
 declare function ok<T>(value: T): Ok<T>;
+/** @deprecated Use `t-result` library instead. */
 declare function err<E extends ResultValidErrors>(error: E): Err<E>;
 declare function unknownToResultError(error: unknown): Err<Error>;
 /** Unwraps a promise result */
@@ -40,29 +51,9 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
         err: (error: E) => NewError;
     }) => Promise<Result<NewValue, NewError>>;
 };
-/**
- * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
- *
- * Usage:
- *
- * @example
- * function doSomething(): Result<string, Error> {
- *  if (something) {
- *    return ok('success');
- *  }
- *
- *  return err(new Error('something went wrong'));
- * }
- *
- * const result = doSomething();
- *
- * if (result.ok) {
- *   // result.value is a string
- * } else {
- *   // result.error is an Error
- * }
- */
+/** @deprecated Use `t-result` library instead. */
 type Result<T, E extends ResultValidErrors = Error> = (Omit<Ok<T>, ResultMethodsKeys> | Omit<Err<E>, ResultMethodsKeys>) & ResultMethods<T, E>;
+/** @deprecated Use `t-result` library instead. */
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
@@ -71,46 +62,24 @@ declare const Result: {
     asyncMap: typeof asyncMap;
     getOkErr: typeof getOkErr;
 };
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T extends Promise<any> ? never : T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+/** @deprecated Use `t-result` library instead. */
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<T, E>>;
-/**
- * Converts an unknown error value into an Error object.
- *
- * @param error - The unknown value to convert to an Error
- * @returns An Error object
- *
- * @example
- * try {
- *   // some code that might throw
- * } catch (err) {
- *   const error = unknownToError(err); // Guaranteed to be Error instance
- * }
- *
- * The function handles different error types:
- * - Returns the error directly if it's already an Error instance
- * - Converts strings into Error objects using the string as the message
- * - For objects, tries to extract a message property or stringifies the object
- * - For other values, stringifies them or uses 'unknown' as fallback
- *
- * The original error value is preserved as the `cause` property of the returned Error.
- */
+/** @deprecated Use `t-result` library instead. */
 declare function unknownToError(error: unknown): Error;
+/** @deprecated Use `t-result` library instead. */
 type TypedResult<T, E extends ResultValidErrors = Error> = {
+    /** @deprecated Use `t-result` library instead. */
     ok: (value: T) => Ok<T>;
+    /** @deprecated Use `t-result` library instead. */
     err: (error: E) => Err<E>;
-    /**
-     * Use in combination with `typeof` to get the return type of the result
-     *
-     * @example
-     * const typedResult = createTypedResult<{ a: 'test' }>();
-     *
-     * function foo(): typeof typedResult.type {
-     *   return typedResult.ok({ a: 'test' });
-     * }
-     */
+    /** @deprecated Use `t-result` library instead. */
     _type: Result<T, E>;
 };
+/** @deprecated Use `t-result` library instead. */
 type GetTypedResult<R extends Result<any, any>> = TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
 declare function getOkErr<F extends (...args: any[]) => Promise<Result<any, any>>>(): TypedResult<Awaited<ReturnType<F>> extends Result<infer T, any> ? T : never, Awaited<ReturnType<F>> extends Result<any, infer E> ? E : never>;
 declare function getOkErr<F extends (...args: any[]) => Result<any, any>>(): TypedResult<ReturnType<F> extends Result<infer T, any> ? T : never, ReturnType<F> extends Result<any, infer E> ? E : never>;

package/lib/tsResult.js

@@ -1,12 +1,175 @@
 import {
-  Result,
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
+import {
+  isFunction,
+  isObject,
+  isPromise
+} from "./chunk-3XCS7FVO.js";
+
+// src/tsResult.ts
+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 okOnOk(fn) {
+  if (this.ok) {
+    fn(this.value);
+  }
+  return this;
+}
+function errOnErr(fn) {
+  if (!this.ok) {
+    fn(this.error);
+  }
+  return this;
+}
+function ok(value = void 0) {
+  const methods = {
+    unwrapOrNull: okUnwrapOr,
+    unwrapOr: okUnwrapOr,
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr,
+    ifOk: okOnOk,
+    ifErr: returnResult
+  };
+  return {
+    ok: true,
+    error: false,
+    value,
+    ...methods
+  };
+}
+function err(error) {
+  const methods = {
+    unwrapOrNull: () => null,
+    unwrapOr: (defaultValue) => defaultValue,
+    unwrap: () => {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw unknownToError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr,
+    ifOk: returnResult,
+    ifErr: errOnErr
+  };
+  return {
+    ok: false,
+    error,
+    errorResult() {
+      return err(error);
+    },
+    ...methods
+  };
+}
+function unknownToResultError(error) {
+  return err(unknownToError(error));
+}
+async function asyncUnwrap(result) {
+  const unwrapped = await result;
+  if (unwrapped.ok) {
+    return unwrapped.value;
+  }
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw unknownToError(unwrapped.error);
+}
+function asyncMap(resultPromise) {
+  return {
+    err: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(result.value) : err(mapFn(result.error));
+    },
+    ok: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(result.error);
+    },
+    okAndErr: async ({
+      ok: mapFn,
+      err: mapErrFn
+    }) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
+    }
+  };
+}
+var Result = {
+  ok,
   err,
+  unknownToError: unknownToResultError,
+  asyncUnwrap,
+  asyncMap,
+  getOkErr
+};
+function resultify(fn, errorNormalizer) {
+  if (!isFunction(fn)) {
+    return fn.then((value) => ok(value)).catch(
+      (error) => err(
+        errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+      )
+    );
+  }
+  try {
+    const result = fn();
+    if (isPromise(result)) {
+      return result.then((value) => ok(value)).catch(
+        (error) => err(
+          errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+        )
+      );
+    }
+    return ok(result);
+  } catch (error) {
+    return err(
+      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+    );
+  }
+}
+function unknownToError(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error)) {
+    return new Error(
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
+      { cause: error }
+    );
+  }
+  return new Error(safeJsonStringify(error) ?? "unknown", {
+    cause: error
+  });
+}
+var typedResult = {
   ok,
-  resultify,
-  unknownToError
-} from "./chunk-J73KJABC.js";
-import "./chunk-VAAMRG4K.js";
-import "./chunk-3XCS7FVO.js";
+  err,
+  get _type() {
+    throw new Error("usage as value is not allowed");
+  }
+};
+function getOkErr() {
+  return typedResult;
+}
 export {
   Result,
   err,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "3.3.2",
+  "version": "3.5.0",
   "license": "MIT",
   "files": [
     "lib"
@@ -176,6 +176,9 @@
     "vite": "^6.0.11",
     "vitest": "^3.0.4"
   },
+  "dependencies": {
+    "t-result": "^0.2.1"
+  },
   "scripts": {
     "test:ui": "vitest --ui",
     "test": "vitest run",

package/lib/chunk-J73KJABC.js

@@ -1,180 +0,0 @@
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
-import {
-  isFunction,
-  isObject,
-  isPromise
-} from "./chunk-3XCS7FVO.js";
-
-// src/tsResult.ts
-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 okOnOk(fn) {
-  if (this.ok) {
-    fn(this.value);
-  }
-  return this;
-}
-function errOnErr(fn) {
-  if (!this.ok) {
-    fn(this.error);
-  }
-  return this;
-}
-function ok(value = void 0) {
-  const methods = {
-    unwrapOrNull: okUnwrapOr,
-    unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr,
-    mapOk: okMap,
-    mapErr: returnResult,
-    mapOkAndErr,
-    ifOk: okOnOk,
-    ifErr: returnResult
-  };
-  return {
-    ok: true,
-    error: false,
-    value,
-    ...methods
-  };
-}
-function err(error) {
-  const methods = {
-    unwrapOrNull: () => null,
-    unwrapOr: (defaultValue) => defaultValue,
-    unwrap: () => {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw unknownToError(error);
-    },
-    mapOk: returnResult,
-    mapErr: errMap,
-    mapOkAndErr,
-    ifOk: returnResult,
-    ifErr: errOnErr
-  };
-  return {
-    ok: false,
-    error,
-    errorResult() {
-      return err(error);
-    },
-    ...methods
-  };
-}
-function unknownToResultError(error) {
-  return err(unknownToError(error));
-}
-async function asyncUnwrap(result) {
-  const unwrapped = await result;
-  if (unwrapped.ok) {
-    return unwrapped.value;
-  }
-  if (unwrapped.error instanceof Error) {
-    throw unwrapped.error;
-  }
-  throw unknownToError(unwrapped.error);
-}
-function asyncMap(resultPromise) {
-  return {
-    err: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: async ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
-var Result = {
-  ok,
-  err,
-  unknownToError: unknownToResultError,
-  asyncUnwrap,
-  asyncMap,
-  getOkErr
-};
-function resultify(fn, errorNormalizer) {
-  if (!isFunction(fn)) {
-    return fn.then((value) => ok(value)).catch(
-      (error) => err(
-        errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-      )
-    );
-  }
-  try {
-    const result = fn();
-    if (isPromise(result)) {
-      return result.then((value) => ok(value)).catch(
-        (error) => err(
-          errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-        )
-      );
-    }
-    return ok(result);
-  } catch (error) {
-    return err(
-      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-    );
-  }
-}
-function unknownToError(error) {
-  if (error instanceof Error) return error;
-  if (typeof error === "string") {
-    return new Error(error);
-  }
-  if (isObject(error)) {
-    return new Error(
-      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
-      { cause: error }
-    );
-  }
-  return new Error(safeJsonStringify(error) ?? "unknown", {
-    cause: error
-  });
-}
-var typedResult = {
-  ok,
-  err,
-  get _type() {
-    throw new Error("usage as value is not allowed");
-  }
-};
-function getOkErr() {
-  return typedResult;
-}
-
-export {
-  ok,
-  err,
-  Result,
-  resultify,
-  unknownToError
-};