@terrygonguet/utils 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -11,7 +11,7 @@ declare function yesno(value?: string): boolean;
 declare function mapListPush<Key, T>(map: Map<Key, T[]>, key: Key, value: T): Map<Key, T[]>;
 declare function recordListPush<Key extends string, T>(record: Record<Key, T[]>, key: Key, value: T): Record<Key, T[]>;
 type ExecResult<T, Err = Error> = [null, T] | [Err, null];
-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>;
+declare function tryCatch<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<infer T> ? Promise<ExecResult<T>> : ExecResult<ReturnType<F>>;
+declare function tryCatch<Err, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<infer T> ? Promise<ExecResult<T, Err>> : ExecResult<ReturnType<F>, Err>;
 
 export { type ExecResult, clamp, createNoopProxy, exhaustive, hash, mapListPush, noop, range, recordListPush, tryCatch, yesno };

package/dist/result.d.ts

@@ -1,7 +1,10 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
 declare class Result<Err extends Error, T> {
     value: T | null;
     error: Err | null;
-    constructor(value: T | null, error: Err | null);
+    constructor(value: null, error: Err);
+    constructor(value: T, error: null);
     asTuple(): [Err, null] | [null, T];
     asObject(): {
         value: null;
@@ -10,8 +13,10 @@ declare class Result<Err extends Error, T> {
         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>>;
-    recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): ReturnType<F> extends Promise<any> ? AsyncResult<Err2, T> : Result<Err2, T>;
+    andThen<Err2 extends Error, F extends (value: T) => any>(f: F): ReturnType<F> extends Promise<infer U> ? AsyncResult<Err | Err2, U> : Result<Err | Err2, ReturnType<F>>;
+    match(onValue: (value: T) => void): void;
+    match<U>(onValue: (value: T) => U, onError: (error: Err) => U): U;
+    recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): ReturnType<F> extends Promise<T> ? AsyncResult<Err2, T> : Result<Err2, T>;
     unwrap(): T;
     unwrapErr(): Err;
 }
@@ -28,6 +33,8 @@ declare class AsyncResult<Err extends Error, T> {
     }>;
     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>>>;
+    match(onValue: (value: T) => void): Promise<void>;
+    match<U>(onValue: (value: T) => U, onError: (error: Err) => U): Promise<U>;
     recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): AsyncResult<Err2, T>;
     unwrap(): Promise<T>;
     unwrapErr(): Promise<Err>;
