@terrygonguet/utils 0.0.13 → 0.1.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 Terry Gonguet
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 Terry Gonguet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,2 +1,2 @@
-# utils
-Okay fine I'll make my own
+# utils
+Okay fine I'll make my own

package/dist/async.d.ts

@@ -0,0 +1,15 @@
+declare function pause(ms: number): Promise<void>;
+interface RetryOptions {
+    count?: number;
+    delay?: number | ((retryCount: number, error: any) => number);
+}
+declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
+declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
+interface AsyncMapOptions {
+    concurrent?: number;
+}
+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>;
+
+export { asyncMap, pause, retry };

package/dist/async.js

@@ -1,65 +1,77 @@
-import { findIndex as g } from "./functional.js";
-function h(n) {
-  return new Promise((t) => setTimeout(t, n));
+// src/async.ts
+function pause(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function x(n, t) {
-  return typeof n == "function" ? p(n, t) : (r) => p(r, n);
+function retry(providerOrOptions, options) {
+  if (typeof providerOrOptions == "function")
+    return _retry(providerOrOptions, options);
+  else
+    return (provider) => _retry(provider, providerOrOptions);
 }
-async function p(n, { count: t = 1 / 0, delay: r } = {}) {
-  let o = 0, s;
-  do
+async function _retry(provider, { count = Infinity, delay } = {}) {
+  let retryCount = 0;
+  let lastError;
+  do {
     try {
-      return await n();
-    } catch (c) {
-      switch (s = c, o++, typeof r) {
+      return await provider();
+    } catch (error) {
+      lastError = error;
+      retryCount++;
+      switch (typeof delay) {
         case "number":
-          await h(r);
+          await pause(delay);
           break;
         case "function":
-          await h(r(o, c));
+          await pause(delay(retryCount, error));
           break;
       }
     }
-  while (o <= t);
-  throw s;
+  } while (retryCount <= count);
+  throw lastError;
 }
-function I(n, t, r) {
-  if (typeof n == "function" && typeof t != "function") {
-    const o = n, s = t;
-    return (c) => w(c, o, s);
-  } else {
-    if (Array.isArray(n) && typeof t == "function")
-      return w(n, t, r);
-    throw new Error("Invalid arguments passed to asyncMap");
-  }
+function asyncMap(dataOrF, ForOptions, options) {
+  if (typeof dataOrF == "function" && typeof ForOptions != "function") {
+    const f = dataOrF;
+    const options2 = ForOptions;
+    return (data) => asyncMap_(data, f, options2);
+  } else if (Array.isArray(dataOrF) && typeof ForOptions == "function") {
+    const data = dataOrF;
+    const f = ForOptions;
+    return asyncMap_(data, f, options);
+  } else throw new Error("Invalid arguments passed to asyncMap");
 }
-async function w(n, t, { concurrent: r = 5 } = {}) {
-  return new Promise((o, s) => {
-    const c = [], u = [];
-    let i = 0;
-    function y(e) {
-      if (c.length == n.length && u.length == 0)
-        return m();
-      if (e >= n.length)
-        return;
-      const f = n[e];
-      u.push([
-        e,
-        t(f, e, n).then((a) => {
-          c.push([e, a]), g(u, ([l]) => e == l).map((l) => u.splice(l, 1)), y(i);
-        }, s)
-      ]), i++;
+async function asyncMap_(data, f, { concurrent = 5 } = {}) {
+  return new Promise((resolve, reject) => {
+    const resolved = [];
+    const inFlight = [];
+    let next = 0;
+    function queue(i) {
+      if (resolved.length == data.length && inFlight.length == 0)
+        return finish();
+      if (i >= data.length) return;
+      const el = data[i];
+      inFlight.push([
+        i,
+        f(el, i, data).then((result) => {
+          resolved.push([i, result]);
+          const j = inFlight.findIndex(([j2]) => i == j2);
+          inFlight.splice(j, 1);
+          queue(next);
+        }, reject)
+      ]);
+      next++;
     }
-    function m() {
-      const e = c.sort(([f], [a]) => f - a);
-      o(e.map(([, f]) => f));
+    function finish() {
+      const sorted = resolved.sort(([a], [b]) => a - b);
+      resolve(sorted.map(([, value]) => value));
+    }
+    for (let i = 0; i < concurrent; i++) {
+      queue(next);
     }
-    for (let e = 0; e < r; e++)
-      y(i);
   });
 }
 export {
-  I as asyncMap,
-  h as pause,
-  x as retry
+  asyncMap,
+  pause,
+  retry
 };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Behaviour is undefined when max < min
+ */
+declare function clamp(value: number, min: number, max: number): number;
+type JSONReviver = (key: string, value: any) => any;
+/**
+ * This function does no runtime type checking,
+ * make sure that the parsed value is valid
+ */
+declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): T;
+declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
+declare function createNoopProxy<T>(): T;
+declare function noop(): void;
+declare function exhaustive(_: never): never;
+declare function hash(message: string): Promise<ArrayBuffer>;
+declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
+
+export { clamp, composeJSONRevivers, createNoopProxy, exhaustive, hash, noop, range, safeParse };

package/dist/index.js

@@ -1,55 +1,62 @@
-import { constant as r } from "./functional.js";
-function s(n, t, e) {
-  return Math.min(Math.max(n, t), e);
+// src/index.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
 }
-function a(n, t, e) {
+function safeParse(str, defaultValue, reviver) {
   try {
-    return JSON.parse(n, e);
-  } catch {
-    return t;
+    return JSON.parse(str, reviver);
+  } catch (_) {
+    return defaultValue;
   }
 }
-function i(...n) {
-  return function(t, e) {
-    for (const o of n)
-      e = o(t, e);
-    return e;
+function composeJSONRevivers(...revivers) {
+  return function(key, value) {
+    for (const reviver of revivers) {
+      value = reviver(key, value);
+    }
+    return value;
   };
 }
-function u() {
-  const n = () => o, t = r(!1), e = r(!0), o = new Proxy(() => {
+function createNoopProxy() {
+  const noop2 = () => proxy;
+  const no = () => false;
+  const yes = () => true;
+  const proxy = new Proxy(() => {
   }, {
-    get: n,
-    set: n,
-    apply: n,
-    construct: n,
-    deleteProperty: e,
-    has: e,
-    preventExtensions: t,
-    defineProperty: t
+    get: noop2,
+    set: noop2,
+    apply: noop2,
+    construct: noop2,
+    deleteProperty: yes,
+    has: yes,
+    preventExtensions: no,
+    defineProperty: no
   });
-  return o;
+  return proxy;
 }
-function f() {
+function noop() {
 }
-function p(n) {
+function exhaustive(_) {
   throw new Error("This should never be called");
 }
-async function h(n) {
-  const e = new TextEncoder().encode(n);
-  return await crypto.subtle.digest("SHA-1", e);
+async function hash(message) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  const hash2 = await crypto.subtle.digest("SHA-1", data);
+  return hash2;
 }
-function* d(n, t, e = 1) {
-  for (let o = n; o < t; o += e)
-    yield o;
+function* range(start, end, step = 1) {
+  for (let i = start; i < end; i += step) {
+    yield i;
+  }
 }
 export {
-  s as clamp,
-  i as composeJSONRevivers,
-  u as createNoopProxy,
-  p as exhaustive,
-  h as hash,
-  f as noop,
-  d as range,
-  a as safeParse
+  clamp,
+  composeJSONRevivers,
+  createNoopProxy,
+  exhaustive,
+  hash,
+  noop,
+  range,
+  safeParse
 };

package/package.json

@@ -1,63 +1,45 @@
-{
-	"name": "@terrygonguet/utils",
-	"version": "0.0.13",
-	"type": "module",
-	"module": "./dist/index.js",
-	"author": {
-		"email": "terry@gonguet.com",
-		"name": "Terry Gonguet",
-		"url": "https://terry.gonguet.com/"
-	},
-	"scripts": {
-		"dev": "vite",
-		"build": "tsc && vite build",
-		"test": "vitest test --ui --watch --update",
-		"coverage": "vitest run --coverage"
-	},
-	"devDependencies": {
-		"@vitest/coverage-v8": "^0.32.0",
-		"@vitest/ui": "^0.32.0",
-		"prettier": "^2.8.8",
-		"typescript": "^5.0.2",
-		"vite": "^4.3.9",
-		"vitest": "^0.32.0"
-	},
-	"files": [
-		"dist/**/*.js",
-		"src/**/!(*.test).ts",
-		"types/**/!(*.test).d.ts"
-	],
-	"exports": {
-		".": {
-			"import": "./dist/index.js"
-		},
-		"./async": {
-			"import": "./dist/async.js"
-		},
-		"./functional": {
-			"import": "./dist/functional.js"
-		}
-	},
-	"typesVersions": {
-		"*": {
-			"async": [
-				"./types/async.d.ts"
-			],
-			"functional": [
-				"./types/functional/index.d.ts"
-			]
-		}
-	},
-	"types": "./types/index.d.ts",
-	"dependencies": {
-		"just-compose": "^2.3.0",
-		"just-pipe": "^1.0.0"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/terrygonguet/utils.git"
-	},
-	"bugs": {
-		"url": "https://github.com/terrygonguet/utils/issues"
-	}
-}
+{
+	"name": "@terrygonguet/utils",
+	"version": "0.1.0",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsup",
+		"test": "vitest test --update",
+		"coverage": "vitest run --coverage"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./async": {
+			"types": "./dist/async.d.ts",
+			"import": "./dist/async.js"
+		}
+	},
+	"devDependencies": {
+		"@vitest/coverage-v8": "^0.32.0",
+		"@vitest/ui": "^0.32.0",
+		"prettier": "^2.8.8",
+		"tsup": "^8.1.0",
+		"typescript": "^5.0.2",
+		"vite": "^4.3.9",
+		"vitest": "^0.32.0"
+	},
+	"author": {
+		"email": "terry@gonguet.com",
+		"name": "Terry Gonguet",
+		"url": "https://terry.gonguet.com/"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/terrygonguet/utils.git"
+	},
+	"bugs": {
+		"url": "https://github.com/terrygonguet/utils/issues"
+	}
+}