ts-data-forge 14.6.3 → 14.7.0

package/dist/functional/ternary-result/impl/ternary-result-zip.d.mts

@@ -1,34 +0,0 @@
-import { type TernaryResult } from '../ternary-result.mjs';
-/**
- * Combines two `TernaryResult`s, prioritising Err over Warn over Ok.
- *
- * @example
- *
- * ```ts
- * const okPair = TernaryResult.zip(
- *   TernaryResult.ok('left'),
- *   TernaryResult.ok(1),
- * );
- *
- * const warnPair = TernaryResult.zip(
- *   TernaryResult.warn('left', 'warn'),
- *   TernaryResult.ok(1),
- * );
- *
- * const errPair = TernaryResult.zip(
- *   TernaryResult.ok('left'),
- *   TernaryResult.err('err'),
- * );
- *
- * assert.deepStrictEqual(okPair, TernaryResult.ok(['left', 1] as const));
- *
- * assert.deepStrictEqual(
- *   warnPair,
- *   TernaryResult.warn(['left', 1] as const, 'warn'),
- * );
- *
- * assert.deepStrictEqual(errPair, TernaryResult.err('err'));
- * ```
- */
-export declare const zip: <S1, W1, E1, S2, W2, E2>(resultA: TernaryResult<S1, E1, W1>, resultB: TernaryResult<S2, E2, W2>) => TernaryResult<readonly [S1, S2], E1 | E2, W1 | W2>;
-//# sourceMappingURL=ternary-result-zip.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-zip.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ternary-result-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-zip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAM3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,GAAG,GAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,WAC/B,aAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,WACzB,aAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KACjC,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAoBnD,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-zip.mjs

@@ -1,52 +0,0 @@
-import { isErr } from './ternary-result-is-err.mjs';
-import { isWarn } from './ternary-result-is-warn.mjs';
-import { ok } from './ternary-result-ok.mjs';
-import { warn } from './ternary-result-warn.mjs';
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const zip = (resultA, resultB) => {
-    if (isErr(resultA)) {
-        return resultA;
-    }
-    if (isErr(resultB)) {
-        return resultB;
-    }
-    const pair = [resultA.value, resultB.value];
-    if (isWarn(resultA)) {
-        return warn(pair, resultA.warning);
-    }
-    if (isWarn(resultB)) {
-        return warn(pair, resultB.warning);
-    }
-    return ok(pair);
-};
-//# sourceMappingURL=ternary-result-zip.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-zip.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ternary-result-zip.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-zip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,EAAE,EAAE,EAAE,MAAM,yBAAyB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,OAAkC,EAClC,OAAkC,EACkB,EAAE;IACtD,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAU,CAAC;IAErD,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;AAClB,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/types.d.mts

@@ -1,26 +0,0 @@
-import { type TernaryErr, type TernaryOk, type TernaryWarn, type UnknownTernaryResult } from '../ternary-result.mjs';
-/**
- * Extracts the success value type `S` from a `TernaryResult.Ok<S>`.
- */
-export type UnwrapOk<R extends UnknownTernaryResult> = R extends TernaryOk<infer S> ? S : R extends TernaryWarn<infer S, unknown> ? S : never;
-/**
- * Extracts the warning value type `W` from a `TernaryResult.Warn<W>`.
- */
-export type UnwrapWarn<R extends UnknownTernaryResult> = R extends TernaryWarn<unknown, infer E> ? E : never;
-/**
- * Extracts the error value type `E` from a `TernaryResult.Err<E>`.
- */
-export type UnwrapErr<R extends UnknownTernaryResult> = R extends TernaryErr<infer E> ? E : never;
-/**
- * Narrows the provided `UnknownTernaryResult` to its Ok variant.
- */
-export type NarrowToOk<R extends UnknownTernaryResult> = R extends TernaryOk<unknown> ? R : never;
-/**
- * Narrows the provided `UnknownTernaryResult` to its Warn variant.
- */
-export type NarrowToWarn<R extends UnknownTernaryResult> = R extends TernaryWarn<unknown, unknown> ? R : never;
-/**
- * Narrows the provided `UnknownTernaryResult` to its Err variant.
- */
-export type NarrowToErr<R extends UnknownTernaryResult> = R extends TernaryErr<unknown> ? R : never;
-//# sourceMappingURL=types.d.mts.map

