@herrlich-digital/trycatch-wrapper 1.0.4

package/README.md

@@ -0,0 +1,114 @@
+# TryCatch-Wrapper
+
+![Release-Package](https://github.com/Herrlich-Digital/tryCatch-Wrapper/actions/workflows/release-package.yml/badge.svg)
+
+## Overview
+
+TryCatch-Wrapper is a lightweight utility designed to simplify error handling in TypeScript applications. It provides a structured approach to handling asynchronous errors using a `Result` type pattern, ensuring better code maintainability and readability.
+
+## Installation
+
+You can install the package from GitHub Packages using bun:
+
+```sh
+bun add @pr0gstar/trycatch-wrapper
+```
+
+or using npm:
+
+```sh
+npm install @pr0gstar/trycatch-wrapper
+```
+
+or using yarn:
+
+```sh
+yarn add @pr0gstar/trycatch-wrapper
+```
+
+## Usage
+
+### API
+
+The core function of this package is:
+
+```ts
+type Success<T> = {
+  data: T;
+  error: null;
+};
+
+type Failure<E> = {
+  data: null;
+  error: E;
+};
+
+type Result<T, E = Error> = Success<T> | Failure<E>;
+
+export async function tryCatch<T, E = Error>(
+  promise: Promise<T>,
+): Promise<Result<T, E>> {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error: error as E };
+  }
+}
+```
+
+### Basic Example
+
+```ts
+import { tryCatch } from "@pr0gstar/trycatch-wrapper";
+
+async function fetchData(): Promise<string> {
+  return await fetch("https://api.example.com/data").then((res) => res.json());
+}
+
+(async () => {
+  const { data, error } = await tryCatch(fetchData());
+  if (error) throw error;
+  console.log("Fetched data:", data);
+})();
+```
+
+### Handling Different Error Types
+
+```ts
+interface CustomError {
+  message: string;
+  code: number;
+}
+
+const { data, error } = await tryCatch<string, CustomError>(
+  Promise.reject({ message: "Something went wrong", code: 500 }),
+);
+
+if (error) throw new Error(`Error ${error.code}: ${error.message}`);
+
+console.log("Success:", data);
+```
+
+## Benefits
+
+- **Type Safety**: Ensures that both success and failure cases are handled properly.
+- **Avoids Try-Catch Blocks Everywhere**: Simplifies error handling for async operations.
+- **Structured Error Handling**: Uses a `Result<T, E>` type pattern for better maintainability.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Author
+
+Developed by Christoph Planken.
+
+## Links
+
+- [GitHub Repository](https://github.com/pr0gstar/trycatch-wrapper)
+- [GitHub Packages](https://github.com/pr0gstar?tab=packages)

package/dist/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  tryCatch: () => tryCatch
+});
+module.exports = __toCommonJS(index_exports);
+async function tryCatch(promise) {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tryCatch
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts"],"sourcesContent":["type Success<T> = {\n  data: T;\n  error: null;\n};\n\ntype Failure<E> = {\n  data: null;\n  error: E;\n};\n\ntype Result<T, E = Error> = Success<T> | Failure<E>;\n\nexport async function tryCatch<T, E = Error>(\n  promise: Promise<T>,\n): Promise<Result<T, E>> {\n  try {\n    const data = await promise;\n    return { data, error: null };\n  } catch (error) {\n    return { data: null, error: error as E };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,eAAsB,SACpB,SACuB;AACvB,MAAI;AACF,UAAM,OAAO,MAAM;AACnB,WAAO,EAAE,MAAM,OAAO,KAAK;AAAA,EAC7B,SAAS,OAAO;AACd,WAAO,EAAE,MAAM,MAAM,MAAkB;AAAA,EACzC;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+type Success<T> = {
+    data: T;
+    error: null;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+};
+type Result<T, E = Error> = Success<T> | Failure<E>;
+declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+
+export { tryCatch };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+type Success<T> = {
+    data: T;
+    error: null;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+};
+type Result<T, E = Error> = Success<T> | Failure<E>;
+declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+
+export { tryCatch };

package/dist/index.js

@@ -0,0 +1,13 @@
+// index.ts
+async function tryCatch(promise) {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+export {
+  tryCatch
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts"],"sourcesContent":["type Success<T> = {\n  data: T;\n  error: null;\n};\n\ntype Failure<E> = {\n  data: null;\n  error: E;\n};\n\ntype Result<T, E = Error> = Success<T> | Failure<E>;\n\nexport async function tryCatch<T, E = Error>(\n  promise: Promise<T>,\n): Promise<Result<T, E>> {\n  try {\n    const data = await promise;\n    return { data, error: null };\n  } catch (error) {\n    return { data: null, error: error as E };\n  }\n}\n"],"mappings":";AAYA,eAAsB,SACpB,SACuB;AACvB,MAAI;AACF,UAAM,OAAO,MAAM;AACnB,WAAO,EAAE,MAAM,OAAO,KAAK;AAAA,EAC7B,SAAS,OAAO;AACd,WAAO,EAAE,MAAM,MAAM,MAAkB;AAAA,EACzC;AACF;","names":[]}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@herrlich-digital/trycatch-wrapper",
+  "description": "A simple try-catch wrapper for TypeScript inspired by Golang",
+  "version": "1.0.4",
+  "entrypoint": "index.ts",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsup": "^8.4.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "keywords": [
+    "try",
+    "catch",
+    "trycatch",
+    "wrapper",
+    "typescript"
+  ],
+  "author": "Christoph Planken <Herrlich Digital>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Herrlich-Digital/tryCatch-Wrapper.git"
+  }
+}