ts-data-forge 5.0.1 → 5.1.1

package/src/functional/result/impl/result-expect-to-be.mts

@@ -11,12 +11,13 @@ import { type UnwrapOk } from './types.mjs';
  * ```ts
  * const okValue = Result.ok('data');
  *
- * assert(Result.expectToBe(okValue, 'should have value') === 'data');
+ * assert.isTrue(Result.expectToBe(okValue, 'should have value') === 'data');
  *
  * const expectResult = Result.expectToBe<string>('missing result');
  *
  * assert.throws(() => expectResult(Result.err('boom')), /missing result/u);
- * assert(expectResult(Result.ok('value')) === 'value');
+ *
+ * assert.isTrue(expectResult(Result.ok('value')) === 'value');
  * ```
  *
  * @template R The `UnknownResult` type to unwrap.
@@ -40,12 +41,14 @@ export function expectToBe<R extends UnknownResult>(
     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: R): UnwrapOk<R> => expectToBeImpl(result, message);
     }
   }

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

@@ -11,15 +11,20 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  * ```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 parsed = Result.flatMap(Result.ok('42'), parseNumber);
+ *
  * const failure = Result.flatMap(Result.ok('abc'), parseNumber);
+ *
  * const passthrough = Result.flatMap(Result.err('fail'), parseNumber);
  *
  * assert.deepStrictEqual(parsed, Result.ok(42));
+ *
  * assert.deepStrictEqual(failure, Result.err('not a number'));
+ *
  * assert.deepStrictEqual(passthrough, Result.err('fail'));
  *
  * const parseThenDouble = Result.flatMap((input: string) =>
@@ -57,12 +62,14 @@ export function flatMap<R extends UnknownResult, S2, E2>(
     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: R) => flatMapImpl(result, flatMapFn);
     }
   }

package/src/functional/result/impl/result-fold.mts

@@ -11,6 +11,7 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = Result.ok(2);
+ *
  * const errValue = Result.err('bad');
  *
  * const foldedOk = Result.fold(
@@ -18,6 +19,7 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *   (value) => value * 2,
  *   (error) => error,
  * );
+ *
  * const foldedErr = Result.fold(
  *   errValue,
  *   (value: number) => value * 2,
@@ -25,6 +27,7 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  * );
  *
  * assert.deepStrictEqual(foldedOk, Result.ok(4));
+ *
  * assert.deepStrictEqual(foldedErr, Result.err('BAD'));
  *
  * const foldNumbers = Result.fold(
@@ -33,6 +36,7 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  * );
  *
  * assert.deepStrictEqual(foldNumbers(Result.ok(3)), Result.ok(9));
+ *
  * assert.deepStrictEqual(foldNumbers(Result.err('oops')), Result.err(4));
  * ```
  *
@@ -72,12 +76,14 @@ export function fold<R extends UnknownResult, S2, E2>(
     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: R) => foldImpl(result, mapFn, mapErrFn);
     }
   }

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

@@ -19,13 +19,16 @@ type UnwrapPromise<P extends Promise<unknown>> =
  *
  * ```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.ok(Result.isErr(rejected));
+ *
+ * assert.isTrue(Result.isErr(rejected));
  * ```
  *
  * @template P The type of the input Promise.

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

@@ -17,12 +17,14 @@ import { ok } from './result-ok.mjs';
  *
  * ```ts
  * const success = Result.fromThrowable(() => 1 + 1);
+ *
  * const failure = Result.fromThrowable(() => {
  *   throw new Error('boom');
  * });
  *
  * assert.deepStrictEqual(success, Result.ok(2));
- * assert.ok(Result.isErr(failure));
+ *
+ * assert.isTrue(Result.isErr(failure));
  * ```
  *
  * @template T The return type of the function.
@@ -37,7 +39,9 @@ export const fromThrowable = <T,>(fn: () => T): Result<T, Error> => {
     if (isError(error)) {
       return err(error);
     }
+
     const msg = unknownToString(error);
+
     return err(new Error(msg));
   }
 };