package/dist/functional/ternary-result/impl/types.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/types.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,oBAAoB,IACjD,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,GACxB,CAAC,GACD,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,GACrC,CAAC,GACD,KAAK,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,oBAAoB,IACnD,CAAC,SAAS,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,oBAAoB,IAClD,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,oBAAoB,IACnD,CAAC,SAAS,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE3C;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,oBAAoB,IACrD,CAAC,SAAS,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,oBAAoB,IACpD,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/functional/ternary-result/impl/types.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.mjs.map

package/dist/functional/ternary-result/impl/types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/types.mts"],"names":[],"mappings":""}

package/dist/functional/ternary-result/impl/variant-name.d.mts

@@ -1,4 +0,0 @@
-import { type UnknownTernaryResult } from '../ternary-result.mjs';
-/** @internal Returns the human readable variant label for the given tag. */
-export declare const variantName: (tag: UnknownTernaryResult['$$tag']) => 'Ok' | 'Warn' | 'Err';
-//# sourceMappingURL=variant-name.d.mts.map

package/dist/functional/ternary-result/impl/variant-name.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"variant-name.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,4EAA4E;AAC5E,eAAO,MAAM,WAAW,QACjB,oBAAoB,CAAC,OAAO,CAAC,KACjC,IAAI,GAAG,MAAM,GAAG,KAWlB,CAAC"}

package/dist/functional/ternary-result/impl/variant-name.mjs

@@ -1,13 +0,0 @@
-import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
-
-export const variantName = (tag) => {
-    switch (tag) {
-        case OkTypeTagName:
-            return 'Ok';
-        case WarnTypeTagName:
-            return 'Warn';
-        case ErrTypeTagName:
-            return 'Err';
-    }
-};
-//# sourceMappingURL=variant-name.mjs.map

package/dist/functional/ternary-result/impl/variant-name.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"variant-name.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE3E,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,GAAkC,EACX,EAAE;IACzB,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,aAAa;YAChB,OAAO,IAAI,CAAC;QAEd,KAAK,eAAe;YAClB,OAAO,MAAM,CAAC;QAEhB,KAAK,cAAc;YACjB,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC,CAAC"}

package/dist/functional/ternary-result/index.d.mts

@@ -1,2 +0,0 @@
-export * from './ternary-result.mjs';
-//# sourceMappingURL=index.d.mts.map

package/dist/functional/ternary-result/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functional/ternary-result/index.mts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/functional/ternary-result/index.mjs

@@ -1,2 +0,0 @@
-export * from './ternary-result.mjs';
-//# sourceMappingURL=index.mjs.map

package/dist/functional/ternary-result/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/functional/ternary-result/index.mts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/functional/ternary-result/ternary-result.d.mts

@@ -1,40 +0,0 @@
-/**
- * Represents a `TernaryResult` that is a success, containing a value.
- */
-export type TernaryOk<S> = Readonly<{
-    /** @internal Discriminant property for the 'Ok' type. */
-    $$tag: 'ts-data-forge::Result.ok';
-    /** The success value. */
-    value: S;
-}>;
-/**
- * Represents a `TernaryResult` that contains a success value and an attached
- * warning.
- */
-export type TernaryWarn<S, W> = Readonly<{
-    /** @internal Discriminant property for the 'Warn' type. */
-    $$tag: 'ts-data-forge::Result.warn';
-    /** The success value. */
-    value: S;
-    /** The warning value. */
-    warning: W;
-}>;
-/**
- * Represents a `TernaryResult` that is an error, containing an error value.
- */
-export type TernaryErr<E> = Readonly<{
-    /** @internal Discriminant property for the 'Err' type. */
-    $$tag: 'ts-data-forge::Result.err';
-    /** The error value. */
-    value: E;
-}>;
-/**
- * Represents a value that can be `Ok`, `Warn`, or `Err`.
- */
-export type TernaryResult<S, E, W = E> = TernaryOk<S> | TernaryWarn<S, W> | TernaryErr<E>;
-/**
- * Base type for any `TernaryResult`, used for generic constraints.
- */
-export type UnknownTernaryResult = TernaryOk<unknown> | TernaryWarn<unknown, unknown> | TernaryErr<unknown>;
-export * as TernaryResult from './impl/index.mjs';
-//# sourceMappingURL=ternary-result.d.mts.map

