@tim-code/my-util 0.5.14 → 0.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "description": "",
   "type": "module",
   "author": "Tim Sprowl",

package/src/promise.js

@@ -59,35 +59,36 @@ export async function sleep(ms) {
  * Parallelize executions of a function using `Promise.allSettled()`.
  * This is useful because usually you want to set a limit to the number of parallel requests possible at once.
  * The output of this function contains the outcome of each call of the callback in a variety of formats.
- *  - "results": Essentially the return value from Promise.allSettled().
+ *  - "results": An array with the same elements as returned by Promise.allSettled().
  *  - "values": The "value" property of each "result" object returned from allSettled(); this will be undefined if the associated promise rejects.
  *  - "returned": The "value" property for each "result" object where the "status" property has a value of fulfilled.
  *     This is arguably more useful than "values" unless you need to be able to index into the array based on the index of the promise.
  *  - "errors": The "reason" property for each "result" object that did not have a status of "fulfilled".
  * @param {Object} $1
- * @param {Array} $1.array
+ * @param {Iterable} $1.array
+ * @param {Iterable=} $1.iterable An alternative, more accurate property name for specifying "array"
  * @param {number=} $1.limit The number of calls to do in parallel. If not provided, each call is done in parallel.
  * @param {Function=} $1.limiter A function awaited after a group of parallel calls is processed.
  *  It is called with the number of parallel calls processed. Could be as simple as `() => sleep(10000)` if you wanted to wait 10 seconds between.
- * @param {boolean=} $1.flatten Flattens values before returning; useful if promises return arrays
+ * @param {boolean=} $1.flatten Flattens "values" and "returned" before returning; useful if promises return arrays
  * @param {boolean=} $1.abort If true, will return early if there are errors.
  *  If false (default), will process all elements in the array (like Promise.allSettled()).
  * @param {Function} callback Default is identity function to enable passing promises as "array".
  * @returns {Object} {results, values, returned, errors}
  */
 export async function allSettled(
-  { array, limit, limiter, flatten = false, abort = false },
+  { array, iterable = array, limit, limiter, flatten = false, abort = false },
   callback = (promise) => promise
 ) {
   const results = []
   let returned = []
   let values = []
   const errors = []
-  const chunked = chunk(array, limit)
+  const chunked = chunk(iterable, limit)
   for (const elements of chunked) {
     const promises = elements.map(callback)
-    const _results = await Promise.allSettled(promises)
-    for (const result of _results) {
+    const chunkResults = await Promise.allSettled(promises)
+    for (const result of chunkResults) {
       const { value, status, reason } = result
       results.push(result)
       values.push(value)

package/src/promise.test.js

@@ -1,6 +1,11 @@
 /* eslint-disable prefer-promise-reject-errors */
 import { jest } from "@jest/globals"
 
+// Exported API under test:
+// - class PollError
+// - functions: poll, sleep, allSettled, intervalLimiter, alert, throwFirstReject
+// Code changes in this diff affect: allSettled (added "iterable" param and generalized to Iterable)
+
 import {
   alert,
   allSettled,
@@ -214,6 +219,20 @@ describe("allSettled", () => {
     expect(cb).toHaveBeenCalledTimes(2)
     // Should not process [3,4] or [5,6]
   })
+
+  it("accepts non-Array iterable via iterable option (Map)", async () => {
+    const map = new Map([
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+    ])
+    const cb = ([k, v]) => `${k}:${v * 2}`
+    const result = await allSettled({ iterable: map, limit: 2 }, cb)
+    expect(result.values).toEqual(["a:2", "b:4", "c:6"])
+    expect(result.returned).toEqual(["a:2", "b:4", "c:6"])
+    expect(result.errors).toEqual([])
+    expect(result.results.every((r) => r.status === "fulfilled")).toBe(true)
+  })
 })
 
 describe("intervalLimiter", () => {