Fix cluster's invalid argument could lead to bugs.

Author: fResult

src/array/cluster.ts

@@ -1,3 +1,5 @@
+import { IllegalSizeError } from 'radashi'
+
 /**
  * Splits a single list into many lists of the desired size.
  *
@@ -13,6 +15,14 @@ export function cluster<T, Size extends number = 2>(
   array: readonly T[],
   size: Size = 2 as Size,
 ): Cluster<T, Size>[] {
+  if (size <= 0 || Number.isNaN(size)) {
+    throw new IllegalSizeError(`Size must be 1 or more, the size is ${size}`)
+  }
+
+  if (size === Number.POSITIVE_INFINITY) {
+    throw new IllegalSizeError(`Size must not be Infinity, the size is ${size}`)
+  }
+
   const clusters: T[][] = []
   for (let i = 0; i < array.length; i += size) {
     clusters.push(array.slice(i, i + size))

src/errors.ts

@@ -0,0 +1,10 @@
+export class IllegalSizeError extends Error {
+  constructor(private _message = 'Size must not be less than 0') {
+    super(_message)
+    super.name = IllegalSizeError.name
+  }
+
+  get message(): string {
+    return this._message
+  }
+}

src/mod.ts

@@ -150,3 +150,4 @@ export * from './typed/isWeakMap.ts'
 export * from './typed/isWeakSet.ts'
 
 export * from './types.ts'
+export * from './errors.ts'

tests/array/cluster.test.ts

@@ -18,4 +18,60 @@ describe('cluster', () => {
     expect(c).toEqual([1, 1, 1])
     expect(d).toEqual([2, 2])
   })
+
+  test('handles empty array', () => {
+    const result = _.cluster([], 2);
+    expect(result).toEqual([]);
+  });
+
+  test('creates individual clusters when size is 1', () => {
+    const list = [1, 2, 3, 4];
+    const result = _.cluster(list, 1);
+    expect(result).toEqual([[1], [2], [3], [4]]);
+  });
+
+  test('creates a single cluster when size exceeds array length', () => {
+    const list = [1, 2, 3];
+    const result = _.cluster(list, 5);
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  test('throws error when size is 0', () => {
+    const list = [1, 2, 3];
+    const size = 0
+    expect(() => _.cluster(list, size)).toThrow(_.IllegalSizeError);
+    expect(() => _.cluster(list, size)).toThrow(`Size must be 1 or more, the size is ${size}`);
+  });
+
+  test('throws error when size is negative', () => {
+    const list = [1, 2, 3];
+    const size = -2
+    expect(() => _.cluster(list, size)).toThrow(_.IllegalSizeError);
+    expect(() => _.cluster(list, size)).toThrow(`Size must be 1 or more, the size is ${size}`);
+  });
+
+  test('uses default size of 2 when no size provided', () => {
+    const list = [1, 2, 3, 4, 5];
+    const actualResult = _.cluster(list);
+    expect(actualResult).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  // THINK FURTHER
+  test('throws error when size is NaN or Infinity', () => {
+    const list = [1, 2, 3];
+    expect(() => _.cluster(list, Number.NaN)).toThrow();
+    expect(() => _.cluster(list, Number.POSITIVE_INFINITY)).toThrow();
+  });
+
+  test('handles arrays with mixed data types', () => {
+    const list = [1, 'a', true, {}, null];
+    const actualResult = _.cluster(list, 2);
+    expect(actualResult).toEqual([[1, 'a'], [true, {}], [null]]);
+  });
+
+  test('handles very large size values', () => {
+    const list = [1, 2, 3];
+    const actualResult = _.cluster(list, Number.MAX_SAFE_INTEGER);
+    expect(actualResult).toEqual([[1, 2, 3]]);
+  });
 })