ts-data-forge 14.6.2 → 14.6.3

package/dist/functional/optional/impl/optional-unwrap-throw.mjs

@@ -1,34 +1,34 @@
 import { isSome } from './optional-is-some.mjs';
-/**
- * Unwraps an `Optional`, returning the contained value. Throws an error if
- * the `Optional` is `None`.
- *
- * This is a safer alternative to direct value access when you know the
- * Optional should contain a value. Use this method when an empty Optional
- * represents a programming error or unexpected condition.
- *
- * @example
- *
- * ```ts
- * const present = Optional.some('available');
- *
- * assert.isTrue(Optional.unwrapThrow(present) === 'available');
- *
- * assert.throws(
- *   () => Optional.unwrapThrow(Optional.none),
- *   /has failed because it is `None`/u,
- * );
- * ```
- *
- * @template O The `UnknownOptional` type to unwrap.
- * @param optional The `Optional` to unwrap.
- * @returns The contained value if `Some`.
- * @throws {Error} Error with message "`unwrapThrow()` has failed because it
- *   is `None`" if the `Optional` is `None`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapThrow = (optional) => {
     if (isSome(optional)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return optional.value;
     }
     throw new Error('`unwrapThrow()` has failed because it is `None`');

package/dist/functional/optional/impl/optional-unwrap.mjs

@@ -1,7 +1,7 @@
 import { isSome } from './optional-is-some.mjs';
 export function unwrap(optional) {
     return isSome(optional)
-        ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ?
             optional.value
         : undefined;
 }

package/dist/functional/optional/impl/optional-zip.mjs

@@ -1,38 +1,38 @@
 import { isSome } from './optional-is-some.mjs';
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
-/**
- * Combines two `Optional` values into a single `Optional` containing a tuple.
- * If either `Optional` is `None`, returns `None`.
- *
- * @example
- *
- * ```ts
- * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));
- *
- * assert.isTrue(Optional.isSome(zipped));
- *
- * if (Optional.isSome(zipped)) {
- *   const expected: readonly [string, number] = ['left', 1] as const;
- *
- *   assert.deepStrictEqual(zipped.value, expected);
- * }
- *
- * const missing = Optional.zip(
- *   Optional.some('value'),
- *   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
- *   Optional.none as Optional<number>,
- * );
- *
- * assert.deepStrictEqual(missing, Optional.none);
- * ```
- *
- * @template A The value type of the first `Optional`.
- * @template B The value type of the second `Optional`.
- * @param optionalA The first `Optional`.
- * @param optionalB The second `Optional`.
- * @returns An `Optional` containing a tuple of both values, or `None`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const zip = (optionalA, optionalB) => isSome(optionalA) && isSome(optionalB)
     ? some([optionalA.value, optionalB.value])
     : none;

package/dist/functional/optional/impl/tag.mjs

@@ -1,4 +1,4 @@
 export const SomeTypeTagName = 'ts-data-forge::Optional.some';
-/** @internal String literal tag to identify the 'None' variant of Optional. */
+
 export const NoneTypeTagName = 'ts-data-forge::Optional.none';
 //# sourceMappingURL=tag.mjs.map

package/dist/functional/pipe.mjs

@@ -1,25 +1,25 @@
 
 import { Optional } from './optional/index.mjs';
