@terrygonguet/utils 0.4.0 → 0.5.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/random.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generates a random integer between `0` (inclusive) and `max` (exlusive)
+ */
+declare function randi(max: number): number;
+/**
+ * Generates a random integer between `min` (inclusive) and `max` (exlusive)
+ */
+declare function randi(min: number, max: number): number;
+/**
+ * Generates a random real between `0` (inclusive) and `max` (exlusive)
+ */
+declare function randf(max: number): number;
+/**
+ * Generates a random real between `min` (inclusive) and `max` (exlusive)
+ */
+declare function randf(min: number, max: number): number;
+declare const shuffle: <T>(arr: T[]) => T[];
+declare function make_randi(prng: typeof Math.random): typeof randi;
+declare function make_randf(prng: typeof Math.random): (minOrMax: number, max?: number) => number;
+declare function make_shuffle(prng: typeof Math.random): <T>(arr: T[]) => T[];
+declare function seeded(seed: string | number): typeof Math.random;
+
+export { make_randf, make_randi, make_shuffle, randf, randi, seeded, shuffle };

package/dist/random.js

@@ -0,0 +1,86 @@
+// src/random.ts
+var base_randi = make_randi(Math.random);
+function randi(minOrMax, max) {
+  if (typeof max == "number") return base_randi(minOrMax, max);
+  else return base_randi(minOrMax);
+}
+var base_randf = make_randf(Math.random);
+function randf(minOrMax, max) {
+  if (typeof max == "number") return base_randf(minOrMax, max);
+  else return base_randf(minOrMax);
+}
+var shuffle = make_shuffle(Math.random);
+function make_randi(prng) {
+  return function randi2(minOrMax, max) {
+    if (typeof max == "number") {
+      const min = minOrMax;
+      const delta = max - min;
+      return min + Math.floor(prng() * delta);
+    } else return Math.floor(prng() * minOrMax);
+  };
+}
+function make_randf(prng) {
+  return function randf2(minOrMax, max) {
+    if (typeof max == "number") {
+      const min = minOrMax;
+      const delta = max - min;
+      return min + prng() * delta;
+    } else return prng() * minOrMax;
+  };
+}
+function make_shuffle(prng) {
+  const randi2 = make_randi(prng);
+  return function shuffle2(arr) {
+    const clone = Array.from(arr);
+    for (let i = 0; i < clone.length - 2; i++) {
+      const j = randi2(i, clone.length);
+      const temp = clone[i];
+      clone[i] = clone[j];
+      clone[j] = temp;
+    }
+    return clone;
+  };
+}
+function seeded(seed) {
+  if (typeof seed == "string") seed = cyrb128(seed);
+  else seed ^= 3735928559;
+  const prng = splitmix32(seed);
+  for (let i = 0; i < 15; i++) prng();
+  return prng;
+}
+function cyrb128(str) {
+  let h1 = 1779033703, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
+  for (let i = 0, k; i < str.length; i++) {
+    k = str.charCodeAt(i);
+    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+  }
+  h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
+  h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
+  h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
+  h4 = Math.imul(h2 ^ h4 >>> 19, 2716044179);
+  h1 ^= h2 ^ h3 ^ h4;
+  return h1 >>> 0;
+}
+function splitmix32(a) {
+  return function() {
+    a |= 0;
+    a = a + 2654435769 | 0;
+    let t = a ^ a >>> 16;
+    t = Math.imul(t, 569420461);
+    t = t ^ t >>> 15;
+    t = Math.imul(t, 1935289751);
+    return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
+  };
+}
+export {
+  make_randf,
+  make_randi,
+  make_shuffle,
+  randf,
+  randi,
+  seeded,
+  shuffle
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"type": "module",
 	"license": "MIT",
 	"scripts": {
@@ -24,17 +24,21 @@
 			"types": "./dist/json.d.ts",
 			"import": "./dist/json.js"
 		},
+		"./random": {
+			"types": "./dist/random.d.ts",
+			"import": "./dist/random.js"
+		},
 		"./tableau": {
 			"types": "./dist/tableau.d.ts",
 			"import": "./dist/tableau.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.2",
+		"tsup": "^8.3.6",
+		"typescript": "^5.7.3",
+		"vite": "^6.1.1",
+		"vitest": "^3.0.6"
 	},
 	"author": {
 		"email": "terry@gonguet.com",