@aurelle/result - npm Package Compare versions

Comparing version 1.0.2 to 1.1.0

dist/index.d.ts

@@ -15,3 +15,3 @@ type SplitResult<T, E> = [T, null] | [null, E];
 export declare const Err: <T = unknown, E = Error>(e: E) => Result<T, E>;
-export declare const resultify: <T extends (...args: any[]) => any>(fn: T) => (...args: Parameters<T>) => ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error>;
+export declare const resultify: <T extends (...args: unknown[]) => unknown>(fn: T) => (...args: Parameters<T>) => ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error>;
 export {};

dist/index.js

@@ -9,3 +9,3 @@ "use strict";
         unwrap: () => val,
-        unwrap_or_default: (_dflt) => val,
+        unwrap_or_default: () => val,
         split: () => [val, null],
@@ -34,2 +34,3 @@ };
             return new Promise((resolve) => {
+                ;
                 r
@@ -41,3 +42,3 @@ .then((val) => resolve((0, exports.Ok)(val)))
         catch (e) {
-            return (0, exports.Err)(new Error(e.toString()));
+            return (0, exports.Err)(new Error(`${e}`));
         }
@@ -44,0 +45,0 @@ };

package.json

 {
   "name": "@aurelle/result",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Simple error handling library inspired by Rust's Result type",
@@ -11,3 +11,6 @@ "scripts": {
     "build": "npm-run-all clean build-with-types",
-    "emit": "tsc --rootDir ./src --emitDeclarationOnly --declaration --outDir dist"
+    "emit": "tsc --rootDir ./src --emitDeclarationOnly --declaration --outDir dist",
+    "lint": "eslint src/**/*.ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -17,2 +20,3 @@ "publishConfig": {
   },
+  "type": "module",
   "main": "dist/index.js",
@@ -24,8 +28,15 @@ "types": "dist/index.d.ts",
   "devDependencies": {
+    "@eslint/js": "^9.4.0",
     "@types/node": "^20.14.2",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "globals": "^15.4.0",
     "npm-run-all": "^4.1.5",
+    "prettier": "3.3.1",
     "rimraf": "^5.0.7",
     "semantic-release": "^24.0.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.12.0"
   }
 }

README.md

@@ -77,1 +77,5 @@ A Typescript error handling library inspired by Rust's Result type.
 Note that `resultify` also works with async functions. It will return a function that returns a `Promise<Result<T, E>>`.
+
+#### Working around `this` context issues
+
+If you need to use a method that relies on the `this` context, you should call `bind` appropriately or wrap the call in a lambda function.

src/index.ts

@@ -1,52 +0,68 @@
-type SplitResult<T, E> = [T, null] | [null, E];
+type SplitResult<T, E> = [T, null] | [null, E]
 
 type ResultCore<T, E> = {
-	unwrap: () => T;
-	unwrap_or_default: <D>(dflt: D) => T | D;
-	split: () => SplitResult<T, E>
+    unwrap: () => T
+    unwrap_or_default: <D>(dflt: D) => T | D
+    split: () => SplitResult<T, E>
 }
 
-export type Result<T = unknown, E = Error> = ({ err: null, val: T } | { err: E }) & ResultCore<T, E>;
+export type Result<T = unknown, E = Error> = (
+    | { err: null; val: T }
+    | { err: E }
+) &
+    ResultCore<T, E>
 
 export const Ok = <T = void>(val: T): Result<T> => {
-	return {
-		val,
-		err: null,
-		unwrap: () => val,
-		unwrap_or_default: (_dflt) => val,
-		split: () => [val, null],
-	}
+    return {
+        val,
+        err: null,
+        unwrap: () => val,
+        unwrap_or_default: () => val,
+        split: () => [val, null],
+    }
 }
 
 export const Err = <T = unknown, E = Error>(e: E): Result<T, E> => {
-	return {
-		err: e,
-		unwrap: () => {
-			throw e;
-		},
-		unwrap_or_default: (dflt) => dflt,
-		split: () => [null, e],
-	}
+    return {
+        err: e,
+        unwrap: () => {
+            throw e
+        },
+        unwrap_or_default: (dflt) => dflt,
+        split: () => [null, e],
+    }
 }
 
-export const resultify = <T extends (...args: any[]) => any>(
-  fn: T
-): (...args: Parameters<T>) => ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error> => {
-  return (...args: Parameters<T>) => {
-    try {
-      const r = fn(...args);
+export const resultify = <T extends (...args: unknown[]) => unknown>(
+    fn: T
+): ((
+    ...args: Parameters<T>
+) => ReturnType<T> extends Promise<infer U>
+    ? Promise<Result<U, Error>>
+    : Result<ReturnType<T>, Error>) => {
+    return (...args: Parameters<T>) => {
+        try {
+            const r = fn(...args)
 
-      if (!(r instanceof Promise)) {
-        return Ok(r) as ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error>;
-      }
+            if (!(r instanceof Promise)) {
+                return Ok(r) as ReturnType<T> extends Promise<infer U>
+                    ? Promise<Result<U, Error>>
+                    : Result<ReturnType<T>, Error>
+            }
 
-      return new Promise<Result<ReturnType<T>, Error>>((resolve) => {
-        (r as Promise<ReturnType<T>>)
-          .then((val) => resolve(Ok(val)))
-          .catch((err) => resolve(Err(err)));
-      }) as ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error>;
-    } catch (e: any) {
-      return Err(new Error(e.toString())) as ReturnType<T> extends Promise<infer U> ? Promise<Result<U, Error>> : Result<ReturnType<T>, Error>;
+            return new Promise<Result<ReturnType<T>, Error>>((resolve) => {
+                ;(r as Promise<ReturnType<T>>)
+                    .then((val) => resolve(Ok(val)))
+                    .catch((err) => resolve(Err(err)))
+            }) as ReturnType<T> extends Promise<infer U>
+                ? Promise<Result<U, Error>>
+                : Result<ReturnType<T>, Error>
+        } catch (e: unknown) {
+            return Err(new Error(`${e}`)) as ReturnType<T> extends Promise<
+                infer U
+            >
+                ? Promise<Result<U, Error>>
+                : Result<ReturnType<T>, Error>
+        }
     }
-  };
-};
+}

New alerts

No tests

Quality

Package does not have any tests. This is a strong signal of a poorly maintained or low quality package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

9243

increased by26.03%

Number of package files

11

increased by57.14%

Lines of code

154

increased by30.51%

Number of lines in readme file

81

increased by5.19%

Is type module

Yes

Worsened metrics

Dev dependency count

12

increased by140%

Number of low quality alerts

2

increased by100%

No dependency changes