ts-data-forge 9.0.0 → 10.0.0

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

@@ -3,24 +3,24 @@ import { isOk } from './result-is-ok.mjs';
 import { ok } from './result-ok.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 3: {
+      const [result, mapFn, mapErrFn] = args;
+      return foldImpl(result, mapFn, mapErrFn);
     }
+    case 2: {
+      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));
+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))
+);
 
 export { fold };
 //# sourceMappingURL=result-fold.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-fold.mjs","sources":["../../../../src/functional/result/impl/result-fold.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA+DM,SAAU,IAAI,CAClB,GAAG,IASE,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;YAEN,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI;YAEtC,OAAO,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;QAC1C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,CAAC,MAAS,KAAK,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;QACzD;;AAEJ;AAEA,MAAM,QAAQ,GAAG,CACf,MAAS,EACT,KAAiC,EACjC,QAAqC,KAErC,IAAI,CAAC,MAAM;AACT;AACE,QAAA,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC;AACvC;QACE,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;;;;"}
+{"version":3,"file":"result-fold.mjs","sources":["../../../../src/functional/result/impl/result-fold.mts"],"sourcesContent":["import { type Result, type UnknownResult } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { ok } from './result-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Applies one of two functions depending on whether the `Result` is `Ok` or\n * `Err`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(2);\n *\n * const errValue = Result.err('bad');\n *\n * const foldedOk = Result.fold(\n *   okValue,\n *   (value) => value * 2,\n *   (error) => error,\n * );\n *\n * const foldedErr = Result.fold(\n *   errValue,\n *   (value: number) => value * 2,\n *   (error) => error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(foldedOk, Result.ok(4));\n *\n * assert.deepStrictEqual(foldedErr, Result.err('BAD'));\n *\n * const foldNumbers = Result.fold(\n *   (value: number) => value * 3,\n *   (error: string) => error.length,\n * );\n *\n * assert.deepStrictEqual(foldNumbers(Result.ok(3)), Result.ok(9));\n *\n * assert.deepStrictEqual(foldNumbers(Result.err('oops')), Result.err(4));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type of the success value returned by `mapFn`.\n * @template E2 The type of the error value returned by `mapErrFn`.\n * @param result The `Result` to fold.\n * @param mapFn The function to apply if `result` is `Ok`.\n * @param mapErrFn The function to apply if `result` is `Err`.\n * @returns A new `Result<S2, E2>` based on the applied function.\n */\nexport function fold<R extends UnknownResult, S2, E2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n  mapErrFn: (error: UnwrapErr<R>) => E2,\n): Result<S2, E2>;\n\n// Curried version\nexport function fold<S, E, S2, E2>(\n  mapFn: (value: S) => S2,\n  mapErrFn: (error: E) => E2,\n): (result: Result<S, E>) => Result<S2, E2>;\n\nexport function fold<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        mapFn: (value: UnwrapOk<R>) => S2,\n        mapErrFn: (error: UnwrapErr<R>) => E2,\n      ]\n    | readonly [\n        mapFn: (value: UnwrapOk<R>) => S2,\n        mapErrFn: (error: UnwrapErr<R>) => E2,\n      ]\n): Result<S2, E2> | ((result: R) => Result<S2, E2>) {\n  switch (args.length) {\n    case 3: {\n      // Direct version: first argument is result\n      const [result, mapFn, mapErrFn] = args;\n\n      return foldImpl(result, mapFn, mapErrFn);\n    }\n\n    case 2: {\n      // Curried version\n      const [mapFn, mapErrFn] = args;\n\n      return (result: R) => foldImpl(result, mapFn, mapErrFn);\n    }\n  }\n}\n\nconst foldImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n  mapErrFn: (error: UnwrapErr<R>) => E2,\n): Result<S2, E2> =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ok(mapFn(result.value as UnwrapOk<R>))\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      err(mapErrFn(result.value as UnwrapErr<R>));\n"],"names":[],"mappings":";;;;AA+DO,SAAS,QACX,IAAA,EAU+C;AAClD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAElC,MAAA,OAAO,QAAA,CAAS,MAAA,EAAQ,KAAA,EAAO,QAAQ,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,CAAC,MAAA,KAAc,QAAA,CAAS,MAAA,EAAQ,OAAO,QAAQ,CAAA;AAAA,IACxD;AAAA;AAEJ;AAEA,MAAM,WAAW,CACf,MAAA,EACA,KAAA,EACA,QAAA,KAEA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEP,EAAA,CAAG,KAAA,CAAM,MAAA,CAAO,KAAoB,CAAC;AAAA;AAAA;AAAA,EAErC,GAAA,CAAI,QAAA,CAAS,MAAA,CAAO,KAAqB,CAAC;AAAA,CAAA;;;;"}