-/**
- * Creates a new pipe object that allows for chaining operations on a value.
- *
- * This function provides a fluent interface for applying transformations to
- * values, with intelligent method selection based on the input type:
- *
- * - For `Optional` values: Provides `mapOptional` for safe Optional
- *   transformations
- * - For other values: Provides `mapNullable` for null-safe transformations
- * - All types get the basic `map` method for general transformations
- *
- * The pipe maintains type safety throughout the chain, automatically selecting
- * the appropriate overload based on the current value type.
- *
- * @template A The type of the initial value to wrap in a pipe.
- * @param a The initial value to wrap in a pipe.
- * @returns A pipe object with chaining methods appropriate for the value type.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const pipe = (a) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 ({
     value: a,
     map: (fn) => pipe(fn(a)),

package/dist/functional/result/impl/result-err.mjs

@@ -1,29 +1,29 @@
 import { ErrTypeTagName } from './tag.mjs';
-/**
- * Creates a `Result.Err` containing the given error value.
- *
- * Use this constructor when an operation fails and you want to wrap the error
- * information in a Result type for consistent error handling.
- *
- * @example
- *
- * ```ts
- * const success = Result.ok({ id: 1 });
- *
- * const failure = Result.err(new Error('missing data'));
- *
- * assert.deepStrictEqual(success, {
- *   $$tag: 'ts-data-forge::Result.ok',
- *   value: { id: 1 },
- * });
- *
- * assert.isTrue(Result.isErr(failure));
- * ```
- *
- * @template E The type of the error value.
- * @param value The error value.
- * @returns A `Result.Err<E>` containing the value.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const err = (value) => ({
     $$tag: ErrTypeTagName,
     value,

package/dist/functional/result/impl/result-expect-to-be.mjs

@@ -3,12 +3,12 @@ import { unwrapOk } from './result-unwrap-ok.mjs';
 export function expectToBe(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is result
+
             const [result, message] = args;
             return expectToBeImpl(result, message);
         }
         case 1: {
-            // Curried version: first argument is message
+
             const [message] = args;
             return (result) => expectToBeImpl(result, message);
         }

package/dist/functional/result/impl/result-flat-map.mjs

@@ -2,20 +2,20 @@ import { isErr } from './result-is-err.mjs';
 export function flatMap(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is result
+
             const [result, flatMapFn] = args;
             return flatMapImpl(result, flatMapFn);
         }
         case 1: {
-            // Curried version
+
             const [flatMapFn] = args;
             return (result) => flatMapImpl(result, flatMapFn);
         }
     }
 }
 const flatMapImpl = (result, flatMapFn) => isErr(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         result
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    :
         flatMapFn(result.value);
 //# sourceMappingURL=result-flat-map.mjs.map

package/dist/functional/result/impl/result-fold.mjs

@@ -4,20 +4,20 @@ import { ok } from './result-ok.mjs';
 export function fold(...args) {
     switch (args.length) {
         case 3: {
-            // Direct version: first argument is result
+
             const [result, mapFn, mapErrFn] = args;
             return foldImpl(result, mapFn, mapErrFn);
         }
         case 2: {
-            // Curried version
+
             const [mapFn, mapErrFn] = args;
             return (result) => foldImpl(result, mapFn, mapErrFn);
         }
     }
 }
 const foldImpl = (result, mapFn, mapErrFn) => isOk(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         ok(mapFn(result.value))
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    :
         err(mapErrFn(result.value));
 //# sourceMappingURL=result-fold.mjs.map

package/dist/functional/result/impl/result-from-optional.mjs

@@ -8,14 +8,14 @@ export function fromOptional(...args) {
             return fromOptionalImpl(optional, error);
         }
         case 1: {
-            // Curried version: the only argument is the error value
+
             const [error] = args;
             return (optional) => fromOptionalImpl(optional, error);
         }
     }
 }
 const fromOptionalImpl = (optional, error) => Optional.isSome(optional)
-    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ?
         ok(Optional.unwrap(optional))
     : err(error);
 //# sourceMappingURL=result-from-optional.mjs.map

package/dist/functional/result/impl/result-from-promise.mjs

@@ -1,39 +1,39 @@
 import { err } from './result-err.mjs';
 import { ok } from './result-ok.mjs';
-/**
- * Converts a Promise into a Promise that resolves to a `Result`. If the input
- * Promise resolves, the `Result` will be `Ok` with the resolved value. If the
- * input Promise rejects, the `Result` will be `Err` with the rejection
- * reason.
- *
- * The error channel is `unknown`, since the rejection reason is carried
- * through untouched. For a concrete error type, use `AsyncResult.fromPromise`
- * with a `mapError` function; called without one it behaves exactly as this
- * function does.
- *
- * @example
- *
- * ```ts
- * const successPromise = Result.fromPromise(Promise.resolve('ok'));
- *
- * const failurePromise = Result.fromPromise(
- *   Promise.reject(new Error('fail')),
- * );
- *
- * const resolved = await successPromise;
- *
- * const rejected = await failurePromise;
- *
- * assert.deepStrictEqual(resolved, Result.ok('ok'));
- *
- * assert.isTrue(Result.isErr(rejected));
- * ```
- *
- * @template P The type of the input Promise.
- * @param promise The Promise to convert.
- * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const fromPromise = (promise) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 promise.then((v) => ok(v)).catch(err);
 //# sourceMappingURL=result-from-promise.mjs.map

package/dist/functional/result/impl/result-from-throwable.mjs

@@ -2,35 +2,35 @@ import { isError } from '@sindresorhus/is';
 import { unknownToString } from '../../../others/index.mjs';
 import { err } from './result-err.mjs';
 import { ok } from './result-ok.mjs';
-/**
- * Wraps a function that may throw an exception in a `Result`.
- *
- * This is a fundamental utility for converting traditional exception-based
- * error handling into Result-based error handling. Any thrown value is
- * converted to an Error object for consistent error handling.
- *
- * If the function executes successfully, returns `Result.Ok` with the result.
- * If the function throws, returns `Result.Err` with the caught error.
- *
- * @example
- *
- * ```ts
- * const success = Result.fromThrowable(() => 1 + 1);
- *
- * const failure = Result.fromThrowable(() => {
- *   throw new Error('boom');
- * });
- *
- * assert.deepStrictEqual(success, Result.ok(2));
- *
- * assert.isTrue(Result.isErr(failure));
- * ```
- *
- * @template T The return type of the function.
- * @param fn The function to execute that may throw.
- * @returns A `Result<T, Error>` containing either the successful result or
- *   the caught error.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const fromThrowable = (fn) => {
     try {
         return ok(fn());

package/dist/functional/result/impl/result-is-err.mjs

@@ -1,22 +1,22 @@
 import { ErrTypeTagName } from './tag.mjs';
-/**
- * Type guard for the error variant.
- *
- * @example
- *
- * ```ts
- * const operation = Result.ok(3);
- *
- * const failure = Result.err('error');
- *
- * if (Result.isOk(operation)) {
- *   const value: number = operation.value;
- *
- *   assert.isTrue(value === 3);
- * }
- *
- * assert.isTrue(Result.isErr(failure));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isErr = (result) => result.$$tag === ErrTypeTagName;
 //# sourceMappingURL=result-is-err.mjs.map

package/dist/functional/result/impl/result-is-ok.mjs

@@ -1,22 +1,22 @@
 import { OkTypeTagName } from './tag.mjs';
-/**
- * Type guard for the ok variant.
- *
- * @example
- *
- * ```ts
- * const operation = Result.ok(3);
- *
- * const failure = Result.err('error');
- *
- * if (Result.isOk(operation)) {
- *   const value: number = operation.value;
- *
- *   assert.isTrue(value === 3);
- * }
- *
- * assert.isTrue(Result.isErr(failure));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isOk = (result) => result.$$tag === OkTypeTagName;
 //# sourceMappingURL=result-is-ok.mjs.map

package/dist/functional/result/impl/result-is-result.mjs

@@ -1,24 +1,24 @@
 import { hasKey, isRecord } from '../../../guard/index.mjs';
 import { ErrTypeTagName, OkTypeTagName } from './tag.mjs';
-/**
- * Checks whether the provided value is a {@link Result<S, E>}.
- *
- * @example
- *
- * ```ts
- * const okValue = Result.ok('success');
- *
- * const errValue = Result.err(new Error('failure'));
- *
- * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;
- *
- * assert.isTrue(Result.isResult(okValue));
- *
- * assert.isTrue(Result.isResult(errValue));
- *
- * assert.isFalse(Result.isResult(notResult));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isResult = (maybeResult) => isRecord(maybeResult) &&
     hasKey(maybeResult, '$$tag') &&
     hasKey(maybeResult, 'value') &&

package/dist/functional/result/impl/result-map-err.mjs

@@ -3,20 +3,20 @@ import { isOk } from './result-is-ok.mjs';
 export function mapErr(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is result
+
             const [result, mapFn] = args;
             return mapErrImpl(result, mapFn);
         }
         case 1: {
-            // Curried version: first argument is mapping function
+
             const [mapFn] = args;
             return (result) => mapErrImpl(result, mapFn);
         }
     }
 }
 const mapErrImpl = (result, mapFn) => isOk(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         result
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    :
         err(mapFn(result.value));
 //# sourceMappingURL=result-map-err.mjs.map

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

@@ -3,20 +3,20 @@ import { ok } from './result-ok.mjs';
 export function map(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is result
+
             const [result, mapFn] = args;
             return mapImpl(result, mapFn);
         }
         case 1: {
-            // Curried version
+
             const [mapFn] = args;
             return (result) => mapImpl(result, mapFn);
         }
     }
 }
 const mapImpl = (result, mapFn) => isErr(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         result
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    :
         ok(mapFn(result.value));
 //# sourceMappingURL=result-map.mjs.map