@praha/byethrow 0.2.0 → 0.2.1

package/dist/cjs/functions/unwrap-error.cjs

@@ -28,6 +28,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_is_success_cjs_namespaceObject = require("./is-success.cjs");
 const unwrapError = (result)=>{
+    if (result instanceof Promise) return result.then((r)=>{
+        if ((0, external_is_success_cjs_namespaceObject.isSuccess)(r)) throw r.value;
+        return r.error;
+    });
     if ((0, external_is_success_cjs_namespaceObject.isSuccess)(result)) throw result.value;
     return result.error;
 };

package/dist/cjs/functions/unwrap-error.d.ts

@@ -1,31 +1,49 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}.
+ * Extracts the error value from a {@link Result}, {@link ResultAsync}.
  *
  * If the result is a {@link Success}, it throws the success value (this is rare but symmetric to `unwrap`).
+ * For {@link ResultAsync}, it returns a Promise that resolves to the error value or rejects with the success value.
  *
  * @function
- * @typeParam E - The type of the error value.
- * @param result - The {@link Result} to unwrap the error from.
- * @returns The error value.
+ * @typeParam R - The type of the result to unwrap.
+ * @param result - The {@link Result}, {@link ResultAsync}.
+ * @returns The error value, or a Promise of the error value for async results.
  * @throws The success value if the result is a {@link Success}.
  *
  * @example Failure Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
- * const error = Result.unwrapError(result); // 'Something went wrong'
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 123 };
- * const error = Result.unwrapError(result); // throws 123
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
+ * const error = Result.unwrapError(result); // 'Oops'
+ * ```
+ *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <E>(result: Result<unknown, E>) => E;
+export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;

package/dist/cjs/functions/unwrap.cjs

@@ -28,6 +28,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
 const unwrap = (result)=>{
+    if (result instanceof Promise) return result.then((r)=>{
+        if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) throw r.error;
+        return r.value;
+    });
     if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) throw result.error;
     return result.value;
 };

package/dist/cjs/functions/unwrap.d.ts

@@ -1,20 +1,22 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}.
+ * Extracts the success value from a {@link Result}, {@link ResultAsync}.
  *
  * If the result is a {@link Failure}, it throws the contained error.
+ * For {@link ResultAsync}, it returns a Promise that resolves to the success value or rejects with the error.
  *
  * @function
- * @typeParam T - The type of the success value.
- * @param result - The {@link Result} to unwrap.
- * @returns The success value.
+ * @typeParam R - The type of the result to unwrap.
+ * @param result - The {@link Result}, {@link ResultAsync}.
+ * @returns The success value, or a Promise of the success value for async results.
  * @throws The error value if the result is a {@link Failure}.
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 100 };
+ * const result: Result.Result<number, string> = Result.succeed(100);
  * const value = Result.unwrap(result); // 100
  * ```
  *
@@ -22,10 +24,26 @@ import type { Result } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Oops' };
+ * const result: Result.Result<number, string> = Result.fail('Oops');
  * const value = Result.unwrap(result); // throws 'Oops'
  * ```
  *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
+ * const value = await Result.unwrap(result); // 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.fail(Promise.resolve('Oops'));
+ * const value = await Result.unwrap(result); // throws 'Oops'
+ * ```
+ *
  * @category Unwraps
  */
-export declare const unwrap: <T>(result: Result<T, unknown>) => T;
+export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;

package/dist/esm/functions/unwrap-error.d.ts

@@ -1,31 +1,49 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}.
+ * Extracts the error value from a {@link Result}, {@link ResultAsync}.
  *
  * If the result is a {@link Success}, it throws the success value (this is rare but symmetric to `unwrap`).
+ * For {@link ResultAsync}, it returns a Promise that resolves to the error value or rejects with the success value.
  *
  * @function
- * @typeParam E - The type of the error value.
- * @param result - The {@link Result} to unwrap the error from.
- * @returns The error value.
+ * @typeParam R - The type of the result to unwrap.
+ * @param result - The {@link Result}, {@link ResultAsync}.
+ * @returns The error value, or a Promise of the error value for async results.
  * @throws The success value if the result is a {@link Success}.
  *
  * @example Failure Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
- * const error = Result.unwrapError(result); // 'Something went wrong'
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 123 };
- * const error = Result.unwrapError(result); // throws 123
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
+ * const error = Result.unwrapError(result); // 'Oops'
+ * ```
+ *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <E>(result: Result<unknown, E>) => E;
+export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;

package/dist/esm/functions/unwrap-error.js

@@ -1,5 +1,9 @@
 import { isSuccess } from "./is-success.js";
 const unwrapError = (result)=>{
+    if (result instanceof Promise) return result.then((r)=>{
+        if (isSuccess(r)) throw r.value;
+        return r.error;
+    });
     if (isSuccess(result)) throw result.value;
     return result.error;
 };

package/dist/esm/functions/unwrap.d.ts

@@ -1,20 +1,22 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}.
+ * Extracts the success value from a {@link Result}, {@link ResultAsync}.
  *
  * If the result is a {@link Failure}, it throws the contained error.
+ * For {@link ResultAsync}, it returns a Promise that resolves to the success value or rejects with the error.
  *
  * @function
- * @typeParam T - The type of the success value.
- * @param result - The {@link Result} to unwrap.
- * @returns The success value.
+ * @typeParam R - The type of the result to unwrap.
+ * @param result - The {@link Result}, {@link ResultAsync}.
+ * @returns The success value, or a Promise of the success value for async results.
  * @throws The error value if the result is a {@link Failure}.
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 100 };
+ * const result: Result.Result<number, string> = Result.succeed(100);
  * const value = Result.unwrap(result); // 100
  * ```
  *
@@ -22,10 +24,26 @@ import type { Result } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Oops' };
+ * const result: Result.Result<number, string> = Result.fail('Oops');
  * const value = Result.unwrap(result); // throws 'Oops'
  * ```
  *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
+ * const value = await Result.unwrap(result); // 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.fail(Promise.resolve('Oops'));
+ * const value = await Result.unwrap(result); // throws 'Oops'
+ * ```
+ *
  * @category Unwraps
  */
-export declare const unwrap: <T>(result: Result<T, unknown>) => T;
+export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;

package/dist/esm/functions/unwrap.js

@@ -1,5 +1,9 @@
 import { isFailure } from "./is-failure.js";
 const unwrap = (result)=>{
+    if (result instanceof Promise) return result.then((r)=>{
+        if (isFailure(r)) throw r.error;
+        return r.value;
+    });
     if (isFailure(result)) throw result.error;
     return result.value;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praha/byethrow",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A lightweight, tree-shakable Result type package with a simple, consistent API designed",
   "keywords": [
     "javascript",
@@ -41,7 +41,7 @@
     "README.md"
   ],
   "devDependencies": {
-    "@rslib/core": "0.10.1",
+    "@rslib/core": "0.10.2",
     "eslint": "9.29.0",
     "typedoc": "0.28.5",
     "typescript": "5.8.3",