feat: add a method for returning an object

README.md

@@ -120,7 +120,25 @@ async function awesome() {
 
    // ...
 }
+```
+
+You can also use the `try$` function to collapse the error and data into a single object:
 
+```TS
+import { try$ } from "@bdsqqq/try"
+
+async function awesome() {
+   const a = await try$(step1());
+   if(a.error) // ...
+
+   const b = await try$(step2(a.data));
+   if(b.error) // ...
+
+   const c = await try$(step3(b.data));
+   if(c.error) // ...
+
+   // ...
+}
 ```
 
 ### Why does this REALLY exist?

src/index.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, vi, expect } from "vitest";
-import { trytm } from ".";
+import { trytm, try$ } from ".";
 
 describe("tryTm", () => {
    it("Should return promise value if the promise resolves", async () => {
@@ -45,3 +45,48 @@ describe("tryTm", () => {
       });
    });
 });
+
+describe("try$", () => {
+   it("Should return promise value if the promise resolves", async () => {
+      const promiseFn = vi
+         .fn()
+         .mockImplementationOnce(async () =>
+            Promise.resolve({ hey: "Bedesqui" }),
+         );
+
+      const { data, error } = await try$(promiseFn());
+
+      expect(data).toStrictEqual({ hey: "Bedesqui" });
+      expect(error).toBeNull();
+   });
+
+   it("Should return error if the promise rejects with an Error value", async () => {
+      const promiseFn = vi
+         .fn()
+         .mockImplementationOnce(async () =>
+            Promise.reject(new Error("I'm a failure")),
+         );
+
+      const { data, error } = await try$(promiseFn());
+
+      expect(data).toBeNull();
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toBe("I'm a failure");
+   });
+
+   it("Should throw if the promise rejects with an non-Error value", async () => {
+      expect.assertions(1);
+
+      const promiseFn = vi
+         .fn()
+         .mockImplementationOnce(async () =>
+            Promise.reject({ someNonErrorValue: "Maybe I'm not a failure" }),
+         );
+
+      await try$(promiseFn()).catch((throwable) => {
+         expect(throwable).toEqual({
+            someNonErrorValue: "Maybe I'm not a failure",
+         });
+      });
+   });
+});

src/index.ts

@@ -12,3 +12,16 @@ export const trytm = async <T>(
       throw throwable;
    }
 };
+
+export const try$ = async <T>(
+   promise: Promise<T>,
+): Promise<{ data: T | null; error: Error | null }> => {
+   try {
+      const data = await promise;
+      return { data, error: null };
+   } catch (throwable) {
+      if (throwable instanceof Error) return { data: null, error: throwable };
+
+      throw throwable;
+   }
+};