feat: init

Author: tanishqmanuja

.github/workflows/release.yaml

@@ -0,0 +1,62 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: "Bump Type"
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  publish:
+    permissions:
+      contents: write
+      id-token: write
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout Source Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install Dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Set Git User
+        run: |
+          git config user.name "${GITHUB_ACTOR}"
+          git config user.email "${GITHUB_ACTOR}@users.noreply.github.com"
+
+      - name: Set NPM Config
+        run: npm config set //registry.npmjs.org/:_authToken "${NPM_TOKEN}"
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Bump version
+        run: bun run bump ${{ github.event.inputs.bump }}
+
+      - name: Build
+        run: bun run build
+
+      - name: Publish
+        run: npm publish --provenance --access public
+
+      - name: Commit
+        run: git push --follow-tags

.gitignore

@@ -0,0 +1,14 @@
+# Dependency directories
+node_modules/
+
+# Environment files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# Output files
+dist
+out
+

README.md

@@ -0,0 +1,56 @@
+# @microlib/try
+
+Easily convert promises or lazy synchronous functions to result
+
+### 🚀 Installation
+
+```bash
+npm install @microlib/try
+```
+
+```bash
+bun add @microlib/try
+```
+
+### 📖 Usage
+
+```ts
+import { Try } from "@microlib/try";
+
+function myTaskSync() {
+  if (Math.random() > 0.5) {
+    throw new Error("Something went wrong");
+  } else {
+    return "Success";
+  }
+}
+
+function myTaskAsync() {
+  return new Promise((resolve, reject) => {
+    if (Math.random() > 0.5) {
+      reject(new Error("Something went wrong"));
+    } else {
+      resolve("Success");
+    }
+  });
+}
+
+const resultSync = Try(myTaskSync);
+const resultAsync = await Try(myTaskAsync);
+
+console.log(resultSync);
+console.log(resultAsync);
+
+/* 
+
+Output can be any of these:
+{ ok: true, value: "Success" }
+OR
+{ ok: false, error: Error: Something went wrong }
+
+*/
+```
+
+## 🍀 Show your Support
+
+Give a ⭐️ if this project helped you!

bun.lockb

@@ -0,0 +1,56 @@
+{
+  "name": "@microlib/try",
+  "version": "0.0.0",
+  "description": "Easily convert promise to result",
+  "keywords": [
+    "promise",
+    "try",
+    "result"
+  ],
+  "type": "module",
+  "module": "src/index.ts",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "bump": "bun scripts/bump.ts",
+    "release": "bun scripts/release.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.11",
+    "unbuild": "^2.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.6.3"
+  },
+  "author": {
+    "name": "tanishqmanuja",
+    "url": "https://github.com/tanishqmanuja",
+    "email": "[email protected]"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microlib-js/try.git"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./result": {
+      "require": "./dist/result.cjs",
+      "import": "./dist/result.mjs",
+      "types": "./dist/result.d.ts"
+    },
+    "./utils": {
+      "require": "./dist/utils.cjs",
+      "import": "./dist/utils.mjs",
+      "types": "./dist/utils.d.ts"
+    },
+    "./package.json": "./package.json"
+  }
+}

package.json

@@ -0,0 +1,15 @@
+import { $ } from "bun";
+
+const bump = process.argv[2];
+
+if (!bump) {
+  console.error("Missing bump");
+  process.exit(1);
+}
+
+if (!["patch", "minor", "major"].includes(bump)) {
+  console.error("Invalid bump");
+  process.exit(1);
+}
+
+await $`npm version ${bump} -m "chore: bump version"`;

scripts/bump.ts