package/dist/functional/result/impl/result-from-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,EACpD,SAAS,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}
+{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,WAC3C,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}

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

@@ -1,37 +1,10 @@
 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.
- *
- * @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>`.
- */
-const fromPromise = (promise) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-promise.then((v) => ok(v)).catch(err);
+const fromPromise = (promise) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  promise.then((v) => ok(v)).catch(err)
+);
 
 export { fromPromise };
 //# sourceMappingURL=result-from-promise.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,WAAW,GAAG,CACzB,OAAU;AAEV;AACA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAyB,CAAC,CAAC,KAAK,CAAC,GAAG;;;;"}
+{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AAyCO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}

package/dist/functional/result/impl/result-from-throwable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-from-throwable.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAG,IAAI,MAAM,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAY9D,CAAC"}
+{"version":3,"file":"result-from-throwable.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,MAAO,MAAM,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAY9D,CAAC"}

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

@@ -3,46 +3,16 @@ import { unknownToString } from '../../../others/unknown-to-string.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.
- */
 const fromThrowable = (fn) => {
-    try {
-        return ok(fn());
-    }
-    catch (error) {
-        if (isError(error)) {
-            return err(error);
-        }
-        const msg = unknownToString(error);
-        return err(new Error(msg));
+  try {
+    return ok(fn());
+  } catch (error) {
+    if (isError(error)) {
+      return err(error);
     }
+    const msg = unknownToString(error);
+    return err(new Error(msg));
+  }
 };
 
 export { fromThrowable };

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-throwable.mjs","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,aAAa,GAAG,CAAK,EAAW,KAAsB;AACjE,IAAA,IAAI;AACF,QAAA,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;IACjB;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;AAClB,YAAA,OAAO,GAAG,CAAC,KAAK,CAAC;QACnB;AAEA,QAAA,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC;QAElC,OAAO,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5B;AACF;;;;"}
+{"version":3,"file":"result-from-throwable.mjs","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"sourcesContent":["import { isError } from '@sindresorhus/is';\nimport { unknownToString } from '../../../others/index.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * Wraps a function that may throw an exception in a `Result`.\n *\n * This is a fundamental utility for converting traditional exception-based\n * error handling into Result-based error handling. Any thrown value is\n * converted to an Error object for consistent error handling.\n *\n * If the function executes successfully, returns `Result.Ok` with the result.\n * If the function throws, returns `Result.Err` with the caught error.\n *\n * @example\n *\n * ```ts\n * const success = Result.fromThrowable(() => 1 + 1);\n *\n * const failure = Result.fromThrowable(() => {\n *   throw new Error('boom');\n * });\n *\n * assert.deepStrictEqual(success, Result.ok(2));\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n *\n * @template T The return type of the function.\n * @param fn The function to execute that may throw.\n * @returns A `Result<T, Error>` containing either the successful result or\n *   the caught error.\n */\nexport const fromThrowable = <T,>(fn: () => T): Result<T, Error> => {\n  try {\n    return ok(fn());\n  } catch (error) {\n    if (isError(error)) {\n      return err(error);\n    }\n\n    const msg = unknownToString(error);\n\n    return err(new Error(msg));\n  }\n};\n"],"names":[],"mappings":";;;;;AAmCO,MAAM,aAAA,GAAgB,CAAK,EAAA,KAAkC;AAClE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,CAAG,IAAI,CAAA;AAAA,EAChB,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,OAAA,CAAQ,KAAK,CAAA,EAAG;AAClB,MAAA,OAAO,IAAI,KAAK,CAAA;AAAA,IAClB;AAEA,IAAA,MAAM,GAAA,GAAM,gBAAgB,KAAK,CAAA;AAEjC,IAAA,OAAO,GAAA,CAAI,IAAI,KAAA,CAAM,GAAG,CAAC,CAAA;AAAA,EAC3B;AACF;;;;"}

package/dist/functional/result/impl/result-is-err.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,aAAa,EAC3C,QAAQ,CAAC,KACR,MAAM,IAAI,WAAW,CAAC,CAAC,CAAoC,CAAC"}
+{"version":3,"file":"result-is-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,aAAa,UACnC,CAAC,KACR,MAAM,IAAI,WAAW,CAAC,CAAC,CAAoC,CAAC"}

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

