@oscarpalmer/atoms 0.80.0 → 0.81.0

package/dist/array/chunk.cjs

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const number = require("../number.cjs");
-function chunk(array, size) {
-  const chunkSize = number.clamp(size ?? 5e3, 1, 5e3);
+function chunk(array) {
   const { length } = array;
-  if (length <= chunkSize) {
+  if (length <= 5e3) {
     return [array];
   }
   const chunks = [];
-  let remaining = Number(length);
-  while (remaining > 0) {
-    chunks.push(array.splice(0, chunkSize));
-    remaining -= chunkSize;
+  let index = 0;
+  while (index < length) {
+    chunks.push(array.slice(index, index + 5e3));
+    index += 5e3;
   }
   return chunks;
 }

package/dist/array/chunk.js

@@ -1,15 +1,13 @@
-import { clamp } from "../number.js";
-function chunk(array, size) {
-  const chunkSize = clamp(size ?? 5e3, 1, 5e3);
+function chunk(array) {
   const { length } = array;
-  if (length <= chunkSize) {
+  if (length <= 5e3) {
     return [array];
   }
   const chunks = [];
-  let remaining = Number(length);
-  while (remaining > 0) {
-    chunks.push(array.splice(0, chunkSize));
-    remaining -= chunkSize;
+  let index = 0;
+  while (index < length) {
+    chunks.push(array.slice(index, index + 5e3));
+    index += 5e3;
   }
   return chunks;
 }

package/dist/array/compact.cjs

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function compact(array, strict) {
-  return strict === true ? array.filter((item) => !!item) : array.filter((item) => item != null);
+  const isStrict = strict ?? false;
+  const { length } = array;
+  const compacted = [];
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    if (isStrict && !!item || !isStrict && item != null) {
+      compacted.push(item);
+    }
+  }
+  return compacted;
 }
 exports.compact = compact;

package/dist/array/compact.js

@@ -1,5 +1,14 @@
 function compact(array, strict) {
-  return strict === true ? array.filter((item) => !!item) : array.filter((item) => item != null);
+  const isStrict = strict ?? false;
+  const { length } = array;
+  const compacted = [];
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    if (isStrict && !!item || !isStrict && item != null) {
+      compacted.push(item);
+    }
+  }
+  return compacted;
 }
 export {
   compact

package/dist/math.cjs

@@ -1,13 +1,33 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function average(values) {
-  return values.length > 0 ? sum(values) / values.length : Number.NaN;
+function average(array, key) {
+  return array.length === 0 ? Number.NaN : sum(array, key) / array.length;
 }
-function max(values) {
-  return values.length > 0 ? Math.max(...values) : Number.NaN;
+function max(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let max2;
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    const value = isCallback ? key(item, index, array) : item[key] ?? item;
+    if (max2 == null || value > max2) {
+      max2 = value;
+    }
+  }
+  return max2 ?? Number.NaN;
 }
-function min(values) {
-  return values.length > 0 ? Math.min(...values) : Number.NaN;
+function min(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let min2;
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    const value = isCallback ? key(item, index, array) : item[key] ?? item;
+    if (min2 == null || value < min2) {
+      min2 = value;
+    }
+  }
+  return min2 ?? Number.NaN;
 }
 function round(value, decimals) {
   if (typeof decimals !== "number" || decimals < 1) {
@@ -16,8 +36,15 @@ function round(value, decimals) {
   const mod = 10 ** decimals;
   return Math.round((value + Number.EPSILON) * mod) / mod;
 }
-function sum(values) {
-  return values.reduce((previous, current) => previous + current, 0);
+function sum(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let sum2 = 0;
+  for (let index = 0; index < length; index += 1) {
+    const value = array[index];
+    sum2 += isCallback ? key(value, index, array) : value[key] ?? value;
+  }
+  return sum2;
 }
 exports.average = average;
 exports.max = max;

package/dist/math.js

@@ -1,11 +1,31 @@
-function average(values) {
-  return values.length > 0 ? sum(values) / values.length : Number.NaN;
+function average(array, key) {
+  return array.length === 0 ? Number.NaN : sum(array, key) / array.length;
 }
-function max(values) {
-  return values.length > 0 ? Math.max(...values) : Number.NaN;
+function max(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let max2;
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    const value = isCallback ? key(item, index, array) : item[key] ?? item;
+    if (max2 == null || value > max2) {
+      max2 = value;
+    }
+  }
+  return max2 ?? Number.NaN;
 }
-function min(values) {
-  return values.length > 0 ? Math.min(...values) : Number.NaN;
+function min(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let min2;
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    const value = isCallback ? key(item, index, array) : item[key] ?? item;
+    if (min2 == null || value < min2) {
+      min2 = value;
+    }
+  }
+  return min2 ?? Number.NaN;
 }
 function round(value, decimals) {
   if (typeof decimals !== "number" || decimals < 1) {
@@ -14,8 +34,15 @@ function round(value, decimals) {
   const mod = 10 ** decimals;
   return Math.round((value + Number.EPSILON) * mod) / mod;
 }
-function sum(values) {
-  return values.reduce((previous, current) => previous + current, 0);
+function sum(array, key) {
+  const isCallback = typeof key === "function";
+  const { length } = array;
+  let sum2 = 0;
+  for (let index = 0; index < length; index += 1) {
+    const value = array[index];
+    sum2 += isCallback ? key(value, index, array) : value[key] ?? value;
+  }
+  return sum2;
 }
 export {
   average,

package/dist/value/diff.cjs

@@ -65,7 +65,10 @@ function getDiffs(first, second, prefix) {
         if (!nested || nested && diffs.length > 0) {
           changes.push(change);
         }
-        changes.push(...diffs);
+        const diffsLength = diffs.length;
+        for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
+          changes.push(diffs[diffIndex]);
+        }
       }
       checked.add(key);
     }

package/dist/value/diff.js

@@ -63,7 +63,10 @@ function getDiffs(first, second, prefix) {
         if (!nested || nested && diffs.length > 0) {
           changes.push(change);
         }
-        changes.push(...diffs);
+        const diffsLength = diffs.length;
+        for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
+          changes.push(diffs[diffIndex]);
+        }
       }
       checked.add(key);
     }

package/package.json

@@ -179,15 +179,8 @@
 			}
 		}
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
-	"keywords": [
-		"helper",
-		"utility"
-	],
+	"files": ["dist", "src", "types"],
+	"keywords": ["helper", "utility"],
 	"license": "MIT",
 	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
@@ -205,5 +198,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.80.0"
+	"version": "0.81.0"
 }

package/src/array/chunk.ts

@@ -1,24 +1,21 @@
-import {clamp} from '../number';
-
 /**
- * Chunk an array _(into smaller arrays of a specified size)_
+ * Chunk an array _(into smaller arrays)_
  */
-export function chunk<Item>(array: Item[], size?: number): Item[][] {
-	const chunkSize = clamp(size ?? 5_000, 1, 5_000);
+export function chunk<Item>(array: Item[]): Item[][] {
 	const {length} = array;
 
-	if (length <= chunkSize) {
+	if (length <= 5_000) {
 		return [array];
 	}
 
 	const chunks: Item[][] = [];
 
-	let remaining = Number(length);
+	let index = 0;
 
-	while (remaining > 0) {
-		chunks.push(array.splice(0, chunkSize));
+	while (index < length) {
+		chunks.push(array.slice(index, index + 5_000));
 
-		remaining -= chunkSize;
+		index += 5_000;
 	}
 
 	return chunks;

package/src/array/compact.ts

@@ -12,7 +12,17 @@ export function compact<Item>(
 ): Exclude<Item, 0 | '' | false | null | undefined>[];
 
 export function compact<Item>(array: Item[], strict?: boolean): Item[] {
-	return strict === true
-		? array.filter(item => !!item)
-		: array.filter(item => item != null);
+	const isStrict = strict ?? false;
+	const {length} = array;
+	const compacted: Item[] = [];
+
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+
+		if ((isStrict && !!item) || (!isStrict && item != null)) {
+			compacted.push(item);
+		}
+	}
+
+	return compacted;
 }

package/src/math.ts

@@ -1,22 +1,98 @@
+import type {GenericCallback, PlainObject} from './models';
+
+type OnlyNumericalKeys<Item> = {
+	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
+
 /**
  * Get the average value from a list of numbers
  */
-export function average(values: number[]): number {
-	return values.length > 0 ? sum(values) / values.length : Number.NaN;
+export function average(values: number[]): number;
+
+export function average<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+
+export function average<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
+
+export function average(array: unknown[], key?: unknown): number {
+	return array.length === 0
+		? Number.NaN
+		: sum(array as never[], key as never) / array.length;
 }
 
 /**
  * Get the maximum value from a list of numbers
  */
-export function max(values: number[]): number {
-	return values.length > 0 ? Math.max(...values) : Number.NaN;
+export function max(values: number[]): number;
+
+export function max<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+
+export function max<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
+
+export function max(array: unknown[], key?: unknown): number {
+	const isCallback = typeof key === 'function';
+	const {length} = array;
+	let max: number | undefined;
+
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+
+		const value = isCallback
+			? (key as GenericCallback)(item, index, array)
+			: ((item as PlainObject)[key as never] ?? item);
+
+		if (max == null || value > max) {
+			max = value;
+		}
+	}
+
+	return max ?? Number.NaN;
 }
 
 /**
  * Get the minimum value from a list of numbers
  */
-export function min(values: number[]): number {
-	return values.length > 0 ? Math.min(...values) : Number.NaN;
+export function min(values: number[]): number;
+
+export function min<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+
+export function min<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
+
+export function min(array: unknown[], key?: unknown): number {
+	const isCallback = typeof key === 'function';
+	const {length} = array;
+	let min: number | undefined;
+
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+
+		const value = isCallback
+			? (key as GenericCallback)(item, index, array)
+			: ((item as PlainObject)[key as never] ?? item);
+
+		if (min == null || value < min) {
+			min = value;
+		}
+	}
+
+	return min ?? Number.NaN;
 }
 
 /**
@@ -35,6 +111,30 @@ export function round(value: number, decimals?: number): number {
 /**
  * Get the sum of a list of numbers
  */
-export function sum(values: number[]): number {
-	return values.reduce((previous, current) => previous + current, 0);
+export function sum(values: number[]): number;
+
+export function sum<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+
+export function sum<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
+
+export function sum(array: unknown[], key?: unknown): number {
+	const isCallback = typeof key === 'function';
+	const {length} = array;
+	let sum = 0;
+
+	for (let index = 0; index < length; index += 1) {
+		const value = array[index];
+
+		sum += isCallback
+			? (key as GenericCallback)(value, index, array)
+			: ((value as PlainObject)[key as never] ?? value);
+	}
+
+	return sum;
 }

package/src/value/diff.ts

@@ -125,7 +125,11 @@ function getDiffs(
 					changes.push(change);
 				}
 
-				changes.push(...diffs);
+				const diffsLength = diffs.length;
+
+				for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
+					changes.push(diffs[diffIndex]);
+				}
 			}
 
 			checked.add(key);

package/types/array/chunk.d.cts

@@ -1,8 +1,8 @@
 // Generated by dts-bundle-generator v9.5.1
 
 /**
- * Chunk an array _(into smaller arrays of a specified size)_
+ * Chunk an array _(into smaller arrays)_
  */
-export declare function chunk<Item>(array: Item[], size?: number): Item[][];
+export declare function chunk<Item>(array: Item[]): Item[][];
 
 export {};

package/types/array/chunk.d.ts

@@ -1,4 +1,4 @@
 /**
- * Chunk an array _(into smaller arrays of a specified size)_
+ * Chunk an array _(into smaller arrays)_
  */
-export declare function chunk<Item>(array: Item[], size?: number): Item[][];
+export declare function chunk<Item>(array: Item[]): Item[][];

package/types/array/index.d.cts

@@ -96,9 +96,9 @@ export type NestedArrayType<Value> = Value extends Array<infer NestedValue> ? Ne
 export type Key = number | string;
 export type PlainObject = UnknownRecord;
 /**
- * Chunk an array _(into smaller arrays of a specified size)_
+ * Chunk an array _(into smaller arrays)_
  */
-export declare function chunk<Item>(array: Item[], size?: number): Item[][];
+export declare function chunk<Item>(array: Item[]): Item[][];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  */

package/types/index.d.cts

@@ -1574,18 +1574,45 @@ export declare function clamp(
  * - Based on Lodash :-)
  */
 export declare function getNumber(value: unknown): number;
+export type OnlyNumericalKeys<Item> = {
+	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
 /**
  * Get the average value from a list of numbers
  */
 export declare function average(values: number[]): number;
+export declare function average<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+export declare function average<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
 /**
  * Get the maximum value from a list of numbers
  */
 export declare function max(values: number[]): number;
+export declare function max<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+export declare function max<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
 /**
  * Get the minimum value from a list of numbers
  */
 export declare function min(values: number[]): number;
+export declare function min<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+export declare function min<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
 /**
  * Round a number to a specific number of decimal places _(defaults to 0)_
  */
@@ -1594,6 +1621,14 @@ export declare function round(value: number, decimals?: number): number;
  * Get the sum of a list of numbers
  */
 export declare function sum(values: number[]): number;
+export declare function sum<Item extends PlainObject>(
+	array: Item[],
+	key: keyof OnlyNumericalKeys<Item>,
+): number;
+export declare function sum<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => number,
+): number;
 declare class Logger {
 	/**
 	 * Log any number of values at the "debug" log level
@@ -1733,9 +1768,9 @@ export declare function isPlainObject(value: unknown): value is PlainObject;
  */
 export declare function isPrimitive(value: unknown): value is Primitive;
 /**
- * Chunk an array _(into smaller arrays of a specified size)_
+ * Chunk an array _(into smaller arrays)_
  */
-export declare function chunk<Item>(array: Item[], size?: number): Item[][];
+export declare function chunk<Item>(array: Item[]): Item[][];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  */

package/types/math.d.cts

@@ -1,17 +1,58 @@
 // Generated by dts-bundle-generator v9.5.1
 
+/**
+Represents an object with `unknown` value. You probably want this instead of `{}`.
+
+Use case: You have an object whose keys and values are unknown to you.
+
+@example
+```
+import type {UnknownRecord} from 'type-fest';
+
+function toJson(object: UnknownRecord) {
+	return JSON.stringify(object);
+}
+
+toJson({hello: 'world'});
+//=> '{"hello":"world"}'
+
+function isObject(value: unknown): value is UnknownRecord {
+	return typeof value === 'object' && value !== null;
+}
+
+isObject({hello: 'world'});
+//=> true
+
+isObject('hello');
+//=> false
+```
+
+@category Type
+@category Object
+*/
+export type UnknownRecord = Record<PropertyKey, unknown>;
+export type PlainObject = UnknownRecord;
+export type OnlyNumericalKeys<Item> = {
+	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
 /**
  * Get the average value from a list of numbers
  */
 export declare function average(values: number[]): number;
+export declare function average<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function average<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the maximum value from a list of numbers
  */
 export declare function max(values: number[]): number;
+export declare function max<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function max<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the minimum value from a list of numbers
  */
 export declare function min(values: number[]): number;
+export declare function min<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function min<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Round a number to a specific number of decimal places _(defaults to 0)_
  */
@@ -20,5 +61,7 @@ export declare function round(value: number, decimals?: number): number;
  * Get the sum of a list of numbers
  */
 export declare function sum(values: number[]): number;
+export declare function sum<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function sum<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 
 export {};

package/types/math.d.ts

@@ -1,15 +1,25 @@
+import type { PlainObject } from './models';
+type OnlyNumericalKeys<Item> = {
+    [Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+};
 /**
  * Get the average value from a list of numbers
  */
 export declare function average(values: number[]): number;
+export declare function average<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function average<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the maximum value from a list of numbers
  */
 export declare function max(values: number[]): number;
+export declare function max<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function max<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the minimum value from a list of numbers
  */
 export declare function min(values: number[]): number;
+export declare function min<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function min<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Round a number to a specific number of decimal places _(defaults to 0)_
  */
@@ -18,3 +28,6 @@ export declare function round(value: number, decimals?: number): number;
  * Get the sum of a list of numbers
  */
 export declare function sum(values: number[]): number;
+export declare function sum<Item extends PlainObject>(array: Item[], key: keyof OnlyNumericalKeys<Item>): number;
+export declare function sum<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+export {};