@tim-code/my-util 0.5.12 → 0.5.14

package/package.json

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

package/src/array.js

@@ -1,22 +1,29 @@
 /**
- * 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.
+ *  This has the same effect as passing a chunk size that is greater than the number of elements in the 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 || !Number.isInteger(chunkSize))) {
+    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 current = []
+  for (const element of iterable) {
+    current.push(element)
+    if (current.length >= chunkSize) {
+      chunks.push(current)
+      current = []
+    }
   }
-  const chunked = []
-  for (let i = 0; i < array.length; i += chunkSize) {
-    chunked.push(array.slice(i, i + chunkSize))
+  if (current.length) {
+    chunks.push(current)
   }
-  return chunked
+  return chunks
 }
 
 /**
@@ -234,7 +241,7 @@ export function sortN(
   array,
   { N, compare = ascending(), unsorted = false, force = false, mutate = false }
 ) {
-  if (!(N >= 0) || N % 1 !== 0) {
+  if (!(N >= 0) || !Number.isInteger(N)) {
     throw new Error("N must be a nonnegative integer")
   }
   if (N === 0) {

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/math.js

@@ -166,7 +166,7 @@ export function isNumber(number) {
  * @returns {Object|undefined} Returns undefined is array is empty
  */
 export function quantiles(array, { N, key, method = Math.round }) {
-  if (!(N > 0) || N % 1 !== 0) {
+  if (!(N > 0) || !Number.isInteger(N)) {
     throw new Error("N must be a positive integer")
   }
   if (!array.length) {