@@ -1,24 +1,5 @@
 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));
- * ```
- */
 const isErr = (result) => result.$$tag === ErrTypeTagName;
 
 export { isErr };

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

@@ -1 +1 @@
-{"version":3,"file":"result-is-err.mjs","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,KAAK,GAAG,CACnB,MAAS,KACoB,MAAM,CAAC,KAAK,KAAK;;;;"}
+{"version":3,"file":"result-is-err.mjs","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { ErrTypeTagName } from './tag.mjs';\nimport { type NarrowToErr } from './types.mjs';\n\n/**\n * Type guard for the error variant.\n *\n * @example\n *\n * ```ts\n * const operation = Result.ok(3);\n *\n * const failure = Result.err('error');\n *\n * if (Result.isOk(operation)) {\n *   const value: number = operation.value;\n *\n *   assert.isTrue(value === 3);\n * }\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n */\nexport const isErr = <R extends UnknownResult>(\n  result: R,\n): result is NarrowToErr<R> => result.$$tag === ErrTypeTagName;\n"],"names":[],"mappings":";;AAuBO,MAAM,KAAA,GAAQ,CACnB,MAAA,KAC6B,MAAA,CAAO,KAAA,KAAU;;;;"}

package/dist/functional/result/impl/result-is-ok.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,aAAa,EAC1C,QAAQ,CAAC,KACR,MAAM,IAAI,UAAU,CAAC,CAAC,CAAmC,CAAC"}
+{"version":3,"file":"result-is-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,aAAa,UAClC,CAAC,KACR,MAAM,IAAI,UAAU,CAAC,CAAC,CAAmC,CAAC"}

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

@@ -1,24 +1,5 @@
 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));
- * ```
- */
 const isOk = (result) => result.$$tag === OkTypeTagName;
 
 export { isOk };

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

@@ -1 +1 @@
-{"version":3,"file":"result-is-ok.mjs","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,IAAI,GAAG,CAClB,MAAS,KACmB,MAAM,CAAC,KAAK,KAAK;;;;"}
+{"version":3,"file":"result-is-ok.mjs","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { OkTypeTagName } from './tag.mjs';\nimport { type NarrowToOk } from './types.mjs';\n\n/**\n * Type guard for the ok variant.\n *\n * @example\n *\n * ```ts\n * const operation = Result.ok(3);\n *\n * const failure = Result.err('error');\n *\n * if (Result.isOk(operation)) {\n *   const value: number = operation.value;\n *\n *   assert.isTrue(value === 3);\n * }\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n */\nexport const isOk = <R extends UnknownResult>(\n  result: R,\n): result is NarrowToOk<R> => result.$$tag === OkTypeTagName;\n"],"names":[],"mappings":";;AAuBO,MAAM,IAAA,GAAO,CAClB,MAAA,KAC4B,MAAA,CAAO,KAAA,KAAU;;;;"}

package/dist/functional/result/impl/result-is-result.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-result.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,GAAI,aAAa,OAAO,KAAG,WAAW,IAAI,aAIgB,CAAC"}
+{"version":3,"file":"result-is-result.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,gBAAiB,OAAO,KAAG,WAAW,IAAI,aAIgB,CAAC"}

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

@@ -2,29 +2,7 @@ import { hasKey } from '../../../guard/has-key.mjs';
 import { isRecord } from '../../../guard/is-record.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));
