@tim-code/my-util 0.5.12 → 0.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.5.12",
+  "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", () => {