package/dist/functional/ternary-result/ternary-result.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ternary-result.d.mts","sourceRoot":"","sources":["../../../src/functional/ternary-result/ternary-result.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,QAAQ,CAAC;IAClC,yDAAyD;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAElC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC;IACvC,2DAA2D;IAC3D,KAAK,EAAE,4BAA4B,CAAC;IAEpC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;IAET,yBAAyB;IACzB,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC;IACnC,0DAA0D;IAC1D,KAAK,EAAE,2BAA2B,CAAC;IAEnC,uBAAuB;IACvB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IACnC,SAAS,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC9B,SAAS,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAE3E,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC"}

package/dist/functional/ternary-result/ternary-result.mjs

@@ -1,2 +0,0 @@
-export * as TernaryResult from './impl/index.mjs';
-//# sourceMappingURL=ternary-result.mjs.map

package/dist/functional/ternary-result/ternary-result.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ternary-result.mjs","sourceRoot":"","sources":["../../../src/functional/ternary-result/ternary-result.mts"],"names":[],"mappings":"AAiDA,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC"}

package/src/functional/async-result/async-result.mts

@@ -1,17 +0,0 @@
-import { type Result } from '../result/index.mjs';
-
-/**
- * Represents an asynchronous computation that can either succeed (`Ok`) or
- * fail (`Err`) — a `Promise` that resolves to a `Result<S, E>`.
- *
- * Unlike a raw `Promise`, an `AsyncResult` never rejects for expected
- * failures: errors are carried in the `Err` channel with a concrete type `E`,
- * so they can be handled with the same combinators as a synchronous
- * `Result`.
- *
- * @template S The type of the success value.
- * @template E The type of the error value.
- */
-export type AsyncResult<S, E> = Promise<Result<S, E>>;
-
-export * as AsyncResult from './impl/index.mjs';

package/src/functional/async-result/impl/async-result-flat-map.mts

@@ -1,99 +0,0 @@
-import { Result, type UnknownResult } from '../../result/index.mjs';
-import { type AsyncResult } from '../async-result.mjs';
-import {
-  type UnknownAsyncResult,
-  type UnwrapErr,
-  type UnwrapOk,
-} from './types.mjs';
-
-/**
- * Applies a function that returns an `AsyncResult` or a `Result` to the
- * success value of an `AsyncResult`. If the input resolves to `Err`, the
- * original `Err` is passed through and the function is not called. This is
- * the monadic bind operation for `AsyncResult`.
- *
- * @example
- *
- * ```ts
- * const parseNumber = (input: string): Result<number, string> => {
- *   const num = Number.parseInt(input, 10);
- *
- *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);
- * };
- *
- * const input = AsyncResult.fromPromise(
- *   Promise.resolve('42'),
- *   () => 'failed',
- * );
- *
- * const parsed = await AsyncResult.flatMap(input, parseNumber);
- *
- * assert.deepStrictEqual(parsed, Result.ok(42));
- * ```
- *
- * @template S The type of the success value of the input.
- * @template E The type of the error value of the input.
- * @template R2 The `AsyncResult` or `Result` type returned by the function.
- * @param asyncResult The `AsyncResult` to flat map.
- * @param flatMapFn The function to apply that returns an `AsyncResult` or a
- *   `Result`.
- * @returns The result of applying the function, or the original `Err`.
- */
-export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
-  asyncResult: AsyncResult<S, E>,
-  flatMapFn: (value: S) => R2,
-): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
-
-// Curried version
-//
-// The function's return type is captured as a whole (`R2`) and unwrapped with
-// `UnwrapOk` / `UnwrapErr`, instead of being written as
-// `AsyncResult<S2, E2> | Result<S2, E2>` with separate `S2` / `E2` type
-// parameters. With the union form, inference for `E2` collects a candidate
-// from matching `Ok<S2>` against `Err<E2>` (both have a `value` property), so
-// `E2` ends up as the success type and the call fails to type-check even for
-// a function annotated as returning `Result<S2, E2>`.
-export function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(
-  flatMapFn: (value: S) => R2,
-): <E>(
-  asyncResult: AsyncResult<S, E>,
-) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
-
-export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
-  ...args:
-    | readonly [asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2]
-    | readonly [flatMapFn: (value: S) => R2]
-):
-  | AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>
-  | ((
-      asyncResult: AsyncResult<S, E>,
-    ) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>) {
-  switch (args.length) {
-    case 2: {
-      // Direct version: first argument is asyncResult
-      const [asyncResult, flatMapFn] = args;
-
-      return flatMapImpl(asyncResult, flatMapFn);
-    }
-
-    case 1: {
-      // Curried version
-      const [flatMapFn] = args;
-
-      return (asyncResult: AsyncResult<S, E>) =>
-        flatMapImpl(asyncResult, flatMapFn);
-    }
-  }
-}
-
-const flatMapImpl = async <S, E, R2 extends UnknownAsyncResult | UnknownResult>(
-  asyncResult: AsyncResult<S, E>,
-  flatMapFn: (value: S) => R2,
-): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>> => {
-  const result = await asyncResult;
-
-  return Result.isErr(result)
-    ? result
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      ((await flatMapFn(result.value)) as Result<UnwrapOk<R2>, UnwrapErr<R2>>);
-};