@@ -35,5 +42,15 @@ declare class AsyncResult<Err extends Error, T> {
 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>>;
+declare class SafeFunctionValidationError extends Error {
+    name: string;
+    issues: StandardSchemaV1.FailureResult["issues"];
+    constructor(message: string, issues: StandardSchemaV1.FailureResult["issues"], options?: ErrorOptions);
+}
+interface MakeSafeFnOptions<ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined> {
+    paramsSchema?: ParamsSchema;
+    returnSchema?: ReturnSchema;
+}
+declare function makeSafeFn<Err extends Error, ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined, F extends (...args: ParamsSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ParamsSchema> : any) => ReturnSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ReturnSchema> : any>(f: F, options?: MakeSafeFnOptions<ParamsSchema, ReturnSchema>): (...args: Parameters<F>) => Result<Err, ReturnType<F>>;
 
-export { safe };
+export { AsyncResult, Result, SafeFunctionValidationError, makeSafeFn, safe };

package/dist/result.js

@@ -13,29 +13,31 @@ var Result = class _Result {
     return { value: this.value, error: this.error };
   }
   andThen(f) {
-    if (this.error || !this.value) return this;
+    if (this.error) return this;
     try {
       const newValue = f(this.value);
-      if (newValue instanceof Promise)
-        return new AsyncResult(newValue);
+      if (newValue instanceof Promise) return new AsyncResult(newValue);
       else return new _Result(newValue, null);
     } catch (error) {
       return new _Result(null, RawError.wrap(error));
     }
   }
+  match(onValue, onError) {
+    if (this.error) return onError?.(this.error);
+    else return onError ? onValue(this.value) : void onValue(this.value);
+  }
   recover(f) {
     if (!this.error) return this;
     try {
       const newValue = f(this.error);
-      if (newValue instanceof Promise)
-        return new AsyncResult(newValue);
+      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;
+    if (!this.error) return this.value;
     else throw new Error("Tried to unwrap a failed Result");
   }
   unwrapErr() {
@@ -63,6 +65,12 @@ var AsyncResult = class _AsyncResult {
   andThen(f) {
     return new _AsyncResult(this.promise.then((value) => f(value)));
   }
+  match(onValue, onError) {
+    return this.promise.then(
+      (value) => onError ? onValue(value) : void onValue(value),
+      (error) => onError?.(error)
+    );
+  }
   recover(f) {
     return new _AsyncResult(
       this.promise.then(
@@ -91,8 +99,7 @@ var RawError = class _RawError extends Error {
   }
 };
 function safe(promiseOrFunction, ...args) {
-  if (promiseOrFunction instanceof Promise)
-    return new AsyncResult(promiseOrFunction);
+  if (promiseOrFunction instanceof Promise) return new AsyncResult(promiseOrFunction);
   try {
     const value = promiseOrFunction(...args);
     if (value instanceof Promise) return new AsyncResult(value);
@@ -101,6 +108,46 @@ function safe(promiseOrFunction, ...args) {
     return new Result(null, RawError.wrap(error));
   }
 }
+var SafeFunctionValidationError = class extends Error {
+  name = "SafeFunctionValidationError";
+  issues;
+  constructor(message, issues, options) {
+    super(message, options);
+    this.issues = issues;
+  }
+};
+function makeSafeFn(f, options) {
+  return function(...args) {
+    if (options?.paramsSchema) {
+      const parsed = options.paramsSchema["~standard"].validate(args);
+      if ("then" in parsed)
+        return new Result(
+          null,
+          new TypeError("[makeSafeFn] Parameters check failed: Async schemas are not supported")
+        );
+      else if (parsed.issues)
+        return new Result(
+          null,
+          new SafeFunctionValidationError("[makeSafeFn] Parameters check failed", parsed.issues)
+        );
+      else args = parsed.value;
+    }
+    if (options?.returnSchema)
+      return safe(f, ...args).andThen((returned) => {
+        const parsed = options.returnSchema["~standard"].validate(returned);
+        if ("then" in parsed)
+          throw new TypeError("[makeSafeFn] Return check failed: Async schemas are not supported");
+        else if (parsed.issues)
+          throw new SafeFunctionValidationError("[makeSafeFn] Return check failed", parsed.issues);
+        else return parsed.value;
+      });
+    else return safe(f, ...args);
+  };
+}
 export {
+  AsyncResult,
+  Result,
+  SafeFunctionValidationError,
+  makeSafeFn,
   safe
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.10.0",
+	"version": "0.11.0",
 	"type": "module",
 	"license": "MIT",
 	"scripts": {
@@ -14,41 +14,48 @@
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
 		},
 		"./async": {
 			"types": "./dist/async.d.ts",
-			"import": "./dist/async.js"
+			"import": "./dist/async.js",
+			"default": "./dist/async.js"
 		},
 		"./json": {
 			"types": "./dist/json.d.ts",
-			"import": "./dist/json.js"
+			"import": "./dist/json.js",
+			"default": "./dist/json.js"
 		},
 		"./option": {
 			"types": "./dist/option.d.ts",
-			"import": "./dist/option.js"
+			"import": "./dist/option.js",
+			"default": "./dist/option.js"
 		},
 		"./random": {
 			"types": "./dist/random.d.ts",
-			"import": "./dist/random.js"
+			"import": "./dist/random.js",
+			"default": "./dist/random.js"
 		},
 		"./result": {
 			"types": "./dist/result.d.ts",
-			"import": "./dist/result.js"
+			"import": "./dist/result.js",
+			"default": "./dist/result.js"
 		},
 		"./tableau": {
 			"types": "./dist/tableau.d.ts",
-			"import": "./dist/tableau.js"
+			"import": "./dist/tableau.js",
+			"default": "./dist/tableau.js"
 		}
 	},
 	"devDependencies": {
 		"@types/benchmark": "^2.1.5",
 		"benchmark": "^2.1.4",
-		"prettier": "^3.6.2",
-		"tsup": "^8.5.0",
+		"prettier": "^3.8.1",
+		"tsup": "^8.5.1",
 		"typescript": "^5.9.3",
-		"vite": "^7.1.12",
-		"vitest": "^4.0.2"
+		"vite": "^8.0.0",
+		"vitest": "^4.1.0"
 	},
 	"author": {
 		"email": "terry@gonguet.com",
@@ -63,6 +70,6 @@
 		"url": "https://github.com/terrygonguet/utils/issues"
 	},
 	"dependencies": {
-		"@standard-schema/spec": "^1.0.0"
+		"@standard-schema/spec": "^1.1.0"
 	}
 }