package/src/functional/result/impl/result-is-err.mts

@@ -8,14 +8,16 @@ import { type NarrowToErr } from './types.mjs';
  *
  * ```ts
  * const operation = Result.ok(3);
+ *
  * const failure = Result.err('error');
  *
  * if (Result.isOk(operation)) {
  *   const value: number = operation.value;
- *   assert(value === 3);
+ *
+ *   assert.isTrue(value === 3);
  * }
  *
- * assert.ok(Result.isErr(failure));
+ * assert.isTrue(Result.isErr(failure));
  * ```
  */
 export const isErr = <R extends UnknownResult>(

package/src/functional/result/impl/result-is-ok.mts

@@ -8,14 +8,16 @@ import { type NarrowToOk } from './types.mjs';
  *
  * ```ts
  * const operation = Result.ok(3);
+ *
  * const failure = Result.err('error');
  *
  * if (Result.isOk(operation)) {
  *   const value: number = operation.value;
- *   assert(value === 3);
+ *
+ *   assert.isTrue(value === 3);
  * }
  *
- * assert.ok(Result.isErr(failure));
+ * assert.isTrue(Result.isErr(failure));
  * ```
  */
 export const isOk = <R extends UnknownResult>(

package/src/functional/result/impl/result-is-result.mts

@@ -8,12 +8,16 @@ import { ErrTypeTagName, OkTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const okValue = Result.ok('success');
+ *
  * const errValue = Result.err(new Error('failure'));
+ *
  * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
  *
- * assert.ok(Result.isResult(okValue));
- * assert.ok(Result.isResult(errValue));
- * assert.notOk(Result.isResult(notResult));
+ * assert.isTrue(Result.isResult(okValue));
+ *
+ * assert.isTrue(Result.isResult(errValue));
+ *
+ * assert.isFalse(Result.isResult(notResult));
  * ```
  */
 export const isResult = (maybeResult: unknown): maybeResult is UnknownResult =>

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

@@ -10,12 +10,15 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = Result.ok(3) as Result<number, string>;
+ *
  * const errValue = Result.err('missing');
  *
  * const untouchedOk = Result.mapErr(okValue, (error) => error.toUpperCase());
+ *
  * const uppercasedErr = Result.mapErr(errValue, (error) => error.toUpperCase());
  *
  * assert.deepStrictEqual(untouchedOk, Result.ok(3));
+ *
  * assert.deepStrictEqual(uppercasedErr, Result.err('MISSING'));
  *
  * const mapError = Result.mapErr((error: Readonly<Error>) => error.message);
@@ -50,12 +53,14 @@ export function mapErr<R extends UnknownResult, E2>(
     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: R) => mapErrImpl(result, mapFn);
     }
   }

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

@@ -11,17 +11,21 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okNumber = Result.ok(5);
+ *
  * const errMessage = Result.err('error');
  *
  * const doubled = Result.map(okNumber, (value) => value * 2);
+ *
  * const untouchedError = Result.map(errMessage, (value: number) => value * 2);
  *
  * assert.deepStrictEqual(doubled, Result.ok(10));
+ *
  * assert.deepStrictEqual(untouchedError, errMessage);
  *
  * const mapToLength = Result.map((text: string) => text.length);
  *
  * assert.deepStrictEqual(mapToLength(Result.ok('abc')), Result.ok(3));
+ *
  * assert.deepStrictEqual(mapToLength(Result.err('bad')), Result.err('bad'));
  * ```
  *
@@ -51,12 +55,14 @@ export function map<R extends UnknownResult, S2>(
     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: R) => mapImpl(result, mapFn);
     }
   }

package/src/functional/result/impl/result-ok.mts

@@ -10,20 +10,22 @@ import { OkTypeTagName } from './tag.mjs';
  *
  * ```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.ok(Result.isErr(failure));
+ *
+ * assert.isTrue(Result.isErr(failure));
  * ```
  *
  * @template S The type of the success value.
  * @param value The success value.
  * @returns A `Result.Ok<S>` containing the value.
  */
-export const ok = <S,>(value: S): Ok<S> => ({
+export const ok = <const S,>(value: S): Ok<S> => ({
   $$tag: OkTypeTagName,
   value,
 });

package/src/functional/result/impl/result-or-else.mts

@@ -8,10 +8,13 @@ import { type NarrowToOk } from './types.mjs';
  *
  * ```ts
  * const primary = Result.ok('primary');
+ *
  * const fallback = Result.ok('fallback');
+ *
  * const failure = Result.err('failure');
  *
  * assert.deepStrictEqual(Result.orElse(primary, fallback), primary);
+ *
  * assert.deepStrictEqual(Result.orElse(failure, fallback), fallback);
  *
  * const orElseFallback = Result.orElse(Result.ok('default'));
@@ -20,6 +23,7 @@ import { type NarrowToOk } from './types.mjs';
  *   orElseFallback(Result.err('missing')),
  *   Result.ok('default'),
  * );
+ *
  * assert.deepStrictEqual(orElseFallback(Result.ok('value')), Result.ok('value'));
  * ```
  *
@@ -46,12 +50,14 @@ export function orElse<R extends UnknownResult, R2 extends UnknownResult>(
     case 2: {
       // Direct version: first argument is result
       const [result, alternative] = args;
+
       return orElseImpl(result, alternative);
     }
 
     case 1: {
       // Curried version
       const [alternative] = args;
+
       return (result: R) => orElseImpl(result, alternative);
     }
   }

package/src/functional/result/impl/result-swap.mts

@@ -11,9 +11,11 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = Result.ok('value');
+ *
  * const errValue = Result.err('error');
  *
  * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));
+ *
  * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));
  * ```
  *

package/src/functional/result/impl/result-to-optional.mts

@@ -17,9 +17,11 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = Result.ok(7);
+ *
  * const errValue = Result.err('fail');
  *
  * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));
+ *
  * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);
  * ```
  *

