@zokugun/xtry 0.2.0 → 0.4.0

package/README.md

@@ -119,19 +119,21 @@ API reference
 ### Result helpers
 
 ```typescript
-export type Success<T> = { fails: false; value: T; error: null };
-export type Failure<E> = { fails: true; value: null; error: E };
-export type Result<T, E> = Success<T> | Failure<E>;
+type Success<T> = { fails: false; value: T; error: undefined };
+type Failure<E> = { fails: true; value: undefined; error: E };
+type Result<T, E> = Success<T> | Failure<E>;
 
-export function ok<T>(value: T): Success<T>;
-export function err<E>(error: E): Failure<E>;
+function ok<T>(value: T): Success<T>;
+function err<E>(error: E): Failure<E>;
 ```
 
 ### Try helpers
 
 ```typescript
-export function xtry<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: E) => void): Result<T, E>;
-export function xatry<T, E>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: (error: E) => void): Promise<Result<T, E>>;
+function xtry<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
+function xatry<T, E>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: (error: unknown) => void | E): Promise<Result<T, E>>;
+
+function stringifyError(error: unknown): string;
 ```
 
 Both helpers:
@@ -143,12 +145,15 @@ Both helpers:
 ### Partial helpers
 
 ```typescript
-export type YSuccess<T> = Success<T> & { success: true };
-export type YFailure<S> = { fails: false; success: false; type: S; value: null; error: null };
-export type YResult<T, E, S> = Failure<E> | YSuccess<T> | YFailure<S>;
-
-export function yok<T>(value: T): YSuccess<T>;
-export function yerr<S>(type: S): YFailure<S>;
+type YSuccess<T> = Success<T> & { success: true };
+type YFailure<M> = { fails: false; success: false; miscue: M; value: undefined; error: undefined };
+type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+
+function yok<T>(value: T): YSuccess<T>;
+function yerr<M>(type: M): YFailure<M>;
+function yress<T, E>(result: Result<T, E>): Failure<E> | YSuccess<T>;
+function yresa<T, E>(promise: Promise<Result<T, E>>): Promise<Failure<E> | YSuccess<T>>;
+function yep<T>(result: Success<T>): YSuccess<T>;
 ```
 
 These helpers are useful when you need to separate soft rejections (`success: false`) from hard failures (`fails: true`).

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './partial.js';
 export * from './result.js';
+export * from './stringify-error.js';
 export * from './try.js';

package/lib/index.js

@@ -1,3 +1,4 @@
 export * from './partial.js';
 export * from './result.js';
+export * from './stringify-error.js';
 export * from './try.js';

package/lib/partial.d.ts

@@ -1,14 +1,17 @@
-import { type Failure, type Success } from './result.js';
-export type YResult<T, E, S> = Failure<E> | YSuccess<T> | YFailure<S>;
+import { type Result, type Failure, type Success } from './result.js';
+export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
 export type YSuccess<T> = Success<T> & {
     success: true;
 };
-export type YFailure<S> = {
+export type YFailure<M> = {
     fails: false;
     success: false;
-    type: S;
-    value: null;
-    error: null;
+    miscue: M;
+    value: undefined;
+    error: undefined;
 };
 export declare function yok<T>(value: T): YSuccess<T>;
-export declare function yerr<S>(type: S): YFailure<S>;
+export declare function yerr<M>(miscue: M): YFailure<M>;
+export declare function yress<T, E>(result: Result<T, E>): Failure<E> | YSuccess<T>;
+export declare function yresa<T, E>(promise: Promise<Result<T, E>>): Promise<Failure<E> | YSuccess<T>>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;

package/lib/partial.js

@@ -3,15 +3,30 @@ export function yok(value) {
         fails: false,
         success: true,
         value,
-        error: null,
+        error: undefined,
     };
 }
-export function yerr(type) {
+export function yerr(miscue) {
     return {
         fails: false,
         success: false,
-        type,
-        value: null,
-        error: null,
+        miscue,
+        value: undefined,
+        error: undefined,
+    };
+}
+export function yress(result) {
+    if (result.fails) {
+        return result;
+    }
+    return yep(result);
+}
+export async function yresa(promise) {
+    return promise.then(yress);
+}
+export function yep(result) {
+    return {
+        ...result,
+        success: true,
     };
 }

package/lib/result.d.ts

@@ -1,11 +1,11 @@
 export type Success<T> = {
     fails: false;
     value: T;
-    error: null;
+    error: undefined;
 };
 export type Failure<E> = {
     fails: true;
-    value: null;
+    value: undefined;
     error: E;
 };
 export type Result<T, E> = Success<T> | Failure<E>;

package/lib/result.js

@@ -2,13 +2,13 @@ export function ok(value) {
     return {
         fails: false,
         value,
-        error: null,
+        error: undefined,
     };
 }
 export function err(error) {
     return {
         fails: true,
-        value: null,
+        value: undefined,
         error,
     };
 }

package/lib/stringify-error.d.ts

@@ -0,0 +1 @@
+export declare function stringifyError(error: unknown): string;

package/lib/stringify-error.js

@@ -0,0 +1,18 @@
+export function stringifyError(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message ?? String(error);
+    }
+    try {
+        const json = JSON.stringify(error);
+        if (typeof json === 'string') {
+            return json;
+        }
+    }
+    catch {
+        // fallthrough
+    }
+    return String(error);
+}

package/lib/try.d.ts

@@ -1,3 +1,3 @@
 import { type Result } from './result.js';
-export declare function xtry<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: ((error: E) => void)): Result<T, E>;
-export declare function xatry<T, E>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: ((error: E) => void)): Promise<Result<T, E>>;
+export declare function xtry<T, E = unknown>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => E | undefined): E extends void ? Result<T, unknown> : Result<T, E>;
+export declare function xatry<T, E = unknown>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: (error: unknown) => E | undefined): Promise<E extends void ? Result<T, unknown> : Result<T, E>>;

package/lib/try.js

@@ -2,24 +2,36 @@ import { err, ok } from './result.js';
 export function xtry(func, handler) {
     try {
         const value = func();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return ok(value);
     }
     catch (error) {
         if (handler) {
-            handler(error);
+            const newError = handler(error);
+            if (newError !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return err(newError);
+            }
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return err(error);
     }
 }
 export async function xatry(func, handler) {
     try {
         const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return ok(value);
     }
     catch (error) {
         if (handler) {
-            handler(error);
+            const newError = handler(error);
+            if (newError !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return err(newError);
+            }
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return err(error);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/xtry",
 	"description": "simple try/catch wrapper returning Result",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"