@tim-code/my-util 0.4.0 → 0.4.1

package/package.json

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

package/src/find.js

@@ -153,6 +153,7 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
 
 /**
  * Find the closest element in an array. If there is a tie, then returns the first matching element by order in the array.
+ * If some values are undefined or null, they will be ignored. If no element is found, returns undefined.
  * If using for strings, need to specify different values for "cutoff" and "comparator".
  * "~" and "" are good cutoff string values for gt/gte and lt/lte respectively.
  * @template T, V

package/src/promise.js

@@ -70,10 +70,15 @@ export async function sleep(ms) {
  * @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.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
  * @returns {Object} {results, values, returned, errors}
  */
-export async function allSettled({ array, limit, limiter, flatten = false }, callback) {
+export async function allSettled(
+  { array, limit, limiter, flatten = false, abort = false },
+  callback
+) {
   const results = []
   let returned = []
   let values = []
@@ -92,6 +97,9 @@ export async function allSettled({ array, limit, limiter, flatten = false }, cal
         errors.push(reason)
       }
     }
+    if (abort && errors.length) {
+      break
+    }
     await limiter?.(elements.length)
   }
   if (flatten) {

package/src/promise.test.js

@@ -2,7 +2,15 @@
 /* eslint-disable prefer-promise-reject-errors */
 import { jest } from "@jest/globals"
 
-import { alert, allSettled, poll, PollError, sleep, throwFirstReject, intervalLimiter } from "./promise.js"
+import {
+  alert,
+  allSettled,
+  intervalLimiter,
+  poll,
+  PollError,
+  sleep,
+  throwFirstReject,
+} from "./promise.js"
 
 describe("poll", () => {
   it("resolves immediately if callback returns a non-undefined/null/false value", async () => {
@@ -182,6 +190,22 @@ describe("allSettled", () => {
     expect(limiter).toHaveBeenCalledTimes(3)
     expect(limiterCalls).toEqual([2, 2, 1])
   })
+
+  it("returns early if abort=true and any error occurs", async () => {
+    // Should process only up to the first chunk with a rejection, then stop
+    const arr = [1, 2, 3, 4, 5, 6]
+    const cb = jest
+      .fn()
+      .mockImplementation((x) => (x === 2 || x === 4 ? Promise.reject(`fail${x}`) : x))
+    // limit=2 so chunks: [1,2], [3,4], [5,6]
+    const result = await allSettled({ array: arr, limit: 2, abort: true }, cb)
+    // The first chunk: [1,2] => 1 fulfilled, 1 rejected
+    // Should stop after first chunk with error
+    expect(result.values.length).toBe(2)
+    expect(result.errors).toEqual(["fail2"])
+    expect(cb).toHaveBeenCalledTimes(2)
+    // Should not process [3,4] or [5,6]
+  })
 })
 
 describe("intervalLimiter", () => {