@tim-code/my-util 0.5.11 → 0.5.13

package/package.json

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

package/src/array.js

@@ -1,22 +1,28 @@
 /**
- * Converts an array into an array of arrays, where each subarray has a maximum size of chunkSize.
+ * Converts an iterable into an array of arrays, where each subarray has a maximum size of chunkSize.
  * Note the last subarray may have a length less than chunkSize.
- * @param {Array} array
- * @param {number=} chunkSize If not provided, defaults to the length of array, returning the input array as one chunk.
+ * If the iterable has no elements, returns an empty array since there are no chunks.
+ * @param {Iterable} iterable
+ * @param {number=} chunkSize If not provided, returns an array consisting of one chunk, which has all the elements of input iterable.
  * @returns {Array}
  */
-export function chunk(array, chunkSize = array.length) {
-  if (!array.length) {
-    return []
+export function chunk(iterable, chunkSize = Infinity) {
+  if (chunkSize !== Infinity && (chunkSize <= 0 || chunkSize % 1 !== 0)) {
+    throw new Error("chunkSize must be a positive integer or Infinity")
   }
-  if (chunkSize <= 0 || chunkSize % 1 !== 0) {
-    throw new Error("chunkSize must be a positive integer")
+  const chunks = []
+  let currentChunk = []
+  for (const element of iterable) {
+    currentChunk.push(element)
+    if (currentChunk.length >= chunkSize) {
+      chunks.push(currentChunk)
+      currentChunk = []
+    }
   }
-  const chunked = []
-  for (let i = 0; i < array.length; i += chunkSize) {
-    chunked.push(array.slice(i, i + chunkSize))
+  if (currentChunk.length) {
+    chunks.push(currentChunk)
   }
-  return chunked
+  return chunks
 }
 
 /**

package/src/array.test.js

@@ -22,14 +22,20 @@ describe("chunk", () => {
     expect(chunk([1, 2], 2)).toEqual([[1, 2]])
   })
 
-  it("returns the entire array as one chunk if chunkSize is omitted", () => {
+  it("returns the entire iterable as one chunk if chunkSize is omitted", () => {
     expect(chunk([1, 2, 3])).toEqual([[1, 2, 3]])
   })
 
-  it("throws if chunkSize is not a positive integer", () => {
-    expect(() => chunk([1, 2, 3], 0)).toThrow("chunkSize must be a positive integer")
-    expect(() => chunk([1, 2, 3], -1)).toThrow("chunkSize must be a positive integer")
-    expect(() => chunk([1, 2, 3], 1.5)).toThrow("chunkSize must be a positive integer")
+  it("throws if chunkSize is not a positive integer or Infinity", () => {
+    expect(() => chunk([1, 2, 3], 0)).toThrow(
+      /chunkSize must be a positive integer or Infinity/u
+    )
+    expect(() => chunk([1, 2, 3], -1)).toThrow(
+      /chunkSize must be a positive integer or Infinity/u
+    )
+    expect(() => chunk([1, 2, 3], 1.5)).toThrow(
+      /chunkSize must be a positive integer or Infinity/u
+    )
   })
 
   it("handles chunkSize of 1 (each element in its own chunk)", () => {
@@ -43,6 +49,40 @@ describe("chunk", () => {
   it("returns one chunk if chunkSize is much larger than array length", () => {
     expect(chunk([1, 2, 3], 100)).toEqual([[1, 2, 3]])
   })
+
+  it("works with Map iterables and chunks entries", () => {
+    const m = new Map([
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+      ["d", 4],
+      ["e", 5],
+    ])
+    expect(chunk(m, 2)).toEqual([
+      [
+        ["a", 1],
+        ["b", 2],
+      ],
+      [
+        ["c", 3],
+        ["d", 4],
+      ],
+      [["e", 5]],
+    ])
+  })
+
+  it("works with non-array iterables when chunkSize is omitted (single chunk of entries)", () => {
+    const m = new Map([
+      ["a", 1],
+      ["b", 2],
+    ])
+    expect(chunk(m)).toEqual([
+      [
+        ["a", 1],
+        ["b", 2],
+      ],
+    ])
+  })
 })
 
 describe("unique", () => {

package/src/promise.js

@@ -72,12 +72,12 @@ export async function sleep(ms) {
  * @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
+ * @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 },
-  callback
+  callback = (promise) => promise
 ) {
   const results = []
   let returned = []

package/src/promise.test.js

@@ -132,6 +132,15 @@ describe("allSettled", () => {
     expect(result.results.every((r) => r.status === "fulfilled")).toBe(true)
   })
 
+  it("returns correct structure for all fulfilled", async () => {
+    const arr = [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)]
+    const result = await allSettled({ array: arr })
+    expect(result.values).toEqual([1, 2, 3])
+    expect(result.returned).toEqual([1, 2, 3])
+    expect(result.errors).toEqual([])
+    expect(result.results.every((r) => r.status === "fulfilled")).toBe(true)
+  })
+
   it("handles rejected promises and collects errors", async () => {
     const arr = [1, 2, 3]
     const cb = (x) => (x === 2 ? Promise.reject("fail") : x + 1)