ts-data-forge 14.6.3 → 14.7.0

package/src/functional/index.mts

@@ -1,6 +1,31 @@
-export * from './async-result/index.mjs';
-export * from './match.mjs';
-export * from './optional/index.mjs';
-export * from './pipe.mjs';
-export * from './result/index.mjs';
-export * from './ternary-result/index.mjs';
+/**
+ * The algebraic data type core. The implementation lives in ts-std-forge
+ * since Sumi D-49 reversed the dependency between the two packages; what
+ * remains here is the re-export that keeps `import { Result } from
+ * 'ts-data-forge'` working. Both names denote the same declarations, so a
+ * value built through either package is the same type to both.
+ *
+ * New code should import these from `ts-std-forge` directly.
+ */
+export {
+  AsyncResult,
+  Optional,
+  Result,
+  TernaryResult,
+  match,
+  pipe,
+} from 'ts-std-forge';
+
+export type {
+  Err,
+  None,
+  Ok,
+  Pipe,
+  Some,
+  TernaryErr,
+  TernaryOk,
+  TernaryWarn,
+  UnknownOptional,
+  UnknownResult,
+  UnknownTernaryResult,
+} from 'ts-std-forge';

package/src/guard/has-key.mts

@@ -1,72 +1,2 @@
-import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';
-
-/**
- * Type guard function that checks if an object has a specific key as its own
- * property.
- *
- * This function uses `Object.hasOwn()` to check if the given object has the
- * specified key as its own property (not inherited). It acts as a type guard
- * that narrows the type of the object to guarantee the key exists, enabling
- * type-safe property access.
- *
- * **Type Narrowing Behavior:**
- *
- * - When the guard returns `true`, TypeScript narrows the object type to include
- *   the checked key
- * - For union types, only union members that contain the key are preserved
- * - The key's value type is preserved from the original object type when possible
- *
- * @example
- *
- * ```ts
- * const maybeUser: Readonly<{ id?: number; name?: string }> = {
- *   id: 42,
- * } as const;
- *
- * if (hasKey(maybeUser, 'id')) {
- *   // `maybeUser` is now known to have an `id` property.
- *   assert.isTrue(maybeUser.id === 42);
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @template R - The type of the input object, must extend UnknownRecord
- * @template K - The type of the key to check for, must extend PropertyKey
- *   (string | number | symbol)
- * @param obj - The object to check for the presence of the key
- * @param key - The key to check for in the object
- * @returns `true` if the object has the specified key as its own property,
- *   `false` otherwise. When `true`, TypeScript narrows the object type to
- *   guarantee the key exists.
- * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type
- */
-export const hasKey = <
-  const R extends UnknownRecord,
-  const K extends PropertyKey,
->(
-  obj: R,
-  key: K,
-): obj is HasKeyReturnType<R, K> => Object.hasOwn(obj, key);
-
-/**
- * @internal
- * When R is a union type (including the case with only one element), if any element in the union
- * contains K as a key, returns a type that narrows the union to only those elements that contain K as a key.
- * If none of the elements in the union contain K as a key, returns `ReadonlyRecord<K, unknown>`.
- * The result is made readonly.
- */
-export type HasKeyReturnType<
-  R extends UnknownRecord,
-  K extends PropertyKey,
-> = R extends R // union distribution
-  ? K extends keyof R
-    ? string extends keyof R
-      ? ReadonlyRecord<K, R[keyof R]> & R
-      : number extends keyof R
-        ? ReadonlyRecord<K, R[keyof R]> & R
-        : symbol extends keyof R
-          ? ReadonlyRecord<K, R[keyof R]> & R
-          : R
-    : never // omit union member that does not have key K
-  : never; // dummy case for union distribution
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { hasKey, type HasKeyReturnType } from 'ts-std-forge';

package/src/guard/is-non-null-object.mts