package/src/functional/result/impl/result-unwrap-err-or.mts

@@ -9,15 +9,18 @@ import { type UnwrapErr } from './types.mjs';
  *
  * ```ts
  * const okResult = Result.ok('success');
+ *
  * const errResult = Result.err('failure');
  *
- * assert(Result.unwrapErrOr(okResult, 'default') === 'default');
- * assert(Result.unwrapErrOr(errResult, 'default') === 'failure');
+ * assert.isTrue(Result.unwrapErrOr(okResult, 'default') === 'default');
+ *
+ * assert.isTrue(Result.unwrapErrOr(errResult, 'default') === 'failure');
  *
  * const unwrapError = Result.unwrapErrOr('fallback error');
  *
- * assert(unwrapError(Result.err('boom')) === 'boom');
- * assert(unwrapError(Result.ok('no error')) === 'fallback error');
+ * assert.isTrue(unwrapError(Result.err('boom')) === 'boom');
+ *
+ * assert.isTrue(unwrapError(Result.ok('no error')) === 'fallback error');
  * ```
  *
  * @template R The `UnknownResult` type to unwrap.
@@ -43,12 +46,14 @@ export function unwrapErrOr<R extends UnknownResult, D>(
     case 2: {
       // Direct version: first argument is result
       const [result, defaultValue] = args;
+
       return unwrapErrOrImpl(result, defaultValue);
     }
 
     case 1: {
       // Curried version
       const [defaultValue] = args;
+
       return (result: R) => unwrapErrOrImpl(result, defaultValue);
     }
   }

package/src/functional/result/impl/result-unwrap-err-throw.mts

@@ -15,9 +15,11 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const errResult = Result.err(new Error('broken'));
+ *
  * const okResult = Result.ok('value');
  *
- * assert(Result.unwrapErrThrow(errResult).message === 'broken');
+ * assert.isTrue(Result.unwrapErrThrow(errResult).message === 'broken');
+ *
  * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
  * ```
  *

package/src/functional/result/impl/result-unwrap-err.mts

@@ -13,16 +13,17 @@ import { type UnwrapErr } from './types.mjs';
  *
  * ```ts
  * const okResult = Result.ok('data');