package/src/functional/async-result/impl/async-result-from-promise.mts

@@ -1,69 +0,0 @@
-import { Result } from '../../result/index.mjs';
-import { type AsyncResult } from '../async-result.mjs';
-
-/**
- * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,
- * the `AsyncResult` resolves to `Ok` with the resolved value. If the input
- * Promise rejects, the rejection reason is passed through `mapError` and the
- * `AsyncResult` resolves to `Err` with the mapped error.
- *
- * Passing `mapError` is what gives the error channel a concrete type `E`.
- * Omitting it carries the rejection reason through untouched, leaving the
- * error channel as `unknown` — the same contract as `Result.fromPromise`.
- *
- * @example
- *
- * ```ts
- * const resolved = await AsyncResult.fromPromise(
- *   Promise.resolve('ok'),
- *   (error) => `failed: ${String(error)}`,
- * );
- *
- * const rejected = await AsyncResult.fromPromise(
- *   Promise.reject(new Error('boom')),
- *   (error) => (isError(error) ? error.message : 'unknown'),
- * );
- *
- * assert.deepStrictEqual(resolved, Result.ok('ok'));
- *
- * assert.deepStrictEqual(rejected, Result.err('boom'));
- *
- * // Without `mapError`, the rejection reason is carried as-is.
- * const untyped = await AsyncResult.fromPromise(
- *   Promise.reject(new Error('boom')),
- * );
- *
- * assert.isTrue(Result.isErr(untyped));
- * ```
- *
- * @template S The type of the success value.
- * @template E The type of the error value.
- * @param promise The Promise to convert.
- * @param mapError The function applied to the rejection reason to produce the
- *   error value. Omit it to carry the rejection reason as `unknown`.
- * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's
- *   failure.
- */
-export function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;
-
-export function fromPromise<S, E>(
-  promise: Promise<S>,
-  mapError: (error: unknown) => E,
-): AsyncResult<S, E>;
-
-export function fromPromise<S, E>(
-  promise: Promise<S>,
-  mapError?: (error: unknown) => E,
-): AsyncResult<S, E> | AsyncResult<S, unknown> {
-  return mapError === undefined
-    ? fromPromiseImpl(promise, (error: unknown) => error)
-    : fromPromiseImpl(promise, mapError);
-}
-
-const fromPromiseImpl = <S, E>(
-  promise: Promise<S>,
-  mapError: (error: unknown) => E,
-): AsyncResult<S, E> =>
-  promise
-    .then((value) => Result.ok(value))
-    .catch((error: unknown) => Result.err(mapError(error)));

package/src/functional/async-result/impl/async-result-from-throwable.mts