@@ -1,36 +1,2 @@
-/**
- * Type guard that checks if a value is a non-null object.
- *
- * This function checks if a value has type `"object"` according to the `typeof`
- * operator and is not `null`. This includes all object types such as plain
- * objects, arrays, dates, regular expressions, and other object instances, but
- * excludes functions.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `object`
- * - Excludes `null`, `undefined`, and all primitive types
- * - Excludes functions (they have `typeof` === `"function"`, not `"object"`)
- * - Includes arrays, dates, regex, and other object instances
- *
- * **Note:** This function returns `true` for arrays. If you need
- * record-oriented narrowing that excludes arrays, use `isRecord()` instead.
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
- *
- * const objects = mixed.filter(isNonNullObject);
- *
- * assert.deepStrictEqual(objects, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is an object and not `null`, `false` otherwise. When
- *   `true`, TypeScript narrows the type to `object`.
- * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)
- */
-// eslint-disable-next-line @typescript-eslint/no-restricted-types
-export const isNonNullObject = (u: unknown): u is object =>
-  typeof u === 'object' && u !== null;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { isNonNullObject } from 'ts-std-forge';

package/src/guard/is-record.mts

@@ -1,95 +1,2 @@
-import { type MutableRecord, type UnknownRecord } from 'ts-type-forge';
-import { isNonNullObject } from './is-non-null-object.mjs';
-
-/**
- * Type guard that checks if a value is a record — a non-null, non-array
- * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,
- * unknown>`).
- *
- * This function is designed to be combined with {@link hasKey} to probe
- * values of type `unknown` (e.g. parsed JSON, caught errors, external data)
- * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)
- * - Excludes `null`, `undefined`, primitives, and functions
- * - Excludes arrays: arrays have no string index signature, so they are not
- *   assignable to `UnknownRecord`; admitting them at runtime would be
- *   inconsistent with the narrowed type
- * - Returns `true` for every other non-null object, including dictionary
- *   objects created with `Object.create(null)` and instances such as `Date`,
- *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes
- *
- * **Why non-plain objects are included:** since every property of
- * `UnknownRecord` is typed `unknown`, reading properties from any object
- * through this narrowing is type-safe, and `hasKey` (backed by
- * `Object.hasOwn`) answers own-property questions correctly on any object
- * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns
- * `false` for them). Restricting the guard to plain objects would require
- * prototype checks that misjudge cross-realm objects and would prevent
- * probing useful instances such as `Error` subclasses.
- *
- * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.
- *
- * @example
- *
- * ```ts
- * const entries: readonly unknown[] = [
- *   { id: 1 },
- *   [1, 2],
- *   'str',
- *   0,
- *   null,
- * ] as const;
- *
- * const records = entries.filter(isRecord);
- *
- * assert.deepStrictEqual(records, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `UnknownRecord`.
- * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)
- * @see {@link hasKey} - For checking if a record has specific keys
- */
-export const isRecord = (u: unknown): u is UnknownRecord =>
-  isNonNullObject(u) && !Array.isArray(u);
-
-/**
- * Type guard that checks if a value is a mutable record.
- *
- * This function has the same runtime behavior as {@link isRecord} (non-null,
- * non-array object check), but narrows the type to `MutableRecord<string,
- * unknown>`, which is useful when you need to add or overwrite properties on
- * the narrowed object.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `MutableRecord<string, unknown>`
- * - Excludes `null`, `undefined`, primitives, functions, and arrays
- * - Returns `true` for every other non-null object (see {@link isRecord} for
- *   details on non-plain objects such as `Date`, `Map`, and `Set`)
- *
- * **Implementation:** This is a type alias for {@link isRecord}.
- *
- * @example
- *
- * ```ts
- * const obj: unknown = { foo: 1 } as const;
- *
- * if (isMutableRecord(obj)) {
- *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record
- * }
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `MutableRecord<string,
- *   unknown>`.
- * @see {@link isRecord} - For the underlying implementation and more details
- */
-export const isMutableRecord: (
-  u: unknown,
-) => u is MutableRecord<string, unknown> = isRecord;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { isMutableRecord, isRecord } from 'ts-std-forge';

package/src/guard/key-is-in.mts

