@oricardopestana/ts-utils 1.0.1 → 1.0.2

package/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Test & Publish
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22.13
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm test
+
+  publish:
+    needs: test
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22.13
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - run: pnpm install --frozen-lockfile
+
+      - run: npm version patch --no-git-tag-version
+
+      - run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add package.json
+          git commit -m "chore: bump version to $(node -p "require('./package.json').version") [skip ci]"
+          git tag v$(node -p "require('./package.json').version")
+          git push --tags
+          git push
+
+      - run: pnpm publish --provenance --access public

package/README.md

@@ -0,0 +1 @@
+# ts-utils

package/global.d.ts

@@ -0,0 +1,6 @@
+declare global {
+  type Nullable<T> = T | null;
+  type FetchError = { statusCode: number; statusMessage: string };
+}
+
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oricardopestana/ts-utils",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "TypeScript utilities",
   "homepage": "https://github.com/oricardopestana/ts-utils#readme",
   "bugs": {
@@ -14,7 +14,10 @@
   "author": "Ricardo Pestana (https://github.com/oricardopestana)",
   "type": "module",
   "main": "index.js",
+  "dependencies": {
+    "vitest": "^4.1.8"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run"
   }
-}
+}

package/use-async/index.spec.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { useAsync } from "./index";
+
+describe("useAsync", () => {
+  it("should return [data, null] when the promise resolves", async () => {
+    const [data, error] = await useAsync(() => Promise.resolve(42));
+    expect(data).toBe(42);
+    expect(error).toBeNull();
+  });
+
+  it("should return [null, reason] when the promise rejects with an Error", async () => {
+    const [data, error] = await useAsync(() => Promise.reject(new Error("Something went wrong")));
+    expect(data).toBeNull();
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe("Something went wrong");
+  });
+
+  it("should return [null, reason] when the promise rejects with a string", async () => {
+    const [data, error] = await useAsync(() => Promise.reject("Oops!"));
+    expect(data).toBeNull();
+    expect(error).toBe("Oops!");
+  });
+
+  it("should return [null, reason] when the promise rejects with a number", async () => {
+    const [data, error] = await useAsync(() => Promise.reject(404));
+    expect(data).toBeNull();
+    expect(error).toBe(404);
+  });
+
+  it("should handle a callback that throws synchronously", async () => {
+    const [data, error] = await useAsync(() => {
+      throw new Error("Sync throw");
+    });
+    expect(data).toBeNull();
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe("Sync throw");
+  });
+
+  it("should handle resolved undefined", async () => {
+    const [data, error] = await useAsync(() => Promise.resolve(undefined));
+    expect(data).toBeUndefined();
+    expect(error).toBeNull();
+  });
+
+  it("should handle resolved null", async () => {
+    const [data, error] = await useAsync(() => Promise.resolve(null));
+    expect(data).toBeNull();
+    expect(error).toBeNull();
+  });
+
+  it("should handle an empty async function", async () => {
+    const [data, error] = await useAsync(async () => {});
+    expect(data).toBeUndefined();
+    expect(error).toBeNull();
+  });
+});

package/use-async/index.ts

@@ -0,0 +1,26 @@
+export type AsyncResult<ResolveData, RejectionReason> =
+  | [data: null, reason: RejectionReason]
+  | [data: ResolveData, reason: null];
+
+/**
+ * Gracefully handles a callback that returns a promise.
+ *
+ * @example
+ * await useAsync(() => Promise.resolve(123))
+ * // [123, null]
+ *
+ * await useAsync(() => Promise.reject(new Error('Error message')))
+ * // [null, new Error('Oops!')]
+ */
+export async function useAsync<ResolveData = unknown, RejectionReason = Error>(
+  callback: () => Promise<ResolveData>,
+): Promise<AsyncResult<ResolveData, RejectionReason>> {
+  try {
+    const data = await callback().catch((error) => {
+      throw error;
+    });
+    return [data, null];
+  } catch (error: unknown) {
+    return [null, error as RejectionReason];
+  }
+}