paralysis 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Gabriel de Oliveira <gabrielhk3@gmail.com> (https://nocnitsa.com)
+
+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

@@ -0,0 +1,21 @@
+# Paralysis
+
+Maps over promises concurrently.
+
+```js
+import parallel from "paralysis";
+
+async function getUser(id) {
+  const response = await fetch(
+    `https://jsonplaceholder.typicode.com/users/${id}`,
+  );
+  const user = await response.json();
+  return user;
+}
+
+const users = await parallel([1, 2, 3, 4, 5], getUser, 2);
+```
+
+This is similar to
+[`Promise.all()`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise/all),
+but accepts an optional concurrency limit.

package/dist/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var TinyQueue = require('tinyqueue');
+
+function createRun(concurrency) {
+  const queue = new TinyQueue();
+  let slots = Math.floor(concurrency);
+  function release() {
+    const next = queue.pop();
+    if (next) {
+      const [resolve, delayed] = next;
+      resolve(delayed);
+    } else {
+      slots++;
+    }
+  }
+  function runRecipe([fn, args]) {
+    return new Promise((resolve) => {
+      resolve(fn(...args));
+    }).finally(release);
+  }
+  return function run(recipe) {
+    if (slots > 0) {
+      slots--;
+      return runRecipe(recipe);
+    }
+    return new Promise((resolve) => {
+      queue.push([resolve, recipe]);
+    }).then(runRecipe);
+  };
+}
+function holdback(list, fn, concurrency = Infinity) {
+  if (!(typeof concurrency === "number" && concurrency >= 1)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const run = createRun(concurrency);
+  return Promise.all(Array.from(list, (...args) => run([fn, args])));
+}
+
+module.exports = holdback;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/holdback.js"],"sourcesContent":["import TinyQueue from \"tinyqueue\";\n\nfunction createRun(concurrency) {\n  const queue = new TinyQueue();\n  let slots = Math.floor(concurrency);\n\n  function release() {\n    // Check if we have more functions waiting in the queue. If we\n    // do, run the next delayed function. Otherwise, free a slot.\n    const next = queue.pop();\n    if (next) {\n      const [resolve, delayed] = next;\n      resolve(delayed);\n    } else {\n      slots++;\n    }\n  }\n\n  function runRecipe([fn, args]) {\n    return new Promise((resolve) => {\n      resolve(fn(...args));\n    }).finally(release);\n  }\n\n  return function run(recipe) {\n    // If we have an available slot, take the slot and return\n    // a promise that executes the function immediately.\n    if (slots > 0) {\n      slots--;\n      return runRecipe(recipe);\n    }\n\n    // If the limit of slots is reached, enqueue the function\n    // and return a promise that will be resolved only after\n    // the next slot is released and the function is executed.\n    return new Promise((resolve) => {\n      queue.push([resolve, recipe]);\n    }).then(runRecipe);\n  };\n}\n\nexport function holdback(list, fn, concurrency = Infinity) {\n  if (!(typeof concurrency === \"number\" && concurrency >= 1)) {\n    throw new TypeError(\"Expected `concurrency` to be a number from 1 and up\");\n  }\n  const run = createRun(concurrency);\n  return Promise.all(Array.from(list, (...args) => run([fn, args])));\n}\n"],"names":[],"mappings":";;;;AAEA,SAAS,UAAU,WAAA,EAAa;AAC9B,EAAA,MAAM,KAAA,GAAQ,IAAI,SAAA,EAAU;AAC5B,EAAA,IAAI,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,WAAW,CAAA;AAElC,EAAA,SAAS,OAAA,GAAU;AAGjB,IAAA,MAAM,IAAA,GAAO,MAAM,GAAA,EAAI;AACvB,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAA;AAC3B,MAAA,OAAA,CAAQ,OAAO,CAAA;AAAA,IACjB,CAAA,MAAO;AACL,MAAA,KAAA,EAAA;AAAA,IACF;AAAA,EACF;AAEA,EAAA,SAAS,SAAA,CAAU,CAAC,EAAA,EAAI,IAAI,CAAA,EAAG;AAC7B,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC9B,MAAA,OAAA,CAAQ,EAAA,CAAG,GAAG,IAAI,CAAC,CAAA;AAAA,IACrB,CAAC,CAAA,CAAE,OAAA,CAAQ,OAAO,CAAA;AAAA,EACpB;AAEA,EAAA,OAAO,SAAS,IAAI,MAAA,EAAQ;AAG1B,IAAA,IAAI,QAAQ,CAAA,EAAG;AACb,MAAA,KAAA,EAAA;AACA,MAAA,OAAO,UAAU,MAAM,CAAA;AAAA,IACzB;AAKA,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC9B,MAAA,KAAA,CAAM,IAAA,CAAK,CAAC,OAAA,EAAS,MAAM,CAAC,CAAA;AAAA,IAC9B,CAAC,CAAA,CAAE,IAAA,CAAK,SAAS,CAAA;AAAA,EACnB,CAAA;AACF;AAEO,SAAS,QAAA,CAAS,IAAA,EAAM,EAAA,EAAI,WAAA,GAAc,QAAA,EAAU;AACzD,EAAA,IAAI,EAAE,OAAO,WAAA,KAAgB,QAAA,IAAY,eAAe,CAAA,CAAA,EAAI;AAC1D,IAAA,MAAM,IAAI,UAAU,qDAAqD,CAAA;AAAA,EAC3E;AACA,EAAA,MAAM,GAAA,GAAM,UAAU,WAAW,CAAA;AACjC,EAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,KAAA,CAAM,IAAA,CAAK,IAAA,EAAM,CAAA,GAAI,IAAA,KAAS,GAAA,CAAI,CAAC,EAAA,EAAI,IAAI,CAAC,CAAC,CAAC,CAAA;AACnE;;;;"}

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+type Promisable<T> = T | PromiseLike<T>;
+
+/**
+ * Maps the async function `fn` over each element of
+ * `list`, limited by `concurrency` executions in parallel.
+ * Returns a promise that resolves with all the results.
+ *
+ * @example
+ * ```js
+ * import holdback from "holdback";
+ *
+ * async function getUser(id) {
+ *   const response = await fetch(
+ *     `https://jsonplaceholder.typicode.com/users/${id}`,
+ *   );
+ *   const user = await response.json();
+ *   return user;
+ * }
+ *
+ * const users = await holdback([1, 2, 3, 4, 5], getUser, 2);
+ * ```
+ *
+ * @param list List that is iterated over concurrently, calling `fn` for each item.
+ * @param fn Async function that is called for every item of `list`.
+ * @param concurrency Number of concurrently pending promises returned by `fn`.
+ * @returns A new promise.
+ */
+declare function holdback<T, U>(
+  list: ArrayLike<T>,
+  fn: (element: T, index: number) => Promisable<U>,
+  concurrency?: number,
+): Promise<Array<U>>;
+
+export { holdback as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../src/index.d.ts"],"mappings":"AAAA,KAAK,UAAU,UAAU,WAAW;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;iBACwB,QAAQ;AAChC,QAAQ,SAAS;AACjB,qCAAqC,UAAU;AAC/C;AACA,GAAG,OAAO,CAAC,KAAK;;;;","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+type Promisable<T> = T | PromiseLike<T>;
+
+/**
+ * Maps the async function `fn` over each element of
+ * `list`, limited by `concurrency` executions in parallel.
+ * Returns a promise that resolves with all the results.
+ *
+ * @example
+ * ```js
+ * import holdback from "holdback";
+ *
+ * async function getUser(id) {
+ *   const response = await fetch(
+ *     `https://jsonplaceholder.typicode.com/users/${id}`,
+ *   );
+ *   const user = await response.json();
+ *   return user;
+ * }
+ *
+ * const users = await holdback([1, 2, 3, 4, 5], getUser, 2);
+ * ```
+ *
+ * @param list List that is iterated over concurrently, calling `fn` for each item.
+ * @param fn Async function that is called for every item of `list`.
+ * @param concurrency Number of concurrently pending promises returned by `fn`.
+ * @returns A new promise.
+ */
+declare function holdback<T, U>(
+  list: ArrayLike<T>,
+  fn: (element: T, index: number) => Promisable<U>,
+  concurrency?: number,
+): Promise<Array<U>>;
+
+export { holdback as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sources":["../src/index.d.ts"],"mappings":"AAAA,KAAK,UAAU,UAAU,WAAW;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;iBACwB,QAAQ;AAChC,QAAQ,SAAS;AACjB,qCAAqC,UAAU;AAC/C;AACA,GAAG,OAAO,CAAC,KAAK;;;;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,39 @@
+import TinyQueue from 'tinyqueue';
+
+function createRun(concurrency) {
+  const queue = new TinyQueue();
+  let slots = Math.floor(concurrency);
+  function release() {
+    const next = queue.pop();
+    if (next) {
+      const [resolve, delayed] = next;
+      resolve(delayed);
+    } else {
+      slots++;
+    }
+  }
+  function runRecipe([fn, args]) {
+    return new Promise((resolve) => {
+      resolve(fn(...args));
+    }).finally(release);
+  }
+  return function run(recipe) {
+    if (slots > 0) {
+      slots--;
+      return runRecipe(recipe);
+    }
+    return new Promise((resolve) => {
+      queue.push([resolve, recipe]);
+    }).then(runRecipe);
+  };
+}
+function holdback(list, fn, concurrency = Infinity) {
+  if (!(typeof concurrency === "number" && concurrency >= 1)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const run = createRun(concurrency);
+  return Promise.all(Array.from(list, (...args) => run([fn, args])));
+}
+
+export { holdback as default };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/holdback.js"],"sourcesContent":["import TinyQueue from \"tinyqueue\";\n\nfunction createRun(concurrency) {\n  const queue = new TinyQueue();\n  let slots = Math.floor(concurrency);\n\n  function release() {\n    // Check if we have more functions waiting in the queue. If we\n    // do, run the next delayed function. Otherwise, free a slot.\n    const next = queue.pop();\n    if (next) {\n      const [resolve, delayed] = next;\n      resolve(delayed);\n    } else {\n      slots++;\n    }\n  }\n\n  function runRecipe([fn, args]) {\n    return new Promise((resolve) => {\n      resolve(fn(...args));\n    }).finally(release);\n  }\n\n  return function run(recipe) {\n    // If we have an available slot, take the slot and return\n    // a promise that executes the function immediately.\n    if (slots > 0) {\n      slots--;\n      return runRecipe(recipe);\n    }\n\n    // If the limit of slots is reached, enqueue the function\n    // and return a promise that will be resolved only after\n    // the next slot is released and the function is executed.\n    return new Promise((resolve) => {\n      queue.push([resolve, recipe]);\n    }).then(runRecipe);\n  };\n}\n\nexport function holdback(list, fn, concurrency = Infinity) {\n  if (!(typeof concurrency === \"number\" && concurrency >= 1)) {\n    throw new TypeError(\"Expected `concurrency` to be a number from 1 and up\");\n  }\n  const run = createRun(concurrency);\n  return Promise.all(Array.from(list, (...args) => run([fn, args])));\n}\n"],"names":[],"mappings":";;AAEA,SAAS,UAAU,WAAA,EAAa;AAC9B,EAAA,MAAM,KAAA,GAAQ,IAAI,SAAA,EAAU;AAC5B,EAAA,IAAI,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,WAAW,CAAA;AAElC,EAAA,SAAS,OAAA,GAAU;AAGjB,IAAA,MAAM,IAAA,GAAO,MAAM,GAAA,EAAI;AACvB,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAA;AAC3B,MAAA,OAAA,CAAQ,OAAO,CAAA;AAAA,IACjB,CAAA,MAAO;AACL,MAAA,KAAA,EAAA;AAAA,IACF;AAAA,EACF;AAEA,EAAA,SAAS,SAAA,CAAU,CAAC,EAAA,EAAI,IAAI,CAAA,EAAG;AAC7B,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC9B,MAAA,OAAA,CAAQ,EAAA,CAAG,GAAG,IAAI,CAAC,CAAA;AAAA,IACrB,CAAC,CAAA,CAAE,OAAA,CAAQ,OAAO,CAAA;AAAA,EACpB;AAEA,EAAA,OAAO,SAAS,IAAI,MAAA,EAAQ;AAG1B,IAAA,IAAI,QAAQ,CAAA,EAAG;AACb,MAAA,KAAA,EAAA;AACA,MAAA,OAAO,UAAU,MAAM,CAAA;AAAA,IACzB;AAKA,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC9B,MAAA,KAAA,CAAM,IAAA,CAAK,CAAC,OAAA,EAAS,MAAM,CAAC,CAAA;AAAA,IAC9B,CAAC,CAAA,CAAE,IAAA,CAAK,SAAS,CAAA;AAAA,EACnB,CAAA;AACF;AAEO,SAAS,QAAA,CAAS,IAAA,EAAM,EAAA,EAAI,WAAA,GAAc,QAAA,EAAU;AACzD,EAAA,IAAI,EAAE,OAAO,WAAA,KAAgB,QAAA,IAAY,eAAe,CAAA,CAAA,EAAI;AAC1D,IAAA,MAAM,IAAI,UAAU,qDAAqD,CAAA;AAAA,EAC3E;AACA,EAAA,MAAM,GAAA,GAAM,UAAU,WAAW,CAAA;AACjC,EAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,KAAA,CAAM,IAAA,CAAK,IAAA,EAAM,CAAA,GAAI,IAAA,KAAS,GAAA,CAAI,CAAC,EAAA,EAAI,IAAI,CAAC,CAAC,CAAC,CAAA;AACnE;;;;"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "paralysis",
+  "version": "1.0.0",
+  "description": "Map over promises concurrently",
+  "repository": "th3rius/paralysis",
+  "keywords": [
+    "async",
+    "concurrency",
+    "parallel",
+    "limit",
+    "queue",
+    "throttle",
+    "promise"
+  ],
+  "author": "Gabriel de Oliveira <gabrielhk3@gmail.com> (https://nocnitsa.com)",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "prepare": "husky",
+    "build": "rimraf dist && pkgroll --sourcemap",
+    "test": "node --test --experimental-test-module-mocks **/*.spec.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "dependencies": {
+    "tinyqueue": "^2.0.3"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^10.2.0",
+    "husky": "^9.1.7",
+    "pkgroll": "^2.21.5",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+import { paralysis } from "./paralysis.js";
+export default paralysis;

package/src/paralysis.js

@@ -0,0 +1,48 @@
+import TinyQueue from "tinyqueue";
+
+function createRun(concurrency) {
+  const queue = new TinyQueue();
+  let slots = Math.floor(concurrency);
+
+  function release() {
+    // Check if we have more functions waiting in the queue. If we
+    // do, run the next delayed function. Otherwise, free a slot.
+    const next = queue.pop();
+    if (next) {
+      const [resolve, delayed] = next;
+      resolve(delayed);
+    } else {
+      slots++;
+    }
+  }
+
+  function runRecipe([fn, args]) {
+    return new Promise((resolve) => {
+      resolve(fn(...args));
+    }).finally(release);
+  }
+
+  return function run(recipe) {
+    // If we have an available slot, take the slot and return
+    // a promise that executes the function immediately.
+    if (slots > 0) {
+      slots--;
+      return runRecipe(recipe);
+    }
+
+    // If the limit of slots is reached, enqueue the function
+    // and return a promise that will be resolved only after
+    // the next slot is released and the function is executed.
+    return new Promise((resolve) => {
+      queue.push([resolve, recipe]);
+    }).then(runRecipe);
+  };
+}
+
+export function paralysis(list, fn, concurrency = Infinity) {
+  if (!(typeof concurrency === "number" && concurrency >= 1)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const run = createRun(concurrency);
+  return Promise.all(Array.from(list, (...args) => run([fn, args])));
+}