- * ```
- */
-const isResult = (maybeResult) => isRecord(maybeResult) &&
-    hasKey(maybeResult, '$$tag') &&
-    hasKey(maybeResult, 'value') &&
-    (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);
+const isResult = (maybeResult) => isRecord(maybeResult) && hasKey(maybeResult, "$$tag") && hasKey(maybeResult, "value") && (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);
 
 export { isResult };
 //# sourceMappingURL=result-is-result.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-is-result.mjs","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,QAAQ,GAAG,CAAC,WAAoB,KAC3C,QAAQ,CAAC,WAAW,CAAC;AACrB,IAAA,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC;AAC5B,IAAA,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC;AAC5B,KAAC,WAAW,CAAC,KAAK,KAAK,cAAc,IAAI,WAAW,CAAC,KAAK,KAAK,aAAa;;;;"}
+{"version":3,"file":"result-is-result.mjs","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { ErrTypeTagName, OkTypeTagName } from './tag.mjs';\n\n/**\n * Checks whether the provided value is a {@link Result<S, E>}.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('success');\n *\n * const errValue = Result.err(new Error('failure'));\n *\n * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;\n *\n * assert.isTrue(Result.isResult(okValue));\n *\n * assert.isTrue(Result.isResult(errValue));\n *\n * assert.isFalse(Result.isResult(notResult));\n * ```\n */\nexport const isResult = (maybeResult: unknown): maybeResult is UnknownResult =>\n  isRecord(maybeResult) &&\n  hasKey(maybeResult, '$$tag') &&\n  hasKey(maybeResult, 'value') &&\n  (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);\n"],"names":[],"mappings":";;;;AAuBO,MAAM,WAAW,CAAC,WAAA,KACvB,SAAS,WAAW,CAAA,IACpB,OAAO,WAAA,EAAa,OAAO,CAAA,IAC3B,MAAA,CAAO,aAAa,OAAO,CAAA,KAC1B,YAAY,KAAA,KAAU,cAAA,IAAkB,YAAY,KAAA,KAAU,aAAA;;;;"}

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

@@ -2,24 +2,24 @@ import { err } from './result-err.mjs';
 import { isOk } from './result-is-ok.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, mapFn] = args;
+      return mapErrImpl(result, mapFn);
     }
+    case 1: {
+      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));
+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))
+);
 
 export { mapErr };
 //# sourceMappingURL=result-map-err.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-map-err.mjs","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAkDM,SAAU,MAAM,CACpB,GAAG,IAE8C,EAAA;AAEjD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI;AAE5B,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC;QAClC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YAEpB,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC;QACjD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,KAAkC,KAElC,IAAI,CAAC,MAAM;AACT;QACG;AACH;QACE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;;;;"}
+{"version":3,"file":"result-map-err.mjs","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Maps a `Result<S, E>` to `Result<S, E2>` by applying a function to the\n * error value. If the `Result` is `Result.Ok`, returns the original `Ok`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(3) as Result<number, string>;\n *\n * const errValue = Result.err('missing');\n *\n * const untouchedOk = Result.mapErr(okValue, (error) => error.toUpperCase());\n *\n * const uppercasedErr = Result.mapErr(errValue, (error) =>\n *   error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(untouchedOk, Result.ok(3));\n *\n * assert.deepStrictEqual(uppercasedErr, Result.err('MISSING'));\n *\n * const mapError = Result.mapErr((error: Readonly<Error>) => error.message);\n *\n * const wrapped = mapError(Result.err(new Error('boom')));\n *\n * assert.deepStrictEqual(wrapped, Result.err('boom'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template E2 The type of the error value returned by the mapping function.\n * @param result The `Result` to map.\n * @param mapFn The function to apply to the error value if present.\n * @returns A new `Result<UnwrapOk<R>, E2>`.\n */\nexport function mapErr<R extends UnknownResult, E2>(\n  result: R,\n  mapFn: (error: UnwrapErr<R>) => E2,\n): Result<UnwrapOk<R>, E2>;\n\n// Curried version\nexport function mapErr<E, E2>(\n  mapFn: (error: E) => E2,\n): <S>(result: Result<S, E>) => Result<S, E2>;\n\nexport function mapErr<R extends UnknownResult, E2>(\n  ...args:\n    | readonly [result: R, mapFn: (error: UnwrapErr<R>) => E2]\n    | readonly [mapFn: (error: UnwrapErr<R>) => E2]\n): Result<UnwrapOk<R>, E2> | ((result: R) => Result<UnwrapOk<R>, E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, mapFn] = args;\n\n      return mapErrImpl(result, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (result: R) => mapErrImpl(result, mapFn);\n    }\n  }\n}\n\nconst mapErrImpl = <R extends UnknownResult, E2>(\n  result: R,\n  mapFn: (error: UnwrapErr<R>) => E2,\n): Result<UnwrapOk<R>, E2> =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result as Ok<UnwrapOk<R>>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      err(mapFn(result.value as UnwrapErr<R>));\n"],"names":[],"mappings":";;;AAkDO,SAAS,UACX,IAAA,EAGiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,UAAA,CAAW,QAAQ,KAAK,CAAA;AAAA,IACjC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,UAAA,CAAW,MAAA,EAAQ,KAAK,CAAA;AAAA,IAChD;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,CACjB,MAAA,EACA,KAAA,KAEA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEN;AAAA;AAAA;AAAA,EAED,GAAA,CAAI,KAAA,CAAM,MAAA,CAAO,KAAqB,CAAC;AAAA,CAAA;;;;"}

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

