go-go-try 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Alisson Cavalcante Agiani thelinuxlich@gmail.com https://astoilkov.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# `go-go-try`
+
+> Tries to execute a sync/async function, returns a specified default value if the function throws.
+
+[![Gzipped Size](https://img.shields.io/bundlephobia/minzip/good-try)](https://bundlephobia.com/result?p=good-try)
+[![Build Status](https://img.shields.io/github/workflow/status/astoilkov/good-try/CI)](https://github.com/astoilkov/good-try/actions/workflows/main.yml)
+
+## Why
+
+Why not [`nice-try`](https://github.com/electerious/nice-try) with it's 70+ million downloads per month?
+
+-   `go-go-try` supports async functions.
+-   `go-go-try` supports an optional default value.
+-   `go-go-try` allows you to capture the thrown error.
+-   `go-go-try` is written in TypeScript. The types are written in a way that reduce developer errors.
+-   `go-go-try` is inspired by Golang error catching.
+
+Why not just `try`/`catch`?
+
+-   In a lot of cases, `try`/`catch` is still the better option.
+-   Nested `try`/`catch` statements are hard to process mentally. They also indent the code and make it hard to read. A single `try`/`catch` does the same but to a lesser degree.
+-   If you [prefer const](https://eslint.org/docs/latest/rules/prefer-const), `try`/`catch` statements get in the way because you need to use `let` if you need the variable outside of the `try`/`catch` scope:
+    ```ts
+    let todos
+    try {
+        todos = JSON.parse(localStorage.getItem('todos'))
+    } catch {}
+    return todos.filter((todo) => todo.done)
+    ```
+-   It takes more space. It's slower to type.
+
+## Install
+
+```bash
+npm install go-go-try
+```
+
+## Usage
+
+```ts
+import goTry from 'go-go-try'
+
+// tries to parse todos, returns empty array if it fails
+const [_, value] = goTry(() => JSON.parse(todos), [])
+
+// fetch todos, on error, fallback to empty array
+const [_, todos] = await goTry(fetchTodos(), [])
+
+// fetch todos, fallback to empty array, send error to your error tracking service
+const [err, todos] = await goTry(fetchTodos(), [])
+sentToErrorTrackingService(err)
+```
+
+## API
+
+**First parameter** accepts:
+
+-   synchronous function `goTry(() => JSON.parse(value))`
+-   asynchronous function / Promise
+
+**Second parameter** accepts:
+
+-   a value of the same type of the first parameter that will be returned if the first parameter throws
+
+**Returns** a tuple with the possible error and result (Golang style)
+If you use TypeScript, the types are well defined and won't let you make a mistake.
+
+## Inspiration
+
+-   This library started as a fork of [good-try](https://github.com/astoilkov/good-try) but diverged a lot so I decided to rename it

package/index.d.ts

@@ -0,0 +1,4 @@
+declare type ResultTuple<T> = [string?, T?];
+export default function goTry<T>(value: Promise<T>, defaultValue?: T): Promise<ResultTuple<T>>;
+export default function goTry<T>(value: () => T, defaultValue?: T): ResultTuple<T>;
+export {};

package/index.js

@@ -0,0 +1,37 @@
+import pIsPromise from 'p-is-promise';
+function isErrorWithMessage(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+function toErrorWithMessage(maybeError) {
+    if (isErrorWithMessage(maybeError)) {
+        return maybeError;
+    }
+    try {
+        return new Error(JSON.stringify(maybeError));
+    }
+    catch {
+        // fallback in case there's an error stringifying the maybeError
+        // like with circular references for example.
+        return new Error(String(maybeError));
+    }
+}
+function getErrorMessage(error) {
+    return toErrorWithMessage(error).message;
+}
+export default function goTry(value, defaultValue) {
+    try {
+        const unwrappedValue = typeof value === 'function' ? value() : value;
+        if (pIsPromise(unwrappedValue)) {
+            return Promise.resolve(unwrappedValue)
+                .then((value) => [undefined, value])
+                .catch((err) => [getErrorMessage(err), defaultValue]);
+        }
+        return [undefined, unwrappedValue];
+    }
+    catch (err) {
+        return [getErrorMessage(err), defaultValue];
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "go-go-try",
+    "version": "1.0.0",
+    "description": "Tries to execute a sync/async function, returns a result tuple",
+    "license": "MIT",
+    "repository": "thelinuxlich/go-go-try",
+    "author": {
+        "name": "Alisson Cavalcante Agiani",
+        "email": "thelinuxlich@gmail.com"
+    },
+    "type": "module",
+    "main": "./index.js",
+    "types": "./index.d.ts",
+    "sideEffects": false,
+    "engines": {
+        "node": ">=12"
+    },
+    "scripts": {
+        "build": "tsc",
+        "lint": "eslint --cache --format=pretty --ext=.ts ./",
+        "test": "yarn run build && yarn run lint && NODE_OPTIONS=--experimental-vm-modules jest --coverage --coverageReporters=text",
+        "release": "yarn run build && np",
+        "prettier": "prettier --write --config .prettierrc.yaml {*.ts,*.json}"
+    },
+    "files": [
+        "index.js",
+        "src/*.js",
+        "index.d.ts",
+        "src/*.d.ts"
+    ],
+    "keywords": [
+        "errors",
+        "try",
+        "catch",
+        "error handling",
+        "nice-try",
+        "good-try",
+        "go-try"
+    ],
+    "devDependencies": {
+        "@types/jest": "^28.1.1",
+        "@typescript-eslint/eslint-plugin": "^5.27.1",
+        "@typescript-eslint/parser": "^5.27.1",
+        "confusing-browser-globals": "^1.0.11",
+        "eslint": "^8.17.0",
+        "eslint-config-strictest": "^0.4.0",
+        "eslint-formatter-pretty": "^4.0.0",
+        "eslint-plugin-promise": "^6.0.0",
+        "eslint-plugin-unicorn": "^42.0.0",
+        "jest": "^28.1.1",
+        "jest-environment-jsdom": "^28.1.1",
+        "np": "^7.6.1",
+        "prettier": "^2.6.2",
+        "ts-jest": "^28.0.4",
+        "ts-node": "^10.8.2",
+        "typescript": "^4.7.3"
+    },
+    "dependencies": {
+        "p-is-promise": "^4.0.0"
+    }
+}