@@ -1,49 +1,2 @@
-import { type UnknownRecord } from 'ts-type-forge';
-
-/**
- * Type guard that checks if a key exists as an own property in an object.
- *
- * This function is similar to `hasKey()` but with reversed parameter order and
- * different type narrowing behavior. While `hasKey()` narrows the object type,
- * `keyIsIn()` narrows the key type to be a valid key of the given object.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the key type to be a key that exists in the object (`K & keyof R`)
- * - Useful when you have a dynamic key and want to ensure it's valid for a
- *   specific object
- * - The object type remains unchanged
- *
- * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not
- * inherited).
- *
- * @example
- *
- * ```ts
- * const user = { id: 1, name: 'Ada' } as const;
- *
- * const maybeKey: string = 'name';
- *
- * if (keyIsIn(maybeKey, user)) {
- *   assert.isTrue(user[maybeKey] === 'Ada');
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @template K - The type of the key to check, must extend PropertyKey (string |
- *   number | symbol)
- * @template R - The type of the record (object), must extend UnknownRecord
- * @param key - The key to check for
- * @param obj - The object to check within
- * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When
- *   `true`, TypeScript narrows the key type to be a valid key of the object.
- * @see {@link hasKey} - Similar function that narrows the object type instead of the key type
- */
-export const keyIsIn = <
-  const K extends PropertyKey,
-  const R extends UnknownRecord,
->(
-  key: K,
-  obj: R,
-): key is K & keyof typeof obj => Object.hasOwn(obj, key);
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { keyIsIn } from 'ts-std-forge';

package/src/number/num.mts

