feat: add support for dwait and DeferredPromise.

README.md

@@ -15,8 +15,16 @@ Bring the "Umph" back to the JavaScript error handling!
     when(Err, handleError)
   );
 ```
+Or even better, You can use the `.dwait` function call on the returned promise of `try$` to get a `DeferredPromise` built using [dwait library](https://github.com/rzvxa/dwait):
+```js
+  const result = await try$(itMayThrow(a, b, c)).dwait().match(
+    when(Ok, consumeResult),
+    when(Err, handleError)
+  ).await;
+```
+With the use of `DeferredPromise` we can keep chaining functions instead of awaiting each result, And we can defer all awaits to the last operation.
 
-Does that seem too rusty? What about something like this? Let's Go!
+Does that seem too Rusty to you? What about something like this? Let's Go!
 ```js
   const [res, err] = await try$(itMayThrow(a, b, c));
   if (!!err) {
@@ -55,8 +63,8 @@ axios
   .catch((error) => handleError(error));
 ```
 
-It is the snippet of code from `ErrorHandling` section of `axios` library. So what about `async/await`?
-If we want to handle the errors properly with `async/await` pattern we have to write it inside a `try/catch` block like this:
+It is the snippet of code from the `ErrorHandling` section of `axios` library. So what about `async/await`?
+If we want to handle the errors properly with the `async/await` pattern we have to write it inside a `try/catch` block like this:
 ```js
   try {
     const resp = await axios.get("/user/12345");

package.json

@@ -4,7 +4,9 @@
   "description": "Bring the \"Umph\" to the javascript's async error handling",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "prepare": "ts-node ./scripts/prepare.ts && npm run build",
     "lint": "eslint .",
@@ -56,5 +58,8 @@
   "engines": {
     "node": "^16.20.2"
   },
-  "engineStrict": true
+  "engineStrict": true,
+  "dependencies": {
+    "dwait": "^1.0.1"
+  }
 }

src/Dwaitable.ts

@@ -0,0 +1,12 @@
+import type { DeferredPromise } from "dwait";
+
+type Dwaitable<T> = {
+  /**
+   * Converts the promise into a `DeferredPromise` from the `dwait` library.
+   *
+   * @returns The `DeferredPromise` of the actual result.
+   */
+  dwait: () => DeferredPromise<T>
+};
+
+export default Dwaitable;

src/try.ts

@@ -1,4 +1,7 @@
+import dwait from "dwait";
+
 import type { Result } from "./result";
+import type Dwaitable from "./Dwaitable";
 import { Ok, Err } from "./result";
 
 /**
@@ -9,15 +12,16 @@ import { Ok, Err } from "./result";
  *
  * @returns A `Promise` to a `Result` containing the result of `promise` or the error it may have thrown.
  */
-async function try$<TResult, TError>(
+function try$<TResult, TError>(
   promise: Promise<TResult>
-): Promise<Result<TResult, TError>> {
-  try {
-    const result: TResult = await promise;
-    return Ok(result);
-  } catch (err) {
-    return Err(err as TError);
-  }
+): Promise<Result<TResult, TError>> & Dwaitable<Result<TResult, TError>> {
+  const task = Promise.resolve(promise)
+    .then((result) => Ok<TResult, TError>(result))
+    .catch((err) => Err(err as TError));
+  // @ts-expect-error adding dwait to the result promise
+  task.dwait = () => dwait(task);
+  return task as Promise<Result<TResult, TError>> &
+    Dwaitable<Result<TResult, TError>>;
 }
 
 export default try$;

tests/try.spec.ts

@@ -25,4 +25,9 @@ describe("try$ Tests", () => {
     const result = await try$(resolveMock());
     expect(result.isErr()).toEqual(false);
   });
+
+  test("should return a promise which can be turned into a DeferredPromise using dwait function", async () => {
+    const result = try$<string, unknown>(resolveMock()).dwait().isErr();
+    await expect(result).resolves.toEqual(false);
+  });
 });