ts-data-forge 9.0.0 → 9.0.1

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

@@ -1,18 +1,16 @@
 import { unwrapErr } from './result-unwrap-err.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, defaultValue] = args;
+      return unwrapErrOrImpl(result, defaultValue);
     }
+    case 1: {
+      const [defaultValue] = args;
+      return (result) => unwrapErrOrImpl(result, defaultValue);
+    }
+  }
 }
 const unwrapErrOrImpl = (result, defaultValue) => unwrapErr(result) ?? defaultValue;
 

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA0CM,SAAU,WAAW,CACzB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;QAC9C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;QAC7D;;AAEJ;AAEA,MAAM,eAAe,GAAG,CACtB,MAAS,EACT,YAAe,KACM,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;;;;"}
+{"version":3,"file":"result-unwrap-err-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { unwrapErr } from './result-unwrap-err.mjs';\nimport { type UnwrapErr } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the error value or a default value if it is\n * `Result.Ok`.\n *\n * @example\n *\n * ```ts\n * const okResult = Result.ok('success');\n *\n * const errResult = Result.err('failure');\n *\n * assert.isTrue(Result.unwrapErrOr(okResult, 'default') === 'default');\n *\n * assert.isTrue(Result.unwrapErrOr(errResult, 'default') === 'failure');\n *\n * const unwrapError = Result.unwrapErrOr('fallback error');\n *\n * assert.isTrue(unwrapError(Result.err('boom')) === 'boom');\n *\n * assert.isTrue(unwrapError(Result.ok('no error')) === 'fallback error');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @template D The type of the default value.\n * @param result The `Result` to unwrap.\n * @param defaultValue The value to return if `result` is `Result.Ok`.\n * @returns The error value if `Result.Err`, otherwise `defaultValue`.\n */\nexport function unwrapErrOr<R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapErr<R>;\n\n// Curried version\nexport function unwrapErrOr<D>(\n  defaultValue: D,\n): <R extends UnknownResult>(result: R) => D | UnwrapErr<R>;\n\nexport function unwrapErrOr<R extends UnknownResult, D>(\n  ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]\n): D | UnwrapErr<R> | ((result: R) => D | UnwrapErr<R>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, defaultValue] = args;\n\n      return unwrapErrOrImpl(result, defaultValue);\n    }\n\n    case 1: {\n      // Curried version\n      const [defaultValue] = args;\n\n      return (result: R) => unwrapErrOrImpl(result, defaultValue);\n    }\n  }\n}\n\nconst unwrapErrOrImpl = <R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapErr<R> => unwrapErr(result) ?? defaultValue;\n"],"names":[],"mappings":";;AA0CO,SAAS,eACX,IAAA,EACmD;AACtD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,YAAY,CAAA,GAAI,IAAA;AAE/B,MAAA,OAAO,eAAA,CAAgB,QAAQ,YAAY,CAAA;AAAA,IAC7C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,YAAY,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,CAAC,MAAA,KAAc,eAAA,CAAgB,MAAA,EAAQ,YAAY,CAAA;AAAA,IAC5D;AAAA;AAEJ;AAEA,MAAM,kBAAkB,CACtB,MAAA,EACA,YAAA,KACqB,SAAA,CAAU,MAAM,CAAA,IAAK,YAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,aAAa,EACpD,QAAQ,CAAC,EACT,QAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAwB,KAClD,SAAS,CAAC,CAAC,CAiBb,CAAC"}
+{"version":3,"file":"result-unwrap-err-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,aAAa,UAC5C,CAAC,UACF,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,KAChC,SAAS,CAAC,CAAC,CAiBb,CAAC"}

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

