@terrygonguet/utils 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -9,9 +9,7 @@ declare function hash(message: string): Promise<ArrayBuffer>;
 declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
 declare function yesno(value?: string): boolean;
 type ExecResult<T, Err = Error> = [null, T] | [Err, null];
-declare function safe<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>>> : ExecResult<ReturnType<F>>;
-declare function safe<Err, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>, Err>> : ExecResult<ReturnType<F>, Err>;
-declare const exec: typeof safe;
-declare const run: typeof safe;
+declare function tryCatch<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>>> : ExecResult<ReturnType<F>>;
+declare function tryCatch<Err, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>, Err>> : ExecResult<ReturnType<F>, Err>;
 
-export { type ExecResult, clamp, createNoopProxy, exec, exhaustive, hash, noop, range, run, safe, yesno };
+export { type ExecResult, clamp, createNoopProxy, exhaustive, hash, noop, range, tryCatch, yesno };

package/dist/index.js

@@ -47,7 +47,7 @@ function yesno(value) {
       return false;
   }
 }
-function safe(f, ...args) {
+function tryCatch(f, ...args) {
   try {
     const promiseOrResult = f(...args);
     if (promiseOrResult instanceof Promise)
@@ -60,17 +60,13 @@ function safe(f, ...args) {
     return [error, null];
   }
 }
-var exec = safe;
-var run = safe;
 export {
   clamp,
   createNoopProxy,
-  exec,
   exhaustive,
   hash,
   noop,
   range,
-  run,
-  safe,
+  tryCatch,
   yesno
 };

package/dist/result.d.ts

@@ -0,0 +1,37 @@
+declare class Result<Err extends Error, T> {
+    value: T | null;
+    error: Err | null;
+    constructor(value: T | null, error: Err | null);
+    asTuple(): [Err, null] | [null, T];
+    asObject(): {
+        value: null;
+        error: Err;
+    } | {
+        value: T;
+        error: null;
+    };
+    andThen<Err2 extends Error, F extends (value: T) => any>(f: F): ReturnType<F> extends Promise<any> ? AsyncResult<Err | Err2, Awaited<ReturnType<F>>> : Result<Err | Err2, ReturnType<F>>;
+    unwrap(): T;
+    unwrapErr(): Err;
+}
+declare class AsyncResult<Err extends Error, T> {
+    promise: Promise<T>;
+    constructor(promise: Promise<T>);
+    asTuple(): Promise<[Err, null] | [null, T]>;
+    asObject(): Promise<{
+        value: null;
+        error: Err;
+    } | {
+        value: T;
+        error: null;
+    }>;
+    then<U>(cb: (value: Result<Err, T>) => U | Promise<U>): Promise<U>;
+    andThen<Err2 extends Error, F extends (value: T) => any>(f: F): AsyncResult<Err | Err2, Awaited<ReturnType<F>>>;
+    unwrap(): Promise<T>;
+    unwrapErr(): Promise<Err>;
+}
+declare function safe<Err extends Error, T>(promise: Promise<T>): AsyncResult<Error, T>;
+declare function safe<Err extends Error, F extends (...args: any) => Promise<any>>(f: F, ...args: Parameters<F>): AsyncResult<Err, Awaited<ReturnType<F>>>;
+declare function safe<Err extends Error, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): Result<Err, ReturnType<F>>;
+
+export { safe };

package/dist/result.js

@@ -0,0 +1,87 @@
+// src/result.ts
+var Result = class _Result {
+  value;
+  error;
+  constructor(value, error) {
+    this.value = value;
+    this.error = error;
+  }
+  asTuple() {
+    return [this.error, this.value];
+  }
+  asObject() {
+    return { value: this.value, error: this.error };
+  }
+  andThen(f) {
+    if (this.error || !this.value) return this;
+    try {
+      const newValue = f(this.value);
+      if (newValue instanceof Promise)
+        return new AsyncResult(newValue);
+      else return new _Result(newValue, null);
+    } catch (error) {
+      return new _Result(null, RawError.wrap(error));
+    }
+  }
+  unwrap() {
+    if (this.value && !this.error) return this.value;
+    else throw new Error("Tried to unwrap a failed Result");
+  }
+  unwrapErr() {
+    if (this.error) return this.error;
+    else throw new Error("Tried to unwrapErr a successful Result");
+  }
+};
+var AsyncResult = class _AsyncResult {
+  promise;
+  constructor(promise) {
+    this.promise = promise;
+  }
+  asTuple() {
+    return this.then((result) => result.asTuple());
+  }
+  asObject() {
+    return this.then((result) => result.asObject());
+  }
+  then(cb) {
+    return this.promise.then(
+      (value) => cb(new Result(value, null)),
+      (error) => cb(new Result(null, RawError.wrap(error)))
+    );
+  }
+  andThen(f) {
+    return new _AsyncResult(this.promise.then((value) => f(value)));
+  }
+  unwrap() {
+    return this.then((result) => result.unwrap());
+  }
+  unwrapErr() {
+    return this.then((result) => result.unwrapErr());
+  }
+};
+var RawError = class _RawError extends Error {
+  name = "RawError";
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  static wrap(error) {
+    if (error instanceof Error) return error;
+    else return new _RawError(error);
+  }
+};
+function safe(promiseOrFunction, ...args) {
+  if (promiseOrFunction instanceof Promise)
+    return new AsyncResult(promiseOrFunction);
+  try {
+    const value = promiseOrFunction(...args);
+    if (value instanceof Promise) return new AsyncResult(value);
+    else return new Result(value, null);
+  } catch (error) {
+    return new Result(null, RawError.wrap(error));
+  }
+}
+export {
+  safe
+};

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"type": "module",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite",
 		"build": "tsup",
-		"test": "vitest test --update"
+		"test": "vitest test --update --typecheck"
 	},
 	"files": [
 		"dist"
@@ -31,14 +31,18 @@
 		"./tableau": {
 			"types": "./dist/tableau.d.ts",
 			"import": "./dist/tableau.js"
+		},
+		"./result": {
+			"types": "./dist/result.d.ts",
+			"import": "./dist/result.js"
 		}
 	},
 	"devDependencies": {
-		"prettier": "^3.5.2",
-		"tsup": "^8.3.6",
-		"typescript": "^5.7.3",
-		"vite": "^6.1.1",
-		"vitest": "^3.0.6"
+		"prettier": "^3.5.3",
+		"tsup": "^8.4.0",
+		"typescript": "^5.8.2",
+		"vite": "^6.2.3",
+		"vitest": "^3.0.9"
 	},
 	"author": {
 		"email": "terry@gonguet.com",