@@ -0,0 +1,49 @@
+import { $ } from "bun";
+
+import { version } from "../package.json";
+
+const WORKFLOW_ID = "release.yaml";
+
+const bump = process.argv[2] ?? "patch";
+
+if (!bump) {
+  console.error("Missing bump");
+  process.exit(1);
+}
+
+if (!["patch", "minor", "major"].includes(bump)) {
+  console.error("Invalid bump");
+  process.exit(1);
+}
+
+const { owner, repo } = await $`git config --get remote.origin.url`
+  .quiet()
+  .text()
+  .then((url) => {
+    const [owner, repo] = url.split("/").slice(-2);
+    if (!owner || !repo) {
+      throw new Error("Cannot find owner or repo");
+    }
+    return {
+      owner,
+      repo: repo.replace(".git", "").trim(),
+    };
+  });
+
+console.log(`Current Version: ${version}`);
+console.log(`Bump Type: ${bump}`);
+console.log(`Repo: ${owner}/${repo}`);
+
+console.log("\nDispatching workflow...");
+
+await $`gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
+  /repos/${owner}/${repo}/actions/workflows/${WORKFLOW_ID}/dispatches -f "ref=main" -f "inputs[bump]=${bump}"`
+  .quiet()
+  .then(() => {
+    console.log("Dispatched!");
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.log(e);
+    process.exit(1);
+  });

scripts/release.ts

@@ -0,0 +1,43 @@
+import {
+  isResultError,
+  isResultOk,
+  resultError,
+  resultOf,
+  resultOk,
+  type Result,
+} from "./result";
+import { isError, isPromise } from "./utils";
+
+export function trySync<T>(fn: () => T): Result<T> {
+  try {
+    const value = fn();
+    return resultOk(value);
+  } catch (e) {
+    const error = isError(e) ? e : new Error(String(e));
+    return resultError(error);
+  }
+}
+
+type MaybePromise<T> = T | Promise<T>;
+export function tryAsync<T>(fn: () => MaybePromise<T>): Promise<Result<T>> {
+  try {
+    const value = fn();
+    if (isPromise(value)) {
+      return value
+        .then((v) => resultOk(v))
+        .catch((e) => resultError(isError(e) ? e : new Error(String(e))));
+    }
+
+    return Promise.resolve(resultOk(value));
+  } catch (e) {
+    const error = isError(e) ? e : new Error(String(e));
+    return Promise.reject(resultError(error));
+  }
+}
+
+export const Try = Object.assign(resultOf, {
+  sync: trySync,
+  async: tryAsync,
+  isOk: isResultOk,
+  isError: isResultError,
+});

src/index.ts

@@ -0,0 +1,57 @@
+import { isPromise, isError } from "./utils";
+
+export type ResultOk<T> = {
+  ok: true;
+  value: T;
+};
+
+export type ResultError<E extends Error = Error> = {
+  ok: false;
+  error: E;
+};
+
+export type Result<T, E extends Error = Error> = ResultOk<T> | ResultError<E>;
+
+export function resultOk<T>(value: T): ResultOk<T> {
+  return {
+    ok: true,
+    value,
+  };
+}
+
+export function resultError<E extends Error = Error>(error: E): ResultError<E> {
+  return {
+    ok: false,
+    error,
+  };
+}
+
+export function isResultOk<T>(result: Result<T>): result is ResultOk<T> {
+  return result.ok;
+}
+
+export function isResultError<E extends Error = Error>(
+  result: Result<unknown, E>
+): result is ResultError<E> {
+  return !result.ok;
+}
+
+export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T>>;
+export function resultOf<T>(fn: () => T): Result<T>;
+export function resultOf<T>(
+  fn: () => Promise<T> | T
+): Result<T> | Promise<Result<T>> {
+  try {
+    const value = fn();
+    if (isPromise(value)) {
+      return value
+        .then((v) => resultOk(v))
+        .catch((e) => resultError(isError(e) ? e : new Error(String(e))));
+    }
+
+    return resultOk(value);
+  } catch (e) {
+    const error = isError(e) ? e : new Error(String(e));
+    return resultError(error);
+  }
+}

src/result.ts

@@ -0,0 +1,12 @@
+const toStr = Function.bind.call(
+  Function.call as typeof Function.prototype.toString,
+  Object.prototype.toString
+);
+
+export function isError(err: unknown): err is Error {
+  return !!err && toStr(err) === "[object Error]";
+}
+
+export function isPromise(value: unknown): value is Promise<unknown> {
+  return !!value && toStr(value) === "[object Promise]";
+}