ts-data-forge 5.0.0 → 5.1.0

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,12 +10,14 @@ 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));
  * ```
  *
@@ -23,7 +25,7 @@ import { OkTypeTagName } from './tag.mjs';
  * @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,14 +9,17 @@ 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');
  *
  * const unwrapError = Result.unwrapErrOr('fallback error');
  *
  * assert(unwrapError(Result.err('boom')) === 'boom');
+ *
  * assert(unwrapError(Result.ok('no error')) === 'fallback error');
  * ```
  *
@@ -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.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
  * ```
  *

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

@@ -13,6 +13,7 @@ import { type UnwrapErr } from './types.mjs';
  *
  * ```ts
  * const okResult = Result.ok('data');
+ *
  * const errResult = Result.err('problem');
  *
  * // Result.unwrapErr returns undefined for Ok results

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

@@ -9,14 +9,17 @@ 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);
  *
  * const unwrapWithDefault = Result.unwrapOkOr(5);
  *
  * assert(unwrapWithDefault(Result.ok(3)) === 3);
+ *
  * assert(unwrapWithDefault(Result.err('no data')) === 5);
  * ```
  *
@@ -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,6 +8,7 @@ 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
@@ -21,6 +22,7 @@ import { type UnwrapOk } from './types.mjs';
  * ```
  */
 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.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'),