ts-data-forge 14.6.2 → 14.6.3

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

@@ -6,15 +6,15 @@ export function match(...args) {
             return matchImpl(result, cases);
         }
         case 1: {
-            // Curried version: the only argument is the case handlers
+
             const [cases] = args;
             return (result) => matchImpl(result, cases);
         }
     }
 }
 const matchImpl = (result, cases) => isOk(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         cases.ok(result.value)
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    :
         cases.err(result.value);
 //# sourceMappingURL=result-match.mjs.map

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

@@ -1,29 +1,29 @@
 import { OkTypeTagName } from './tag.mjs';
-/**
- * Creates a `Result.Ok` containing the given success value.
- *
- * Use this constructor when an operation succeeds and you want to wrap the
- * successful result 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 S The type of the success value.
- * @param value The success value.
- * @returns A `Result.Ok<S>` containing the value.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const ok = (value) => ({
     $$tag: OkTypeTagName,
     value,

package/dist/functional/result/impl/result-or-else.mjs

@@ -2,12 +2,12 @@ import { isOk } from './result-is-ok.mjs';
 export function orElse(...args) {
     switch (args.length) {
         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) => orElseImpl(result, alternative);
         }

package/dist/functional/result/impl/result-safe-try.mjs

@@ -1,15 +1,15 @@
 import { hasKey, isRecord } from '../../../guard/index.mjs';
 export function safeTry(body) {
     const generator = body();
-    // A yielded `Err` and a returned `Result` are both already the final
-    // answer, so the first step's `value` is the result in either case: the
-    // generator is closed rather than resumed after yielding.
+
+
+
     const step = generator.next();
     if (isSyncStep(step)) {
-        // Dropping a suspended generator would skip the `finally` blocks and
-        // `using` disposals still pending in the body; closing it runs them
-        // before the short-circuited `Err` is handed back. `isSyncGenerator` is
-        // what makes `return()` here synchronous rather than a floating promise.
+
+
+
+
         if (step.done !== true && isSyncGenerator(generator, step)) {
             generator.return(step.value);
         }
@@ -22,14 +22,14 @@ export function safeTry(body) {
         return asyncStep.value;
     });
 }
-// A sync generator's `next()` returns a plain `{ value, done }` object with
-// own properties, while an async generator's returns a `Promise`, whose
-// `then` lives on the prototype — so an own-key check on `done` separates the
-// two.
+
+
+
+
 const isSyncStep = (value) => isRecord(value) && hasKey(value, 'done');
-// The generator-side counterpart of `isSyncStep`: a step in the sync form can
-// only have come from a sync generator, so the step is what narrows the
-// generator that produced it — hence the predicate reads its second argument
-// and not its first.
+
+
+
+
 const isSyncGenerator = (_generator, step) => isSyncStep(step);
 //# sourceMappingURL=result-safe-try.mjs.map

package/dist/functional/result/impl/result-safe-unwrap.mjs

@@ -1,42 +1,42 @@
 import { isErr } from './result-is-err.mjs';
-/**
- * Unwraps a `Result` inside a {@link Result.safeTry} generator body via
- * `yield*`, emulating Rust's `?` operator.
- *
- * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained
- * value and execution continues. If it is `Err`, the error is yielded to
- * {@link Result.safeTry}, which returns it immediately — the rest of the
- * generator body never runs.
- *
- * This generator must only be delegated to (`yield*`) inside a
- * {@link Result.safeTry} body; resuming it after it has yielded an `Err`
- * throws.
- *
- * @example
- *
- * ```ts
- * const result = Result.safeTry(function* () {
- *   const x = yield* Result.safeUnwrap(Result.ok(2));
- *
- *   const y = yield* Result.safeUnwrap(Result.ok(3));
- *
- *   return Result.ok(x + y);
- * });
- *
- * assert.deepStrictEqual(result, Result.ok(5));
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to unwrap.
- * @returns A generator that yields the `Err` (if any) and returns the `Ok`
- *   value.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export function* safeUnwrap(result) {
     if (isErr(result)) {
         yield result;
         throw new Error('`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`');
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result.value;
 }
 //# sourceMappingURL=result-safe-unwrap.mjs.map

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

@@ -2,26 +2,26 @@ import { err } from './result-err.mjs';
 import { isOk } from './result-is-ok.mjs';
 import { ok } from './result-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
-/**
- * Swaps the success and error values of a `Result`.
- *
- * @example
- *
- * ```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'));
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to swap.
- * @returns A new `Result` with success and error swapped.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const swap = (result) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 isOk(result) ? err(unwrapOk(result)) : ok(result.value);
 //# sourceMappingURL=result-swap.mjs.map

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

@@ -1,32 +1,32 @@
 import { Optional } from '../../optional/index.mjs';
 import { isOk } from './result-is-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
-/**
- * Converts a `Result` to an `Optional`.
- *
- * This conversion is useful when you want to discard error information and
- * only care about whether an operation succeeded. The error information is
- * lost in this conversion, so use it when error details are not needed.
- *
- * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is
- * `Err`, returns `None`.
- *
- * @example
- *
- * ```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);
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to convert.
- * @returns An `Optional<UnwrapOk<R>>` containing the success value or
- *   representing `None`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const toOptional = (result) => isOk(result) ? Optional.some(unwrapOk(result)) : Optional.none;
 //# sourceMappingURL=result-to-optional.mjs.map

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

@@ -2,12 +2,12 @@ import { unwrapErr } from './result-unwrap-err.mjs';
 export function unwrapErrOr(...args) {
     switch (args.length) {
         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) => unwrapErrOrImpl(result, defaultValue);
         }

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

@@ -1,38 +1,38 @@
 import { unknownToString } from '../../../others/index.mjs';
 import { match } from '../../match.mjs';
 import { isErr } from './result-is-err.mjs';
-/**
- * Unwraps a `Result`, returning the error value. Throws an error if the
- * `Result` is `Result.Ok`.
- *
- * This function is used when you expect a Result to be an error and want to
- * extract the error value. If the Result is unexpectedly Ok, it will throw an
- * error with information about the unexpected success value.
- *
- * @example
- *
- * ```ts
- * const errResult = Result.err(new Error('broken'));
- *
- * const okResult = Result.ok('value');
- *
- * assert.isTrue(Result.unwrapErrThrow(errResult).message === 'broken');
- *
- * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @param toStr An optional function to convert the success value to a string
- *   for the error message when the Result is unexpectedly Ok. Defaults to
- *   `String`.
- * @returns The error value if `Result.Err`.
- * @throws {Error} Error with message "Expected Err but got Ok: {value}" if
- *   the `Result` is `Result.Ok`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapErrThrow = (result, toStr = unknownToString) => {
     if (isErr(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return result.value;
     }
     const variant = match(result.$$tag, {
@@ -40,7 +40,7 @@ export const unwrapErrThrow = (result, toStr = unknownToString) => {
         'ts-data-forge::Result.err': 'Err',
     });
     throw new Error(`Expected Err but got ${variant}: ${toStr(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     result.value)}`);
 };
 //# sourceMappingURL=result-unwrap-err-throw.mjs.map

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

@@ -1,34 +1,34 @@
 import { isErr } from './result-is-err.mjs';
-/**
- * Unwraps a `Result`, returning the error value or `undefined` if it is
- * `Result.Ok`.
- *
- * This provides a safe way to extract error values from Results without
- * throwing exceptions. Useful for error handling patterns where you want to
- * check for specific error conditions.
- *
- * @example
- *
- * ```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.isTrue(Result.unwrapErr(okResult) === undefined);
- *
- * // Result.unwrapErr returns the error value for Err results
- *
- * assert.isTrue(Result.unwrapErr(errResult) === 'problem');
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @returns The error value if `Result.Err`, otherwise `undefined`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapErr = (result) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 isErr(result) ? result.value : undefined;
 //# sourceMappingURL=result-unwrap-err.mjs.map

package/dist/functional/result/impl/result-unwrap-ok-or.mjs

@@ -2,12 +2,12 @@ import { unwrapOk } from './result-unwrap-ok.mjs';
 export function unwrapOkOr(...args) {
     switch (args.length) {
         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) => unwrapOkOrImpl(result, defaultValue);
         }

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

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

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

@@ -1,40 +1,40 @@
 import { unknownToString } from '../../../others/index.mjs';
 import { isErr } from './result-is-err.mjs';
-/**
- * Unwraps a `Result`, returning the success value. Throws an error if the
- * `Result` is `Result.Err`.
- *
- * This is useful when you're confident that a Result should contain a success
- * value and want to treat errors as exceptional conditions. The error message
- * will be constructed from the error value using the provided string
- * conversion function.
- *
- * @example
- *
- * ```ts
- * const okResult = Result.ok('data');
- *
- * const errResult = Result.err(new Error('fail'));
- *
- * assert.isTrue(Result.unwrapThrow(okResult) === 'data');
- *
- * assert.throws(() => Result.unwrapThrow(errResult), Error, 'fail');
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @param toStr An optional function to convert the error value to a string
- *   for the error message. Defaults to `String`.
- * @returns The success value if `Result.Ok`.
- * @throws {Error} Error with the stringified error value if the `Result` is
- *   `Result.Err`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapThrow = (result, toStr = unknownToString) => {
     if (isErr(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         throw new Error(toStr(result.value));
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result.value;
 };
 //# sourceMappingURL=result-unwrap-throw.mjs.map

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

@@ -1,34 +1,34 @@
 import { isOk } from './result-is-ok.mjs';
 import { ok } from './result-ok.mjs';
-/**
- * Combines two `Result` values into a single `Result` containing a tuple. If
- * either `Result` is `Err`, returns the first `Err` encountered.
- *
- * @example
- *
- * ```ts
- * const first = Result.ok('left');
- *
- * const second = Result.ok(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'),
- * );
- * ```
- *
- * @template S1 The success type of the first `Result`.
- * @template E1 The error type of the first `Result`.
- * @template S2 The success type of the second `Result`.
- * @template E2 The error type of the second `Result`.
- * @param resultA The first `Result`.
- * @param resultB The second `Result`.
- * @returns A `Result` containing a tuple of both values, or the first `Err`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const zip = (resultA, resultB) => isOk(resultA)
     ? isOk(resultB)
         ? ok([resultA.value, resultB.value])

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

@@ -1,4 +1,4 @@
 export const OkTypeTagName = 'ts-data-forge::Result.ok';
-/** @internal Tag identifying the Err variant. */
+
 export const ErrTypeTagName = 'ts-data-forge::Result.err';
 //# sourceMappingURL=tag.mjs.map

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

@@ -1,6 +1,6 @@
 export const OkTypeTagName = 'ts-data-forge::Result.ok';
-/** @internal Tag identifying the Warn variant. */
+
 export const WarnTypeTagName = 'ts-data-forge::Result.warn';
-/** @internal Tag identifying the Err variant. */
+
 export const ErrTypeTagName = 'ts-data-forge::Result.err';
 //# sourceMappingURL=tag.mjs.map