@@ -3,47 +3,20 @@ import { unknownToString } from '../../../others/unknown-to-string.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`.
- */
 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, {
-        'ts-data-forge::Result.ok': 'Ok',
-        '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)}`);
+  if (isErr(result)) {
+    return result.value;
+  }
+  const variant = match(result.$$tag, {
+    "ts-data-forge::Result.ok": "Ok",
+    "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
+    )}`
+  );
 };
 
 export { unwrapErrThrow };

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,cAAc,GAAG,CAC5B,MAAS,EACT,KAAA,GAAoC,eAAe,KACnC;AAChB,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;;QAEjB,OAAO,MAAM,CAAC,KAAqB;IACrC;AAEA,IAAA,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE;AAClC,QAAA,0BAA0B,EAAE,IAAI;AAChC,QAAA,2BAA2B,EAAE,KAAK;AACnC,KAAA,CAAC;AAEF,IAAA,MAAM,IAAI,KAAK,CACb,CAAA,qBAAA,EAAwB,OAAO,KAAK,KAAK;;AAEvC,IAAA,MAAM,CAAC,KAAoB,CAC5B,CAAA,CAAE,CACJ;AACH;;;;"}
+{"version":3,"file":"result-unwrap-err-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"sourcesContent":["import { unknownToString } from '../../../others/index.mjs';\nimport { match } from '../../match.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the error value. Throws an error if the\n * `Result` is `Result.Ok`.\n *\n * This function is used when you expect a Result to be an error and want to\n * extract the error value. If the Result is unexpectedly Ok, it will throw an\n * error with information about the unexpected success value.\n *\n * @example\n *\n * ```ts\n * const errResult = Result.err(new Error('broken'));\n *\n * const okResult = Result.ok('value');\n *\n * assert.isTrue(Result.unwrapErrThrow(errResult).message === 'broken');\n *\n * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @param result The `Result` to unwrap.\n * @param toStr An optional function to convert the success value to a string\n *   for the error message when the Result is unexpectedly Ok. Defaults to\n *   `String`.\n * @returns The error value if `Result.Err`.\n * @throws {Error} Error with message \"Expected Err but got Ok: {value}\" if\n *   the `Result` is `Result.Ok`.\n */\nexport const unwrapErrThrow = <R extends UnknownResult>(\n  result: R,\n  toStr: (v: UnwrapOk<R>) => string = unknownToString,\n): UnwrapErr<R> => {\n  if (isErr(result)) {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return result.value as UnwrapErr<R>;\n  }\n\n  const variant = match(result.$$tag, {\n    'ts-data-forge::Result.ok': 'Ok',\n    'ts-data-forge::Result.err': 'Err',\n  });\n\n  throw new Error(\n    `Expected Err but got ${variant}: ${toStr(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      result.value as UnwrapOk<R>,\n    )}`,\n  );\n};\n"],"names":[],"mappings":";;;;;AAmCO,MAAM,cAAA,GAAiB,CAC5B,MAAA,EACA,KAAA,GAAoC,eAAA,KACnB;AACjB,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AAEjB,IAAA,OAAO,MAAA,CAAO,KAAA;AAAA,EAChB;AAEA,EAAA,MAAM,OAAA,GAAU,KAAA,CAAM,MAAA,CAAO,KAAA,EAAO;AAAA,IAClC,0BAAA,EAA4B,IAAA;AAAA,IAC5B,2BAAA,EAA6B;AAAA,GAC9B,CAAA;AAED,EAAA,MAAM,IAAI,KAAA;AAAA,IACR,CAAA,qBAAA,EAAwB,OAAO,CAAA,EAAA,EAAK,KAAA;AAAA;AAAA,MAElC,MAAA,CAAO;AAAA,KACR,CAAA;AAAA,GACH;AACF;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,aAAa,EAC/C,QAAQ,CAAC,KACR,SAAS,CAAC,CAAC,CAAC,GAAG,SAE0C,CAAC"}
+{"version":3,"file":"result-unwrap-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,aAAa,UACvC,CAAC,KACR,SAAS,CAAC,CAAC,CAAC,GAAG,SAE0C,CAAC"}

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

@@ -1,37 +1,9 @@
 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`.
- */
-const unwrapErr = (result) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-isErr(result) ? result.value : undefined;
+const unwrapErr = (result) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  isErr(result) ? result.value : void 0
+);
 
 export { unwrapErr };
 //# sourceMappingURL=result-unwrap-err.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,SAAS,GAAG,CACvB,MAAS;AAET;AACA,KAAK,CAAC,MAAM,CAAC,GAAI,MAAM,CAAC,KAAsB,GAAG;;;;"}
+{"version":3,"file":"result-unwrap-err.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type UnwrapErr } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the error value or `undefined` if it is\n * `Result.Ok`.\n *\n * This provides a safe way to extract error values from Results without\n * throwing exceptions. Useful for error handling patterns where you want to\n * check for specific error conditions.\n *\n * @example\n *\n * ```ts\n * const okResult = Result.ok('data');\n *\n * const errResult = Result.err('problem');\n *\n * // Result.unwrapErr returns undefined for Ok results\n *\n * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n * assert.isTrue(Result.unwrapErr(okResult) === undefined);\n *\n * // Result.unwrapErr returns the error value for Err results\n *\n * assert.isTrue(Result.unwrapErr(errResult) === 'problem');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @param result The `Result` to unwrap.\n * @returns The error value if `Result.Err`, otherwise `undefined`.\n */\nexport const unwrapErr = <R extends UnknownResult>(\n  result: R,\n): UnwrapErr<R> | undefined =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  isErr(result) ? (result.value as UnwrapErr<R>) : undefined;\n"],"names":[],"mappings":";;AAiCO,MAAM,YAAY,CACvB,MAAA;AAAA;AAAA,EAGA,KAAA,CAAM,MAAM,CAAA,GAAK,MAAA,CAAO,KAAA,GAAyB;AAAA;;;;"}

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