@@ -2,24 +2,24 @@ import { isErr } from './result-is-err.mjs';
 import { ok } from './result-ok.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, mapFn] = args;
+      return mapImpl(result, mapFn);
     }
+    case 1: {
+      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));
+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))
+);
 
 export { map };
 //# sourceMappingURL=result-map.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-map.mjs","sources":["../../../../src/functional/result/impl/result-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAkDM,SAAU,GAAG,CACjB,GAAG,IAE6C,EAAA;AAEhD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI;AAE5B,YAAA,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;QAC/B;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YAEpB,OAAO,CAAC,MAAS,KAAK,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;QAC9C;;AAEJ;AAEA,MAAM,OAAO,GAAG,CACd,MAAS,EACT,KAAiC,KAEjC,KAAK,CAAC,MAAM;AACV;QACG;AACH;QACE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC,CAAC;;;;"}
+{"version":3,"file":"result-map.mjs","sources":["../../../../src/functional/result/impl/result-map.mts"],"sourcesContent":["import { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { ok } from './result-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Maps a `Result<S, E>` to `Result<S2, E>` by applying a function to the\n * success value. If the `Result` is `Result.Err`, returns the original\n * `Err`.\n *\n * @example\n *\n * ```ts\n * const okNumber = Result.ok(5);\n *\n * const errMessage = Result.err('error');\n *\n * const doubled = Result.map(okNumber, (value) => value * 2);\n *\n * const untouchedError = Result.map(errMessage, (value: number) => value * 2);\n *\n * assert.deepStrictEqual(doubled, Result.ok(10));\n *\n * assert.deepStrictEqual(untouchedError, errMessage);\n *\n * const mapToLength = Result.map((text: string) => text.length);\n *\n * assert.deepStrictEqual(mapToLength(Result.ok('abc')), Result.ok(3));\n *\n * assert.deepStrictEqual(mapToLength(Result.err('bad')), Result.err('bad'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type of the success value returned by the mapping\n *   function.\n * @param result The `Result` to map.\n * @param mapFn The function to apply to the success value if present.\n * @returns A new `Result<S2, UnwrapErr<R>>`.\n */\nexport function map<R extends UnknownResult, S2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n): Result<S2, UnwrapErr<R>>;\n\n// Curried version\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): <E>(result: Result<S, E>) => Result<S2, E>;\n\nexport function map<R extends UnknownResult, S2>(\n  ...args:\n    | readonly [result: R, mapFn: (value: UnwrapOk<R>) => S2]\n    | readonly [mapFn: (value: UnwrapOk<R>) => S2]\n): Result<S2, UnwrapErr<R>> | ((result: R) => Result<S2, UnwrapErr<R>>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, mapFn] = args;\n\n      return mapImpl(result, mapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [mapFn] = args;\n\n      return (result: R) => mapImpl(result, mapFn);\n    }\n  }\n}\n\nconst mapImpl = <R extends UnknownResult, S2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n): Result<S2, UnwrapErr<R>> =>\n  isErr(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result as Err<UnwrapErr<R>>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ok(mapFn(result.value as UnwrapOk<R>));\n"],"names":[],"mappings":";;;AAkDO,SAAS,OACX,IAAA,EAGmE;AACtE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,OAAA,CAAQ,QAAQ,KAAK,CAAA;AAAA,IAC9B;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,OAAA,CAAQ,MAAA,EAAQ,KAAK,CAAA;AAAA,IAC7C;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,CACd,MAAA,EACA,KAAA,KAEA,MAAM,MAAM,CAAA;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA,EAED,EAAA,CAAG,KAAA,CAAM,MAAA,CAAO,KAAoB,CAAC;AAAA,CAAA;;;;"}

package/dist/functional/result/impl/result-ok.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,EAAE,GAAI,KAAK,CAAC,CAAC,EAAG,OAAO,CAAC,KAAG,EAAE,CAAC,CAAC,CAI/B,CAAC"}
+{"version":3,"file":"result-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,EAAE,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,EAAE,CAAC,CAAC,CAI/B,CAAC"}

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

@@ -1,33 +1,8 @@
 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.
