@terrygonguet/utils 0.4.1 → 0.6.0

package/dist/async.d.ts

@@ -5,11 +5,21 @@ interface RetryOptions {
 }
 declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
 declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
-interface AsyncMapOptions {
+interface AsyncMapOptions<FailFast extends boolean = false, WithSourceIndexes extends boolean = false> {
     concurrent?: number;
+    failFast?: FailFast;
+    withSourceIndexes?: WithSourceIndexes;
+}
+interface AsyncMapResultWithIndexes<U> {
+    results: [i: number, value: U][];
+    errors: [i: number, error: unknown][];
+}
+interface AsyncMapResult<U> {
+    results: U[];
+    errors: unknown[];
 }
-declare function asyncMap<T, U>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions): (data: T[]) => Promise<U[]>;
-declare function asyncMap<T, U>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions): Promise<U[]>;
 type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>;
+declare function asyncMap<T, U, FailFast extends boolean = false, WithSourceIndexes extends boolean = false>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions<FailFast, WithSourceIndexes>): (data: T[]) => Promise<FailFast extends true ? WithSourceIndexes extends true ? [i: number, value: U][] : U[] : WithSourceIndexes extends true ? AsyncMapResultWithIndexes<U> : AsyncMapResult<U>>;
+declare function asyncMap<T, U, FailFast extends boolean = false, WithSourceIndexes extends boolean = false>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions<FailFast, WithSourceIndexes>): Promise<FailFast extends true ? WithSourceIndexes extends true ? [i: number, value: U][] : U[] : WithSourceIndexes extends true ? AsyncMapResultWithIndexes<U> : AsyncMapResult<U>>;
 
 export { asyncMap, pause, retry };

package/dist/async.js

@@ -40,34 +40,62 @@ function asyncMap(dataOrF, ForOptions, options) {
     return asyncMap_(data, f, options);
   } else throw new Error("Invalid arguments passed to asyncMap");
 }
-async function asyncMap_(data, f, { concurrent = 5 } = {}) {
+async function asyncMap_(data, f, {
+  concurrent = 5,
+  failFast = false,
+  withSourceIndexes = false
+} = {}) {
   return new Promise((resolve, reject) => {
     const resolved = [];
-    const inFlight = [];
+    const errors = [];
+    const inFlight = /* @__PURE__ */ new Map();
     let next = 0;
+    let stop = false;
     function queue(i) {
-      if (resolved.length == data.length && inFlight.length == 0)
-        return finish();
-      if (i >= data.length) return;
-      const el = data[i];
-      inFlight.push([
+      if (!stop && i > 0 && inFlight.size == 0) return finish();
+      if (stop || i >= data.length) return;
+      inFlight.set(
         i,
-        f(el, i, data).then((result) => {
-          resolved.push([i, result]);
-          const j = inFlight.findIndex(([j2]) => i == j2);
-          inFlight.splice(j, 1);
+        f(data[i], i, data).then(
+          (result) => void resolved.push([i, result]),
+          (error) => {
+            if (!failFast) errors.push([i, error]);
+            else {
+              stop = true;
+              reject(error);
+            }
+          }
+        ).finally(() => {
+          inFlight.delete(i);
           queue(next);
-        }, reject)
-      ]);
+        })
+      );
       next++;
     }
     function finish() {
-      const sorted = resolved.sort(([a], [b]) => a - b);
-      resolve(sorted.map(([, value]) => value));
-    }
-    for (let i = 0; i < concurrent; i++) {
-      queue(next);
+      resolved.sort(([a], [b]) => a - b);
+      if (failFast) {
+        if (withSourceIndexes) resolve(resolved);
+        else resolve(resolved.map(([, value]) => value));
+      } else {
+        errors.sort(([a], [b]) => a - b);
+        if (withSourceIndexes)
+          resolve({
+            results: resolved,
+            errors
+          });
+        else
+          resolve({
+            results: resolved.map(([, value]) => value),
+            errors: errors.map(([, error]) => error)
+          });
+      }
     }
+    if (data.length == 0) finish();
+    else
+      for (let i = 0; i < concurrent; i++) {
+        queue(next);
+      }
   });
 }
 export {

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.4.1",
+	"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": "^2.8.8",
-		"tsup": "^8.1.0",
-		"typescript": "^5.0.2",
-		"vite": "^5.4.8",
-		"vitest": "^2.1.2"
+		"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",