@@ -1,18 +1,16 @@
 import { unwrapOk } from './result-unwrap-ok.mjs';
 
 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);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, defaultValue] = args;
+      return unwrapOkOrImpl(result, defaultValue);
     }
+    case 1: {
+      const [defaultValue] = args;
+      return (result) => unwrapOkOrImpl(result, defaultValue);
+    }
+  }
 }
 const unwrapOkOrImpl = (result, defaultValue) => unwrapOk(result) ?? defaultValue;
 

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-ok-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA0CM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC;QAC7C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC;QAC5D;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,YAAe,KACK,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;;;;"}
+{"version":3,"file":"result-unwrap-ok-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the success value or a default value if it is\n * `Result.Err`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(10);\n *\n * const errValue = Result.err('fail');\n *\n * assert.isTrue(Result.unwrapOkOr(okValue, 0) === 10);\n *\n * assert.isTrue(Result.unwrapOkOr(errValue, 0) === 0);\n *\n * const unwrapWithDefault = Result.unwrapOkOr(5);\n *\n * assert.isTrue(unwrapWithDefault(Result.ok(3)) === 3);\n *\n * assert.isTrue(unwrapWithDefault(Result.err('no data')) === 5);\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @template D The type of the default value.\n * @param result The `Result` to unwrap.\n * @param defaultValue The value to return if `result` is `Result.Err`.\n * @returns The success value if `Result.Ok`, otherwise `defaultValue`.\n */\nexport function unwrapOkOr<R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapOk<R>;\n\n// Curried version\nexport function unwrapOkOr<D>(\n  defaultValue: D,\n): <R extends UnknownResult>(result: R) => D | UnwrapOk<R>;\n\nexport function unwrapOkOr<R extends UnknownResult, D>(\n  ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]\n): D | UnwrapOk<R> | ((result: R) => D | UnwrapOk<R>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, defaultValue] = args;\n\n      return unwrapOkOrImpl(result, defaultValue);\n    }\n\n    case 1: {\n      // Curried version\n      const [defaultValue] = args;\n\n      return (result: R) => unwrapOkOrImpl(result, defaultValue);\n    }\n  }\n}\n\nconst unwrapOkOrImpl = <R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapOk<R> => unwrapOk(result) ?? defaultValue;\n"],"names":[],"mappings":";;AA0CO,SAAS,cACX,IAAA,EACiD;AACpD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,YAAY,CAAA,GAAI,IAAA;AAE/B,MAAA,OAAO,cAAA,CAAe,QAAQ,YAAY,CAAA;AAAA,IAC5C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,YAAY,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,CAAC,MAAA,KAAc,cAAA,CAAe,MAAA,EAAQ,YAAY,CAAA;AAAA,IAC3D;AAAA;AAEJ;AAEA,MAAM,iBAAiB,CACrB,MAAA,EACA,YAAA,KACoB,QAAA,CAAS,MAAM,CAAA,IAAK,YAAA;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-ok.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA+BM,SAAU,QAAQ,CACtB,MAAS,EAAA;IAET,OAAO,IAAI,CAAC,MAAM;AAChB;AACG,YAAA,MAAM,CAAC;UACR,SAAS;AACf;;;;"}
+{"version":3,"file":"result-unwrap-ok.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Safely unwraps the success value, returning `undefined` for failures.\n *\n * @example\n *\n * ```ts\n * const okResult = Result.ok(42);\n *\n * const errResult = Result.err('oops');\n *\n * // Result.unwrapOk returns the value for Ok results\n *\n * assert.isTrue(Result.unwrapOk(okResult) === 42);\n *\n * // Result.unwrapOk returns undefined for Err results\n *\n * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n * assert.isTrue(Result.unwrapOk(errResult) === undefined);\n * ```\n */\nexport function unwrapOk<R extends Ok<unknown>>(result: R): UnwrapOk<R>;\n\nexport function unwrapOk<R extends UnknownResult>(\n  result: R,\n): UnwrapOk<R> | undefined;\n\nexport function unwrapOk<R extends UnknownResult>(\n  result: R,\n): UnwrapOk<R> | undefined {\n  return isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result.value as UnwrapOk<R>)\n    : undefined;\n}\n"],"names":[],"mappings":";;AA+BO,SAAS,SACd,MAAA,EACyB;AACzB,EAAA,OAAO,KAAK,MAAM,CAAA;AAAA;AAAA,IAEb,MAAA,CAAO;AAAA,MACR,MAAA;AACN;;;;"}