- */
 const ok = (value) => ({
-    $$tag: OkTypeTagName,
-    value,
+  $$tag: OkTypeTagName,
+  value
 });
 
 export { ok };

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

@@ -1 +1 @@
-{"version":3,"file":"result-ok.mjs","sources":["../../../../src/functional/result/impl/result-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,EAAE,GAAG,CAAW,KAAQ,MAClC;AACC,IAAA,KAAK,EAAE,aAAa;IACpB,KAAK;AACN,CAAA;;;;"}
+{"version":3,"file":"result-ok.mjs","sources":["../../../../src/functional/result/impl/result-ok.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { OkTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `Result.Ok` containing the given success value.\n *\n * Use this constructor when an operation succeeds and you want to wrap the\n * successful result in a Result type for consistent error handling.\n *\n * @example\n *\n * ```ts\n * const success = Result.ok({ id: 1 });\n *\n * const failure = Result.err(new Error('missing data'));\n *\n * assert.deepStrictEqual(success, {\n *   $$tag: 'ts-data-forge::Result.ok',\n *   value: { id: 1 },\n * });\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n *\n * @template S The type of the success value.\n * @param value The success value.\n * @returns A `Result.Ok<S>` containing the value.\n */\nexport const ok = <const S,>(value: S): Ok<S> =>\n  ({\n    $$tag: OkTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AA4BO,MAAM,EAAA,GAAK,CAAW,KAAA,MAC1B;AAAA,EACC,KAAA,EAAO,aAAA;AAAA,EACP;AACF,CAAA;;;;"}

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

@@ -1,20 +1,18 @@
 import { isOk } from './result-is-ok.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, alternative] = args;
+      return orElseImpl(result, alternative);
     }
+    case 1: {
+      const [alternative] = args;
+      return (result) => orElseImpl(result, alternative);
+    }
+  }
 }
-const orElseImpl = (result, alternative) => (isOk(result) ? result : alternative);
+const orElseImpl = (result, alternative) => isOk(result) ? result : alternative;
 
 export { orElse };
 //# sourceMappingURL=result-or-else.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-or-else.mjs","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAiDM,SAAU,MAAM,CACpB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI;AAElC,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI;YAE1B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACvD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,WAAe,MACS,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC;;;;"}
+{"version":3,"file":"result-or-else.mjs","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type NarrowToOk } from './types.mjs';\n\n/**\n * Returns the `Result` if it is `Ok`, otherwise returns the alternative.\n *\n * @example\n *\n * ```ts\n * const primary = Result.ok('primary');\n *\n * const fallback = Result.ok('fallback');\n *\n * const failure = Result.err('failure');\n *\n * assert.deepStrictEqual(Result.orElse(primary, fallback), primary);\n *\n * assert.deepStrictEqual(Result.orElse(failure, fallback), fallback);\n *\n * const orElseFallback = Result.orElse(Result.ok('default'));\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Result.err('missing')),\n *   Result.ok('default'),\n * );\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Result.ok('value')),\n *   Result.ok('value'),\n * );\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to check.\n * @param alternative The alternative `Result` to return if the first is\n *   `Err`.\n * @returns The first `Result` if `Ok`, otherwise the alternative.\n */\nexport function orElse<R extends UnknownResult, R2 extends UnknownResult>(\n  result: R,\n  alternative: R2,\n): NarrowToOk<R> | R2;\n\n// Curried version\nexport function orElse<R2 extends UnknownResult>(\n  alternative: R2,\n): <R extends UnknownResult>(result: R) => NarrowToOk<R> | R2;\n\nexport function orElse<R extends UnknownResult, R2 extends UnknownResult>(\n  ...args: readonly [result: R, alternative: R2] | readonly [alternative: R2]\n): (NarrowToOk<R> | R2) | ((result: R) => R | R2) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, alternative] = args;\n\n      return orElseImpl(result, alternative);\n    }\n\n    case 1: {\n      // Curried version\n      const [alternative] = args;\n\n      return (result: R) => orElseImpl(result, alternative);\n    }\n  }\n}\n\nconst orElseImpl = <R extends UnknownResult, R2 extends UnknownResult>(\n  result: R,\n  alternative: R2,\n): NarrowToOk<R> | R2 => (isOk(result) ? result : alternative);\n"],"names":[],"mappings":";;AAiDO,SAAS,UACX,IAAA,EAC6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,WAAW,CAAA,GAAI,IAAA;AAE9B,MAAA,OAAO,UAAA,CAAW,QAAQ,WAAW,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAW,CAAA,GAAI,IAAA;AAEtB,MAAA,OAAO,CAAC,MAAA,KAAc,UAAA,CAAW,MAAA,EAAQ,WAAW,CAAA;AAAA,IACtD;AAAA;AAEJ;AAEA,MAAM,aAAa,CACjB,MAAA,EACA,gBACwB,IAAA,CAAK,MAAM,IAAI,MAAA,GAAS,WAAA;;;;"}