@@ -1,3 +1,4 @@
+import { SafeNumber } from 'ts-std-forge';
 import {
   type Decrement,
   type FiniteNumber,
@@ -118,25 +119,34 @@ export namespace Num {
    * assert.isTrue(Result.isErr(Num.safeParseInt('')));
    *
    * assert.strictEqual(Result.unwrapOk(Num.safeParseInt('  ')), undefined);
+   *
+   * // A value that overflows to Infinity is not an integer either, even
+   * // though native `parseInt` reads a 1 out of it.
+   *
+   * assert.strictEqual(Number.parseInt('1e400', 10), 1);
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseInt('1e400')));
    * ```
    *
    * @param s The string to parse.
    * @returns `Result.ok(parsedInt)` for valid input, otherwise `Result.err`
-   *   wrapping an `Error` describing the invalid input.
+   *   wrapping an `Error` describing the invalid input. A value that
+   *   overflows to `Infinity` is rejected, so the `Int` brand never lies.
    */
-  export const safeParseInt = (s: string): Result<Int, Error> => {
-    const viaNumber = Number(s);
-
-    // `Number('')` / `Number('   ')` は 0 を返すが、`parseInt` は NaN を返す。
-    // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に
-    // 有効な場合のみ採用することで空文字・空白のみ・末尾不正をまとめて弾く。
-    return Number.isNaN(viaNumber) || Number.isNaN(Number.parseInt(s, 10))
-      ? Result.err(
+  export const safeParseInt = (s: string): Result<Int, Error> =>
+    // The parsing itself is `SafeNumber.parseInteger` (Sumi D-49 (c)): one
+    // implementation, in the package that owns the standard-library
+    // boundary. What stays here is this function's own contract — the `Int`
+    // brand on the success side, and an `Error` rather than a tagged record
+    // on the failure side.
+    Result.match(SafeNumber.parseInteger(s), {
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      ok: (n) => Result.ok(n as Int),
+      err: () =>
+        Result.err(
           new Error(`safeParseInt: "${s}" is not a valid base-10 integer`),
-        )
-      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Result.ok(Math.trunc(viaNumber) as Int);
-  };
+        ),
+    });
 
   /**
    * Safely parses a finite floating-point number from a string, returning a
@@ -201,22 +211,20 @@ export namespace Num {
    * @returns `Result.ok(parsedFloat)` for valid finite input, otherwise
    *   `Result.err` wrapping an `Error` describing the invalid input.
    */
-  export const safeParseFloat = (s: string): Result<FiniteNumber, Error> => {
-    const viaNumber = Number(s);
-
-    // `Number('')` / `Number('   ')` は 0 を返すが、`parseFloat` は NaN を返す。
-    // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に
-    // 非 NaN かつ有限の場合のみ採用することで空文字・空白のみ・末尾不正・
-    // Infinity をまとめて弾く。
-    return Number.isNaN(viaNumber) ||
-      !Number.isFinite(viaNumber) ||
-      Number.isNaN(Number.parseFloat(s))
-      ? Result.err(
+  export const safeParseFloat = (s: string): Result<FiniteNumber, Error> =>
+    // The parsing itself is `SafeNumber.parse` (Sumi D-49 (c)): one
+    // implementation, in the package that owns the standard-library
+    // boundary. What stays here is this function's own contract — the
+    // `FiniteNumber` brand on the success side, and an `Error` rather than a
+    // tagged record on the failure side.
+    Result.match(SafeNumber.parse(s), {
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      ok: (n) => Result.ok(n as FiniteNumber),
+      err: () =>
+        Result.err(
           new Error(`safeParseFloat: "${s}" is not a valid finite number`),
-        )
-      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Result.ok(viaNumber as FiniteNumber);
-  };
+        ),
+    });
 
   /**
    * Type guard that checks if a number is non-zero.

package/src/others/index.mts

@@ -5,5 +5,6 @@ export * from './fast-deep-equal.mjs';
 export * from './if-then.mjs';
 export * from './map-nullable.mjs';
 export * from './memoize-function.mjs';
+export * from './panic-error.mjs';
 export * from './tuple.mjs';
 export * from './unknown-to-string.mjs';

package/src/others/panic-error.mts

@@ -0,0 +1,8 @@
+/**
+ * The panic error. Implemented in ts-std-forge since Sumi D-49 / D-53; this
+ * re-export keeps the names importable from here. The boundary functions of
+ * this package recognize a panic through `isPanicError`, which matches on a
+ * mark rather than on a constructor, so a panic raised by either package is a
+ * panic to both.
+ */
+export { createPanicError, isPanicError, type PanicError } from 'ts-std-forge';

package/src/others/unknown-to-string.mts

@@ -1,111 +1,2 @@
-import { isDate, isError, isMap, isRegExp, isSet } from '@sindresorhus/is';
-
-/**
- * Converts an unknown value to its string representation in a type-safe manner.
- *
- * This function handles all JavaScript types and provides consistent string
- * conversion with proper error handling for edge cases like circular
- * references. Unlike naive toString() calls, this function never throws and
- * handles all value types gracefully.
- *
- * **Type conversion rules:**
- *
- * - Strings: returned as-is
- * - Numbers, booleans, bigints: converted via toString()
- * - Symbols: converted to their description string
- * - Functions: converted to their string representation
- * - null: returns "null" (not "null" from JSON)
- * - undefined: returns "undefined"
- * - Date: converted to ISO string
- * - RegExp: converted to regex literal string
- * - Map: converted to Map representation with entries
- * - Set: converted to Set representation with values
- * - Error: returns error message
- * - Objects: JSON stringified (with optional pretty printing)
- *
- * @param value - The unknown value to convert to string
- * @param options - Optional configuration for the conversion
- * @param options.prettyPrintObject - If true, objects are formatted with
- *   2-space indentation
- * @returns The string representation of the value. For circular references or
- *   non-serializable objects, returns an error message string
- *
- *   **Error Handling:** Circular references and non-serializable objects return
- *   descriptive error messages instead of throwing
- * @see JSON.stringify - Underlying serialization for objects
- */
-export const unknownToString = (
-  value: unknown,
-  options?: Partial<Readonly<{ prettyPrintObject: boolean }>>,
-): string => {
-  switch (typeof value) {
-    case 'string':
-      return value;
-
-    case 'bigint':
-      return `${value.toString()}n`;
-
-    case 'number':
-    case 'boolean':
-    case 'symbol':
-    case 'function':
-      return value.toString();
-
-    case 'undefined':
-      return 'undefined';
-
-    case 'object': {
-      if (value === null) {
-        return 'null';
-      }
-
-      try {
-        // Special handling for Date
-        if (isDate(value)) {
-          return value.toISOString();
-        }
-
-        // Special handling for RegExp
-        if (isRegExp(value)) {
-          return value.toString();
-        }
-
-        if (isError(value)) {
-          return value.message;
-        }
-
-        const prettyPrintObject = options?.prettyPrintObject === true;
-
-        // Special handling for Map
-        if (isMap(value)) {
-          const entries = Array.from(value);
-
-          const entriesStr = prettyPrintObject
-            ? JSON.stringify(entries, undefined, 2)
-            : JSON.stringify(entries);
-
-          return `Map(${entriesStr})`;
-        }
-
-        // Special handling for Set
-        if (isSet(value)) {
-          const values = Array.from(value);
-
-          const valuesStr = prettyPrintObject
-            ? JSON.stringify(values, undefined, 2)
-            : JSON.stringify(values);
-
-          return `Set(${valuesStr})`;
-        }
-
-        return prettyPrintObject
-          ? JSON.stringify(value, undefined, 2)
-          : JSON.stringify(value);
-      } catch (error) {
-        return isError(error)
-          ? error.message
-          : '[Circular or Non-serializable]';
-      }
-    }
-  }
-};
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { unknownToString } from 'ts-std-forge';

package/src/types.mts

@@ -75,57 +75,7 @@ export namespace SizeType {
   >;
 }
 
-// #region Optional
-/**
- * Represents the 'Some' variant of an Optional, containing a value.
- *
- * @template S The type of the contained value.
- */
-export type Some<S> = Readonly<{
-  /** @internal Discriminant property for the 'Some' type. */
-  $$tag: 'ts-data-forge::Optional.some';
-
-  /** The contained value. */
-  value: S;
-}>;
-
-/**
- * Represents the 'None' variant of an Optional, indicating the absence
- * of a value.
- */
-export type None = Readonly<{
-  /** @internal Discriminant property for the 'None' type. */
-  $$tag: 'ts-data-forge::Optional.none';
-}>;
-
-// #endregion Optional
-
-// #region Result
-
-/**
- * Represents a `Result` that is a success, containing a value.
- *
- * @template S The type of the success value.
- */
-export type Ok<S> = Readonly<{
-  /** @internal Discriminant property for the 'Ok' type. */
-  $$tag: 'ts-data-forge::Result.ok';
-
-  /** The success value. */
-  value: S;
-}>;
-
-/**
- * Represents a `Result` that is an error, containing an error value.
- *
- * @template E The type of the error value.
- */
-export type Err<E> = Readonly<{
-  /** @internal Discriminant property for the 'Err' type. */
-  $$tag: 'ts-data-forge::Result.err';
-
-  /** The error value. */
-  value: E;
-}>;
-
-// #endregion Result
+// The four variant shapes of `Optional` and `Result` are implemented in
+// ts-std-forge since Sumi D-49; re-exported here so that `Ok` / `Err` /
+// `Some` / `None` keep denoting the same declarations in both packages.
+export type { Err, None, Ok, Some } from 'ts-std-forge';

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

@@ -1,16 +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';
-//# sourceMappingURL=async-result.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"async-result.d.mts","sourceRoot":"","sources":["../../../src/functional/async-result/async-result.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEtD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC"}

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

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

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

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

package/dist/functional/async-result/impl/async-result-flat-map.d.mts

@@ -1,39 +0,0 @@
-import { 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 declare function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
-export declare function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(flatMapFn: (value: S) => R2): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
-//# sourceMappingURL=async-result-flat-map.d.mts.map

package/dist/functional/async-result/impl/async-result-flat-map.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-result-flat-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-flat-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,kBAAkB,GAAG,aAAa,EACzE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAC1B,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;AAWhD,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,SAAS,kBAAkB,GAAG,aAAa,EACtE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAC1B,CAAC,CAAC,EACH,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAC3B,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC"}