package/dist/functional/result/impl/result-unwrap-throw.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EACjD,QAAQ,CAAC,EACT,QAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,MAAwB,KACnD,QAAQ,CAAC,CAAC,CAQZ,CAAC"}
+{"version":3,"file":"result-unwrap-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,UACzC,CAAC,UACF,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,MAAM,KACjC,QAAQ,CAAC,CAAC,CAQZ,CAAC"}

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

@@ -2,42 +2,11 @@ import '@sindresorhus/is';
 import { unknownToString } from '../../../others/unknown-to-string.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`.
- */
 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;
+  if (isErr(result)) {
+    throw new Error(toStr(result.value));
+  }
+  return result.value;
 };
 
 export { unwrapThrow };

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,WAAW,GAAG,CACzB,MAAS,EACT,KAAA,GAAqC,eAAe,KACrC;AACf,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;;QAEjB,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;IACtD;;IAGA,OAAO,MAAM,CAAC,KAAoB;AACpC;;;;"}
+{"version":3,"file":"result-unwrap-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"sourcesContent":["import { unknownToString } from '../../../others/index.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the success value. Throws an error if the\n * `Result` is `Result.Err`.\n *\n * This is useful when you're confident that a Result should contain a success\n * value and want to treat errors as exceptional conditions. The error message\n * will be constructed from the error value using the provided string\n * conversion function.\n *\n * @example\n *\n * ```ts\n * const okResult = Result.ok('data');\n *\n * const errResult = Result.err(new Error('fail'));\n *\n * assert.isTrue(Result.unwrapThrow(okResult) === 'data');\n *\n * assert.throws(() => Result.unwrapThrow(errResult), Error, 'fail');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @param result The `Result` to unwrap.\n * @param toStr An optional function to convert the error value to a string\n *   for the error message. Defaults to `String`.\n * @returns The success value if `Result.Ok`.\n * @throws {Error} Error with the stringified error value if the `Result` is\n *   `Result.Err`.\n */\nexport const unwrapThrow = <R extends UnknownResult>(\n  result: R,\n  toStr: (e: UnwrapErr<R>) => string = unknownToString,\n): UnwrapOk<R> => {\n  if (isErr(result)) {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    throw new Error(toStr(result.value as UnwrapErr<R>));\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return result.value as UnwrapOk<R>;\n};\n"],"names":[],"mappings":";;;;AAkCO,MAAM,WAAA,GAAc,CACzB,MAAA,EACA,KAAA,GAAqC,eAAA,KACrB;AAChB,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AAEjB,IAAA,MAAM,IAAI,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,KAAqB,CAAC,CAAA;AAAA,EACrD;AAGA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"result-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-zip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,GAAG,GAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAChC,SAAS,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,EACvB,SAAS,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,KACtB,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAKvB,CAAC"}
+{"version":3,"file":"result-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-zip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,GAAG,GAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,WACvB,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,WACd,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,KACtB,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAKvB,CAAC"}

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

@@ -1,40 +1,7 @@
 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`.
- */
-const zip = (resultA, resultB) => isOk(resultA)
-    ? isOk(resultB)
-        ? ok([resultA.value, resultB.value])
-        : resultB
-    : resultA;
+const zip = (resultA, resultB) => isOk(resultA) ? isOk(resultB) ? ok([resultA.value, resultB.value]) : resultB : resultA;
 
 export { zip };
 //# sourceMappingURL=result-zip.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-zip.mjs","sources":["../../../../src/functional/result/impl/result-zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,GAAG,GAAG,CACjB,OAAuB,EACvB,OAAuB,KAEvB,IAAI,CAAC,OAAO;AACV,MAAE,IAAI,CAAC,OAAO;AACZ,UAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAU;AAC5C,UAAE;MACF;;;;"}
+{"version":3,"file":"result-zip.mjs","sources":["../../../../src/functional/result/impl/result-zip.mts"],"sourcesContent":["import { type Result } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * Combines two `Result` values into a single `Result` containing a tuple. If\n * either `Result` is `Err`, returns the first `Err` encountered.\n *\n * @example\n *\n * ```ts\n * const first = Result.ok('left');\n *\n * const second = Result.ok(1);\n *\n * const expected = ['left', 1] as const;\n *\n * assert.deepStrictEqual(Result.zip(first, second), Result.ok(expected));\n *\n * assert.deepStrictEqual(\n *   Result.zip(first, Result.err('error')),\n *   Result.err('error'),\n * );\n * ```\n *\n * @template S1 The success type of the first `Result`.\n * @template E1 The error type of the first `Result`.\n * @template S2 The success type of the second `Result`.\n * @template E2 The error type of the second `Result`.\n * @param resultA The first `Result`.\n * @param resultB The second `Result`.\n * @returns A `Result` containing a tuple of both values, or the first `Err`.\n */\nexport const zip = <S1, E1, S2, E2>(\n  resultA: Result<S1, E1>,\n  resultB: Result<S2, E2>,\n): Result<readonly [S1, S2], E1 | E2> =>\n  isOk(resultA)\n    ? isOk(resultB)\n      ? ok([resultA.value, resultB.value] as const)\n      : resultB\n    : resultA;\n"],"names":[],"mappings":";;;AAiCO,MAAM,MAAM,CACjB,OAAA,EACA,YAEA,IAAA,CAAK,OAAO,IACR,IAAA,CAAK,OAAO,CAAA,GACV,EAAA,CAAG,CAAC,OAAA,CAAQ,KAAA,EAAO,QAAQ,KAAK,CAAU,IAC1C,OAAA,GACF;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/result/impl/tag.mts"],"sourcesContent":[null],"names":[],"mappings":"AAGO,MAAM,aAAa,GAAyB;AAEnD;AACO,MAAM,cAAc,GACzB;;;;"}
+{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/result/impl/tag.mts"],"sourcesContent":["/** @internal Tag identifying the Ok variant. */\nimport { type Err, type Ok } from '../../../types.mjs';\n\nexport const OkTypeTagName: Ok<unknown>['$$tag'] = 'ts-data-forge::Result.ok';\n\n/** @internal Tag identifying the Err variant. */\nexport const ErrTypeTagName: Err<unknown>['$$tag'] =\n  'ts-data-forge::Result.err';\n"],"names":[],"mappings":"AAGO,MAAM,aAAA,GAAsC;AAG5C,MAAM,cAAA,GACX;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/ternary-result/impl/tag.mts"],"sourcesContent":[null],"names":[],"mappings":"AAOO,MAAM,aAAa,GACxB;AAEF;AACO,MAAM,eAAe,GAC1B;AAEF;AACO,MAAM,cAAc,GACzB;;;;"}
+{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/ternary-result/impl/tag.mts"],"sourcesContent":["/** @internal Tag identifying the Ok variant. */\nimport {\n  type TernaryErr,\n  type TernaryOk,\n  type TernaryWarn,\n} from '../ternary-result.mjs';\n\nexport const OkTypeTagName: TernaryOk<unknown>['$$tag'] =\n  'ts-data-forge::Result.ok';\n\n/** @internal Tag identifying the Warn variant. */\nexport const WarnTypeTagName: TernaryWarn<unknown, unknown>['$$tag'] =\n  'ts-data-forge::Result.warn';\n\n/** @internal Tag identifying the Err variant. */\nexport const ErrTypeTagName: TernaryErr<unknown>['$$tag'] =\n  'ts-data-forge::Result.err';\n"],"names":[],"mappings":"AAOO,MAAM,aAAA,GACX;AAGK,MAAM,eAAA,GACX;AAGK,MAAM,cAAA,GACX;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGxD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,EAAG,OAAO,CAAC,KAAG,UAAU,CAAC,CAAC,CAIxC,CAAC"}
+{"version":3,"file":"ternary-result-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGxD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,UAAU,CAAC,CAAC,CAIxC,CAAC"}

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

@@ -1,21 +1,8 @@
 import { ErrTypeTagName } from './tag.mjs';
 
-/**
- * Creates a `TernaryResult.Err` containing the provided error value.
- *
- * @example
- *
- * ```ts
- * const failure = TernaryResult.err(new Error('missing data'));
- *
- * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');
- *
- * assert.isTrue(TernaryResult.isErr(failure));
- * ```
- */
 const err = (value) => ({
-    $$tag: ErrTypeTagName,
-    value,
+  $$tag: ErrTypeTagName,
+  value
 });
 
 export { err };

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

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-err.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;AAYG;MACU,GAAG,GAAG,CAAW,KAAQ,MACnC;AACC,IAAA,KAAK,EAAE,cAAc;IACrB,KAAK;AACN,CAAA;;;;"}
+{"version":3,"file":"ternary-result-err.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"sourcesContent":["import { type TernaryErr } from '../ternary-result.mjs';\nimport { ErrTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `TernaryResult.Err` containing the provided error value.\n *\n * @example\n *\n * ```ts\n * const failure = TernaryResult.err(new Error('missing data'));\n *\n * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');\n *\n * assert.isTrue(TernaryResult.isErr(failure));\n * ```\n */\nexport const err = <const E,>(value: E): TernaryErr<E> =>\n  ({\n    $$tag: ErrTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AAgBO,MAAM,GAAA,GAAM,CAAW,KAAA,MAC3B;AAAA,EACC,KAAA,EAAO,cAAA;AAAA,EACP;AACF,CAAA;;;;"}

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

@@ -2,22 +2,22 @@ import { isOk } from './ternary-result-is-ok.mjs';
 import { unwrapOk } from './ternary-result-unwrap-ok.mjs';
 
 function expectToBe(...args) {
-    switch (args.length) {
-        case 2: {
-            const [result, message] = args;
-            return expectImpl(result, message);
-        }
-        case 1: {
-            const [message] = args;
-            return (result) => expectImpl(result, message);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, message] = args;
+      return expectImpl(result, message);
     }
+    case 1: {
+      const [message] = args;
+      return (result) => expectImpl(result, message);
+    }
+  }
 }
 const expectImpl = (result, message) => {
-    if (isOk(result)) {
-        return unwrapOk(result);
-    }
-    throw new Error(message);
+  if (isOk(result)) {
+    return unwrapOk(result);
+  }
+  throw new Error(message);
 };
 
 export { expectToBe };

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

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-expect-to-be.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAqCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;QACpC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YAEtB,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;QACnD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,OAAe,KACA;AACf,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AAChB,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}
+{"version":3,"file":"ternary-result-expect-to-be.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-expect-to-be.mts"],"sourcesContent":["import {\n  type TernaryResult,\n  type UnknownTernaryResult,\n} from '../ternary-result.mjs';\nimport { isOk } from './ternary-result-is-ok.mjs';\nimport { unwrapOk } from './ternary-result-unwrap-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps the Ok value or throws with the provided message.\n *\n * @example\n *\n * ```ts\n * const okValue = TernaryResult.ok('ready');\n *\n * assert.strictEqual(TernaryResult.expectToBe(okValue, 'missing'), 'ready');\n *\n * const expectResult = TernaryResult.expectToBe('needs value');\n *\n * const throwTest = (): void => {\n *   expectResult(TernaryResult.err('oops'));\n * };\n *\n * assert.throws(throwTest, /needs value/u);\n * ```\n */\nexport function expectToBe<R extends UnknownTernaryResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R>;\n\n// Curried version\nexport function expectToBe(\n  message: string,\n): <S, W, E>(result: TernaryResult<S, E, W>) => S;\n\nexport function expectToBe<R extends UnknownTernaryResult>(\n  ...args: readonly [result: R, message: string] | readonly [message: string]\n): UnwrapOk<R> | ((result: R) => UnwrapOk<R>) {\n  switch (args.length) {\n    case 2: {\n      const [result, message] = args;\n\n      return expectImpl(result, message);\n    }\n\n    case 1: {\n      const [message] = args;\n\n      return (result: R) => expectImpl(result, message);\n    }\n  }\n}\n\nconst expectImpl = <R extends UnknownTernaryResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R> => {\n  if (isOk(result)) {\n    return unwrapOk(result);\n  }\n\n  throw new Error(message);\n};\n"],"names":[],"mappings":";;;AAqCO,SAAS,cACX,IAAA,EACyC;AAC5C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,OAAO,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,UAAA,CAAW,QAAQ,OAAO,CAAA;AAAA,IACnC;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,MAAA,KAAc,UAAA,CAAW,MAAA,EAAQ,OAAO,CAAA;AAAA,IAClD;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,CACjB,MAAA,EACA,OAAA,KACgB;AAChB,EAAA,IAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAChB,IAAA,OAAO,SAAS,MAAM,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AACzB,CAAA;;;;"}

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

@@ -3,38 +3,39 @@ import { isWarn } from './ternary-result-is-warn.mjs';
 import { warn } from './ternary-result-warn.mjs';
 
 function flatMap(...args) {
-    switch (args.length) {
-        case 2: {
-            const [result, flatMapFn] = args;
-            return flatMapImpl(result, flatMapFn);
-        }
-        case 1: {
-            const [flatMapFn] = args;
-            return (result) => flatMapImpl(result, flatMapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, flatMapFn] = args;
+      return flatMapImpl(result, flatMapFn);
     }
+    case 1: {
+      const [flatMapFn] = args;
+      return (result) => flatMapImpl(result, flatMapFn);
+    }
+  }
 }
 const flatMapImpl = (result, flatMapFn) => {
-    if (isOk(result)) {
+  if (isOk(result)) {
+    return flatMapFn(result.value);
+  }
+  if (isWarn(result)) {
+    const next = flatMapFn(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      result.value
+    );
+    if (isOk(next)) {
+      return warn(
+        next.value,
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return flatMapFn(result.value);
+        result.warning
+      );
     }
-    if (isWarn(result)) {
-        const next = flatMapFn(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        result.value);
-        if (isOk(next)) {
-            return warn(next.value, 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            result.warning);
-        }
-        if (isWarn(next)) {
-            return warn(next.value, next.warning);
-        }
-        return next;
+    if (isWarn(next)) {
+      return warn(next.value, next.warning);
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    return result;
+    return next;
+  }
+  return result;
 };
 
 export { flatMap };

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

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-flat-map.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-flat-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAsDM,SAAU,OAAO,CACrB,GAAG,IAKwE,EAAA;AAI3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI;AAEhC,YAAA,OAAO,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACvC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,MAAS,KAAK,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACtD;;AAEJ;AAEA,MAAM,WAAW,GAAG,CAClB,MAAS,EACT,SAA4D,KACA;AAC5D,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;;AAEhB,QAAA,OAAO,SAAS,CAAC,MAAM,CAAC,KAAoB,CAAC;IAC/C;AAEA,IAAA,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE;QAClB,MAAM,IAAI,GAAG,SAAS;;QAEpB,MAAM,CAAC,KAAoB,CAC5B;AAED,QAAA,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;AACd,YAAA,OAAO,IAAI,CACT,IAAI,CAAC,KAAK;;YAEV,MAAM,CAAC,OAAwB,CAChC;QACH;AAEA,QAAA,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE;YAChB,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAoC,CAAC;QACpE;AAEA,QAAA,OAAO,IAAI;IACb;;AAGA,IAAA,OAAO,MAAuC;AAChD,CAAC;;;;"}
+{"version":3,"file":"ternary-result-flat-map.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-flat-map.mts"],"sourcesContent":["import {\n  type TernaryErr,\n  type TernaryResult,\n  type UnknownTernaryResult,\n} from '../ternary-result.mjs';\nimport { isOk } from './ternary-result-is-ok.mjs';\nimport { isWarn } from './ternary-result-is-warn.mjs';\nimport { warn } from './ternary-result-warn.mjs';\nimport { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';\n\n/**\n * Applies a function returning a `TernaryResult` to the Ok variant.\n *\n * @example\n *\n * ```ts\n * const parse = (value: string): TernaryResult<number, string, string> =>\n *   pipe(Num.safeParseFloat(value)).map((result) =>\n *     Result.isErr(result)\n *       ? TernaryResult.err('NaN')\n *       : TernaryResult.ok(result.value),\n *   ).value;\n *\n * const doubled = TernaryResult.flatMap(TernaryResult.ok('3'), (text) =>\n *   TernaryResult.map(parse(text), (num) => num * 2),\n * );\n *\n * const warnPassthrough = TernaryResult.flatMap(\n *   TernaryResult.warn('3', 'retry'),\n *   parse,\n * );\n *\n * const errPassthrough = TernaryResult.flatMap(\n *   TernaryResult.err('oops'),\n *   parse,\n * );\n *\n * assert.deepStrictEqual(doubled, TernaryResult.ok(6));\n *\n * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(3, 'retry'));\n *\n * assert.deepStrictEqual(errPassthrough, TernaryResult.err('oops'));\n * ```\n */\nexport function flatMap<R extends UnknownTernaryResult, S2, W2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => TernaryResult<S2, E2, W2>,\n): TernaryResult<S2, E2 | UnwrapErr<R>, W2 | UnwrapWarn<R>>;\n\n// Curried version\nexport function flatMap<S, S2, W2, E2>(\n  flatMapFn: (value: S) => TernaryResult<S2, E2, W2>,\n): <W, E>(result: TernaryResult<S, E, W>) => TernaryResult<S2, E | E2, W | W2>;\n\nexport function flatMap<R extends UnknownTernaryResult, S2, W2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        flatMapFn: (value: UnwrapOk<R>) => TernaryResult<S2, E2, W2>,\n      ]\n    | readonly [flatMapFn: (value: UnwrapOk<R>) => TernaryResult<S2, E2, W2>]\n):\n  | TernaryResult<S2, E2 | UnwrapErr<R>, W2 | UnwrapWarn<R>>\n  | ((result: R) => TernaryResult<S2, UnwrapErr<R> | E2, UnwrapWarn<R> | W2>) {\n  switch (args.length) {\n    case 2: {\n      const [result, flatMapFn] = args;\n\n      return flatMapImpl(result, flatMapFn);\n    }\n\n    case 1: {\n      const [flatMapFn] = args;\n\n      return (result: R) => flatMapImpl(result, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = <R extends UnknownTernaryResult, S2, W2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => TernaryResult<S2, E2, W2>,\n): TernaryResult<S2, E2 | UnwrapErr<R>, W2 | UnwrapWarn<R>> => {\n  if (isOk(result)) {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return flatMapFn(result.value as UnwrapOk<R>);\n  }\n\n  if (isWarn(result)) {\n    const next = flatMapFn(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      result.value as UnwrapOk<R>,\n    );\n\n    if (isOk(next)) {\n      return warn(\n        next.value,\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        result.warning as UnwrapWarn<R>,\n      );\n    }\n\n    if (isWarn(next)) {\n      return warn(next.value, next.warning satisfies W2 | UnwrapWarn<R>);\n    }\n\n    return next;\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return result as TernaryErr<E2 | UnwrapErr<R>>;\n};\n"],"names":[],"mappings":";;;;AAsDO,SAAS,WACX,IAAA,EAQyE;AAC5E,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,SAAS,CAAA,GAAI,IAAA;AAE5B,MAAA,OAAO,WAAA,CAAY,QAAQ,SAAS,CAAA;AAAA,IACtC;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,MAAA,KAAc,WAAA,CAAY,MAAA,EAAQ,SAAS,CAAA;AAAA,IACrD;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,CAClB,MAAA,EACA,SAAA,KAC6D;AAC7D,EAAA,IAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAEhB,IAAA,OAAO,SAAA,CAAU,OAAO,KAAoB,CAAA;AAAA,EAC9C;AAEA,EAAA,IAAI,MAAA,CAAO,MAAM,CAAA,EAAG;AAClB,IAAA,MAAM,IAAA,GAAO,SAAA;AAAA;AAAA,MAEX,MAAA,CAAO;AAAA,KACT;AAEA,IAAA,IAAI,IAAA,CAAK,IAAI,CAAA,EAAG;AACd,MAAA,OAAO,IAAA;AAAA,QACL,IAAA,CAAK,KAAA;AAAA;AAAA,QAEL,MAAA,CAAO;AAAA,OACT;AAAA,IACF;AAEA,IAAA,IAAI,MAAA,CAAO,IAAI,CAAA,EAAG;AAChB,MAAA,OAAO,IAAA,CAAK,IAAA,CAAK,KAAA,EAAO,IAAA,CAAK,OAAoC,CAAA;AAAA,IACnE;AAEA,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,OAAO,MAAA;AACT,CAAA;;;;"}