package/dist/functional/result/impl/result-swap.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-swap.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-swap.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAKhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,aAAa,EAC1C,QAAQ,CAAC,KACR,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAEsC,CAAC"}
+{"version":3,"file":"result-swap.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-swap.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAKhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,aAAa,UAClC,CAAC,KACR,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAEsC,CAAC"}

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

@@ -3,28 +3,10 @@ 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.
- */
-const swap = (result) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-isOk(result) ? err(unwrapOk(result)) : ok(result.value);
+const swap = (result) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  isOk(result) ? err(unwrapOk(result)) : ok(result.value)
+);
 
 export { swap };
 //# sourceMappingURL=result-swap.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-swap.mjs","sources":["../../../../src/functional/result/impl/result-swap.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAOA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,IAAI,GAAG,CAClB,MAAS;AAET;AACA,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAqB;;;;"}
+{"version":3,"file":"result-swap.mjs","sources":["../../../../src/functional/result/impl/result-swap.mts"],"sourcesContent":["import { type Result, type UnknownResult } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { ok } from './result-ok.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Swaps the success and error values of a `Result`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('value');\n *\n * const errValue = Result.err('error');\n *\n * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));\n *\n * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to swap.\n * @returns A new `Result` with success and error swapped.\n */\nexport const swap = <R extends UnknownResult>(\n  result: R,\n): Result<UnwrapErr<R>, UnwrapOk<R>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  isOk(result) ? err(unwrapOk(result)) : ok(result.value as UnwrapErr<R>);\n"],"names":[],"mappings":";;;;;AA0BO,MAAM,OAAO,CAClB,MAAA;AAAA;AAAA,EAGA,IAAA,CAAK,MAAM,CAAA,GAAI,GAAA,CAAI,QAAA,CAAS,MAAM,CAAC,CAAA,GAAI,EAAA,CAAG,MAAA,CAAO,KAAqB;AAAA;;;;"}

package/dist/functional/result/impl/result-to-optional.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-to-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,aAAa,EAChD,QAAQ,CAAC,KACR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CACyC,CAAC"}
+{"version":3,"file":"result-to-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,aAAa,UACxC,CAAC,KACR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CACyC,CAAC"}

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

@@ -3,33 +3,6 @@ import { some } from '../../optional/impl/optional-some.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`.
- */
 const toOptional = (result) => isOk(result) ? some(unwrapOk(result)) : none;
 
 export { toOptional };

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

@@ -1 +1 @@
-{"version":3,"file":"result-to-optional.mjs","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"sourcesContent":[null],"names":["Optional.some","Optional.none"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,UAAU,GAAG,CACxB,MAAS,KAET,IAAI,CAAC,MAAM,CAAC,GAAGA,IAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAGC;;;;"}
+{"version":3,"file":"result-to-optional.mjs","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"sourcesContent":["import { Optional } from '../../optional/index.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Converts a `Result` to an `Optional`.\n *\n * This conversion is useful when you want to discard error information and\n * only care about whether an operation succeeded. The error information is\n * lost in this conversion, so use it when error details are not needed.\n *\n * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is\n * `Err`, returns `None`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(7);\n *\n * const errValue = Result.err('fail');\n *\n * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));\n *\n * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to convert.\n * @returns An `Optional<UnwrapOk<R>>` containing the success value or\n *   representing `None`.\n */\nexport const toOptional = <R extends UnknownResult>(\n  result: R,\n): Optional<UnwrapOk<R>> =>\n  isOk(result) ? Optional.some(unwrapOk(result)) : Optional.none;\n"],"names":["Optional.some","Optional.none"],"mappings":";;;;;AAiCO,MAAM,UAAA,GAAa,CACxB,MAAA,KAEA,IAAA,CAAK,MAAM,CAAA,GAAIA,IAAS,CAAK,QAAA,CAAS,MAAM,CAAC,CAAA,GAAIC;;;;"}