@@ -1,78 +0,0 @@
-import { Result } from '../../result/index.mjs';
-import { type AsyncResult } from '../async-result.mjs';
-
-/**
- * Wraps a function returning a `Promise` in an `AsyncResult`. Both a
- * synchronous `throw` while calling `fn` and an asynchronous rejection of the
- * returned Promise are caught, passed through `mapError`, and carried as
- * `Err`.
- *
- * Passing `mapError` is what gives the error channel a concrete type `E`.
- * Omitting it carries the thrown value through untouched, leaving the error
- * channel as `unknown`.
- *
- * @example
- *
- * ```ts
- * const success = await AsyncResult.fromThrowable(
- *   () => Promise.resolve(2),
- *   (error) => `failed: ${String(error)}`,
- * );
- *
- * const failure = await AsyncResult.fromThrowable(
- *   (): Promise<number> => {
- *     throw new Error('boom');
- *   },
- *   (error) => (isError(error) ? error.message : 'unknown'),
- * );
- *
- * assert.deepStrictEqual(success, Result.ok(2));
- *
- * assert.deepStrictEqual(failure, Result.err('boom'));
- *
- * // Without `mapError`, the thrown value is carried as-is.
- * const untyped = await AsyncResult.fromThrowable(
- *   (): Promise<number> => {
- *     throw new Error('boom');
- *   },
- * );
- *
- * assert.isTrue(Result.isErr(untyped));
- * ```
- *
- * @template S The type of the success value.
- * @template E The type of the error value.
- * @param fn The function to execute; it may throw synchronously or return a
- *   rejecting Promise.
- * @param mapError The function applied to the thrown value or rejection
- *   reason to produce the error value. Omit it to carry the thrown value as
- *   `unknown`.
- * @returns An `AsyncResult<S, E>` containing either the resolved value or the
- *   mapped error.
- */
-export function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;
-
-export function fromThrowable<S, E>(
-  fn: () => Promise<S>,
-  mapError: (error: unknown) => E,
-): AsyncResult<S, E>;
-
-export function fromThrowable<S, E>(
-  fn: () => Promise<S>,
-  mapError?: (error: unknown) => E,
-): AsyncResult<S, E> | AsyncResult<S, unknown> {
-  return mapError === undefined
-    ? fromThrowableImpl(fn, (error: unknown) => error)
-    : fromThrowableImpl(fn, mapError);
-}
-
-const fromThrowableImpl = async <S, E>(
-  fn: () => Promise<S>,
-  mapError: (error: unknown) => E,
-): AsyncResult<S, E> => {
-  try {
-    return Result.ok(await fn());
-  } catch (error) {
-    return Result.err(mapError(error));
-  }
-};

package/src/functional/async-result/impl/async-result-map-err.mts

@@ -1,84 +0,0 @@
-import { Result } from '../../result/index.mjs';
-import { type AsyncResult } from '../async-result.mjs';
-
-/**
- * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function
- * to the error value. The mapping function may be synchronous or return a
- * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
- * `Ok`, the original `Ok` is passed through and the function is not called.
- *
- * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
- * as-is — it is **not** caught and converted into an `Err`.
- *
- * @example
- *
- * ```ts
- * const errValue = AsyncResult.fromPromise(
- *   Promise.reject(new Error('boom')),
- *   () => 'failure',
- * );
- *
- * const uppercased = await AsyncResult.mapErr(errValue, (error) =>
- *   error.toUpperCase(),
- * );
- *
- * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));
- * ```
- *
- * @template S The type of the success value.
- * @template E The type of the error value of the input.
- * @template E2 The type of the error value returned by the mapping function.
- * @param asyncResult The `AsyncResult` to map.
- * @param mapFn The function to apply to the error value if present.
- * @returns A new `AsyncResult<S, E2>`.
- */
-export function mapErr<S, E, E2>(
-  asyncResult: AsyncResult<S, E>,
-  mapFn: (error: E) => E2 | Promise<E2>,
-): AsyncResult<S, E2>;
-
-// Curried version
-//
-// Unlike `Result.mapErr`, the returned function can simply be generic over
-// `S`: an `AsyncResult` is a `Promise`, not a discriminated union, so there
-// is no literal-narrowing problem that would require the whole-result
-// generic trick used by the synchronous combinators.
-export function mapErr<E, E2>(
-  mapFn: (error: E) => E2 | Promise<E2>,
-): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;
-
-export function mapErr<S, E, E2>(
-  ...args:
-    | readonly [
-        asyncResult: AsyncResult<S, E>,
-        mapFn: (error: E) => E2 | Promise<E2>,
-      ]
-    | readonly [mapFn: (error: E) => E2 | Promise<E2>]
-):
-  | AsyncResult<S, E2>
-  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>) {
-  switch (args.length) {
-    case 2: {
-      // Direct version: first argument is asyncResult
-      const [asyncResult, mapFn] = args;
-
-      return mapErrImpl(asyncResult, mapFn);
-    }
-
-    case 1: {
-      // Curried version: first argument is mapping function
-      const [mapFn] = args;
-
-      return (asyncResult: AsyncResult<S, E>) => mapErrImpl(asyncResult, mapFn);
-    }
-  }
-}
-
-const mapErrImpl = async <S, E, E2>(
-  asyncResult: AsyncResult<S, E>,
-  mapFn: (error: E) => E2 | Promise<E2>,
-): AsyncResult<S, E2> => {
-  const result = await asyncResult;
-
-  return Result.isOk(result) ? result : Result.err(await mapFn(result.value));
-};