+ *
  * const errResult = Result.err('problem');
  *
  * // Result.unwrapErr returns undefined for Ok results
  *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
- * assert(Result.unwrapErr(okResult) === undefined);
+ * assert.isTrue(Result.unwrapErr(okResult) === undefined);
  *
  * // Result.unwrapErr returns the error value for Err results
  *
- * assert(Result.unwrapErr(errResult) === 'problem');
+ * assert.isTrue(Result.unwrapErr(errResult) === 'problem');
  * ```
  *
  * @template R The `UnknownResult` type to unwrap.

package/src/functional/result/impl/result-unwrap-ok-or.mts

@@ -9,15 +9,18 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = Result.ok(10);
+ *
  * const errValue = Result.err('fail');
  *
- * assert(Result.unwrapOkOr(okValue, 0) === 10);
- * assert(Result.unwrapOkOr(errValue, 0) === 0);
+ * assert.isTrue(Result.unwrapOkOr(okValue, 0) === 10);
+ *
+ * assert.isTrue(Result.unwrapOkOr(errValue, 0) === 0);
  *
  * const unwrapWithDefault = Result.unwrapOkOr(5);
  *
- * assert(unwrapWithDefault(Result.ok(3)) === 3);
- * assert(unwrapWithDefault(Result.err('no data')) === 5);
+ * assert.isTrue(unwrapWithDefault(Result.ok(3)) === 3);
+ *
+ * assert.isTrue(unwrapWithDefault(Result.err('no data')) === 5);
  * ```
  *
  * @template R The `UnknownResult` type to unwrap.
@@ -43,12 +46,14 @@ export function unwrapOkOr<R extends UnknownResult, D>(
     case 2: {
       // Direct version: first argument is result
       const [result, defaultValue] = args;
+
       return unwrapOkOrImpl(result, defaultValue);
     }
 
     case 1: {
       // Curried version
       const [defaultValue] = args;
+
       return (result: R) => unwrapOkOrImpl(result, defaultValue);
     }
   }

package/src/functional/result/impl/result-unwrap-ok.mts

@@ -8,19 +8,21 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okResult = Result.ok(42);
+ *
  * const errResult = Result.err('oops');
  *
  * // Result.unwrapOk returns the value for Ok results
  *
- * assert(Result.unwrapOk(okResult) === 42);
+ * assert.isTrue(Result.unwrapOk(okResult) === 42);
  *
  * // Result.unwrapOk returns undefined for Err results
  *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
- * assert(Result.unwrapOk(errResult) === undefined);
+ * assert.isTrue(Result.unwrapOk(errResult) === undefined);
  * ```
  */
 export function unwrapOk<R extends Ok<unknown>>(result: R): UnwrapOk<R>;
+
 export function unwrapOk<R extends UnknownResult>(
   result: R,
 ): UnwrapOk<R> | undefined;

package/src/functional/result/impl/result-unwrap-throw.mts

@@ -15,9 +15,11 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okResult = Result.ok('data');
+ *
  * const errResult = Result.err(new Error('fail'));
  *
- * assert(Result.unwrapThrow(okResult) === 'data');
+ * assert.isTrue(Result.unwrapThrow(okResult) === 'data');
+ *
  * assert.throws(() => Result.unwrapThrow(errResult), /fail/u);
  * ```
  *

package/src/functional/result/impl/result-zip.mts

@@ -9,11 +9,13 @@ import { ok } from './result-ok.mjs';
  *
  * ```ts
  * const first = Result.ok('left');
+ *
  * const second = Result.ok(1);
  *
- * const expected: readonly [string, number] = ['left', 1];
+ * const expected = ['left', 1] as const;
  *
  * assert.deepStrictEqual(Result.zip(first, second), Result.ok(expected));
+ *
  * assert.deepStrictEqual(
  *   Result.zip(first, Result.err('error')),
  *   Result.err('error'),