@stacksjs/arrays 0.53.1 → 0.56.23

package/dist/index.d.ts

@@ -1,80 +1,83 @@
-import type { Arrayable, Nullable } from '@stacksjs/types';
-export declare function contains(needle: string, haystack: string[]): boolean;
-export declare function containsAll(needles: string[], haystack: string[]): boolean;
-export declare function containsAny(needles: string[], haystack: string[]): boolean;
-export declare function containsNone(needles: string[], haystack: string[]): boolean;
-export declare function containsOnly(needles: string[], haystack: string[]): boolean;
-export declare function doesNotContain(needle: string, haystack: string[]): boolean;
+import { Nullable, Arrayable } from '@stacksjs/types';
+import { Macroable } from 'macroable';
+
+declare function average(arr: number[]): number;
+declare function avg(arr: number[]): number;
+declare function median(arr: number[]): number;
+declare function mode(arr: number[]): number;
+declare function sum(array: readonly number[]): number;
+
 /**
  * Convert `Arrayable<T>` to `Array<T>`
  *
  * @category Array
  */
-export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
+declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 /**
  * Convert `Arrayable<T>` to `Array<T>` and flatten it
  *
  * @category Array
  */
-export declare function flattenArrayable<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
+declare function flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
 /**
  * Use rest arguments to merge arrays
  *
  * @category Array
  */
-export declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
-export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any;
+declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
+type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any;
 /**
  * Divide an array into two parts by a filter function
  *
  * @category Array
  * @example const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)
  */
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]];
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]];
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>): [T[], T[], T[], T[]];
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
-export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>, f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>): [T[], T[], T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
+declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>, f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
 /**
  * Unique an Array
  *
  * @category Array
  */
-export declare function uniq<T>(array: readonly T[]): T[];
+declare function uniq<T>(array: readonly T[]): T[];
+declare function unique<T>(array: readonly T[]): T[];
 /**
  * Unique an Array by a custom equality function
  *
  * @category Array
  */
-export declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
+declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
 /**
  * Get last item
  *
  * @category Array
  */
-export declare function last(array: readonly []): undefined;
-export declare function last<T>(array: readonly T[]): T;
+declare function last(array: readonly []): undefined;
+declare function last<T>(array: readonly T[]): T;
 /**
  * Remove an item from Array
  *
  * @category Array
  */
-export declare function remove<T>(array: T[], value: T): boolean;
+declare function remove<T>(array: T[], value: T): boolean;
 /**
  * Get nth item of Array. Negative for backward
  *
  * @category Array
  */
-export declare function at(array: readonly [], index: number): undefined;
-export declare function at<T>(array: readonly T[], index: number): T;
+declare function at(array: readonly [], index: number): undefined;
+declare function at<T>(array: readonly T[], index: number): T;
 /**
  * Generate a range array of numbers. The `stop` is exclusive.
  *
  * @category Array
  */
-export declare function range(stop: number): number[];
-export declare function range(start: number, stop: number, step?: number): number[];
+declare function range(stop: number): number[];
+declare function range(start: number, stop: number, step?: number): number[];
 /**
  * Move element in an Array
  *
@@ -83,22 +86,81 @@ export declare function range(start: number, stop: number, step?: number): numbe
  * @param from
  * @param to
  */
-export declare function move<T>(arr: T[], from: number, to: number): T[];
+declare function move<T>(arr: T[], from: number, to: number): T[];
 /**
  * Clamp a number to the index range of an array.
  *
  * @category Array
  */
-export declare function clampArrayRange(n: number, arr: readonly unknown[]): any;
+declare function clampArrayRange(arr: readonly unknown[], n: number): number;
 /**
  * Get random items from an array
  *
  * @category Array
  */
-export declare function sample<T>(arr: T[], count: number): T[];
+declare function sample<T>(arr: T[], count: number): T[];
 /**
  * Shuffle an array. This function mutates the array.
  *
  * @category Array
  */
-export declare function shuffle<T>(array: T[]): T[];
+declare function shuffle<T>(array: T[]): T[];
+
+declare function contains(needle: string, haystack: string[]): boolean;
+declare function containsAll(needles: string[], haystack: string[]): boolean;
+declare function containsAny(needles: string[], haystack: string[]): boolean;
+declare function containsNone(needles: string[], haystack: string[]): boolean;
+declare function containsOnly(needles: string[], haystack: string[]): boolean;
+declare function doesNotContain(needle: string, haystack: string[]): boolean;
+
+declare class Arr extends Macroable {
+    contains(needle: string, haystack: string[]): boolean;
+    containsAll(needles: string[], haystack: string[]): boolean;
+    containsAny(needles: string[], haystack: string[]): boolean;
+    containsNone(needles: string[], haystack: string[]): boolean;
+    containsOnly(needles: string[], haystack: string[]): boolean;
+    doesNotContain(needle: string, haystack: string[]): boolean;
+    toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
+    flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
+    mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
+    partition<T>(array: readonly T[], filter: PartitionFilter<T>): [T[], T[]];
+    /**
+     * Returns a random item/s from the array
+     */
+    random<T>(arr: T[], count?: number): T[];
+    /**
+     * Returns random item/s from the array
+     */
+    sample<T>(arr: T[], count?: number): T[];
+    unique<T>(arr: T[]): T[];
+    uniqueBy<T>(arr: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
+    last<T>(arr: T[]): T | undefined;
+    remove<T>(arr: T[], value: T): boolean;
+    at(arr: any[], index: number): any;
+    range(start: number, end: number, step?: number): number[];
+    move<T>(arr: T[], from: number, to: number): T[];
+    clampArrayRange(arr: readonly unknown[], n: number): number;
+    shuffle<T>(arr: T[]): T[];
+    /**
+     * Returns the sum of all items in the array
+     */
+    sum(arr: number[]): number;
+    /**
+     * Returns the average of all items in the array
+     */
+    average(arr: number[]): number;
+    avg(arr: number[]): number;
+    /**
+     * Returns the median of all items in the array
+     */
+    median(arr: number[]): number;
+    /**
+     * Returns the mode of all items in the array
+     */
+    mode(arr: number[]): number;
+    static macros: {};
+    static getters: {};
+}
+declare const arr: Arr;
+
+export { Arr, PartitionFilter, arr, at, average, avg, clampArrayRange, contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain, flatten, last, median, mergeArrayable, mode, move, partition, range, remove, sample, shuffle, sum, toArray, uniq, unique, uniqueBy };

package/dist/index.mjs

@@ -1,33 +1,33 @@
-import { clamp } from "@stacksjs/utils";
-export function contains(needle, haystack) {
-  return haystack.some((hay) => needle.includes(hay));
-}
-export function containsAll(needles, haystack) {
-  return needles.every((needle) => contains(needle, haystack));
+import { clamp } from '@stacksjs/utils';
+import { Macroable } from 'macroable';
+
+function average(arr) {
+  return sum(arr) / arr.length;
 }
-export function containsAny(needles, haystack) {
-  return needles.some((needle) => contains(needle, haystack));
+function avg(arr) {
+  return average(arr);
 }
-export function containsNone(needles, haystack) {
-  return !containsAny(needles, haystack);
+function median(arr) {
+  return arr[Math.floor(arr.length / 2)];
 }
-export function containsOnly(needles, haystack) {
-  return containsAll(haystack, needles);
+function mode(arr) {
+  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
 }
-export function doesNotContain(needle, haystack) {
-  return !contains(needle, haystack);
+function sum(array) {
+  return array.reduce((acc, cur) => acc + cur, 0);
 }
-export function toArray(array) {
+
+function toArray(array) {
   array = array ?? [];
   return Array.isArray(array) ? array : [array];
 }
-export function flattenArrayable(array) {
+function flatten(array) {
   return toArray(array).flat(1);
 }
-export function mergeArrayable(...args) {
+function mergeArrayable(...args) {
   return args.flatMap((i) => toArray(i));
 }
-export function partition(array, ...filters) {
+function partition(array, ...filters) {
   const result = new Array(filters.length + 1).fill(null).map(() => []);
   array.forEach((e, idx, arr) => {
     let i = 0;
@@ -42,10 +42,13 @@ export function partition(array, ...filters) {
   });
   return result;
 }
-export function uniq(array) {
+function uniq(array) {
   return Array.from(new Set(array));
 }
-export function uniqueBy(array, equalFn) {
+function unique(array) {
+  return uniq(array);
+}
+function uniqueBy(array, equalFn) {
   return array.reduce((acc, cur) => {
     const index = acc.findIndex((item) => equalFn(cur, item));
     if (index === -1)
@@ -53,10 +56,10 @@ export function uniqueBy(array, equalFn) {
     return acc;
   }, []);
 }
-export function last(array) {
+function last(array) {
   return at(array, -1);
 }
-export function remove(array, value) {
+function remove(array, value) {
   if (!array)
     return false;
   const index = array.indexOf(value);
@@ -66,7 +69,7 @@ export function remove(array, value) {
   }
   return false;
 }
-export function at(array, index) {
+function at(array, index) {
   const len = array.length;
   if (!len)
     return void 0;
@@ -74,7 +77,7 @@ export function at(array, index) {
     index += len;
   return array[index];
 }
-export function range(...args) {
+function range(...args) {
   let start, stop, step;
   if (args.length === 1) {
     start = 0;
@@ -91,20 +94,143 @@ export function range(...args) {
   }
   return arr;
 }
-export function move(arr, from, to) {
+function move(arr, from, to) {
   arr.splice(to, 0, arr.splice(from, 1)[0]);
   return arr;
 }
-export function clampArrayRange(n, arr) {
+function clampArrayRange(arr, n) {
   return clamp(n, 0, arr.length - 1);
 }
-export function sample(arr, count) {
+function sample(arr, count) {
   return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))]);
 }
-export function shuffle(array) {
+function shuffle(array) {
   for (let i = array.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
     [array[i], array[j]] = [array[j], array[i]];
   }
   return array;
 }
+
+function contains(needle, haystack) {
+  return haystack.some((hay) => needle.includes(hay));
+}
+function containsAll(needles, haystack) {
+  return needles.every((needle) => contains(needle, haystack));
+}
+function containsAny(needles, haystack) {
+  return needles.some((needle) => contains(needle, haystack));
+}
+function containsNone(needles, haystack) {
+  return !containsAny(needles, haystack);
+}
+function containsOnly(needles, haystack) {
+  return containsAll(haystack, needles);
+}
+function doesNotContain(needle, haystack) {
+  return !contains(needle, haystack);
+}
+
+class Arr extends Macroable {
+  contains(needle, haystack) {
+    return contains(needle, haystack);
+  }
+  containsAll(needles, haystack) {
+    return containsAll(needles, haystack);
+  }
+  containsAny(needles, haystack) {
+    return containsAny(needles, haystack);
+  }
+  containsNone(needles, haystack) {
+    return containsNone(needles, haystack);
+  }
+  containsOnly(needles, haystack) {
+    return containsOnly(needles, haystack);
+  }
+  doesNotContain(needle, haystack) {
+    return doesNotContain(needle, haystack);
+  }
+  toArray(array) {
+    return toArray(array);
+  }
+  flatten(array) {
+    return flatten(array);
+  }
+  mergeArrayable(...args) {
+    return mergeArrayable(...args);
+  }
+  partition(array, filter) {
+    return partition(array, filter);
+  }
+  /**
+   * Returns a random item/s from the array
+   */
+  random(arr2, count = 1) {
+    return sample(arr2, count);
+  }
+  /**
+   * Returns random item/s from the array
+   */
+  sample(arr2, count = 1) {
+    return sample(arr2, count);
+  }
+  unique(arr2) {
+    return uniq(arr2);
+  }
+  uniqueBy(arr2, equalFn) {
+    return uniqueBy(arr2, equalFn);
+  }
+  last(arr2) {
+    return last(arr2);
+  }
+  remove(arr2, value) {
+    return remove(arr2, value);
+  }
+  at(arr2, index) {
+    return at(arr2, index);
+  }
+  range(start, end, step = 1) {
+    return range(start, end, step);
+  }
+  move(arr2, from, to) {
+    return move(arr2, from, to);
+  }
+  clampArrayRange(arr2, n) {
+    return clampArrayRange(arr2, n);
+  }
+  shuffle(arr2) {
+    return shuffle(arr2);
+  }
+  /**
+   * Returns the sum of all items in the array
+   */
+  sum(arr2) {
+    return sum(arr2);
+  }
+  /**
+   * Returns the average of all items in the array
+   */
+  average(arr2) {
+    return average(arr2);
+  }
+  avg(arr2) {
+    return average(arr2);
+  }
+  /**
+   * Returns the median of all items in the array
+   */
+  median(arr2) {
+    return median(arr2);
+  }
+  /**
+   * Returns the mode of all items in the array
+   */
+  mode(arr2) {
+    return mode(arr2);
+  }
+}
+Arr.macros = {};
+Arr.getters = {};
+const arr = new Arr();
+
+export { Arr, arr, at, average, avg, clampArrayRange, contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain, flatten, last, median, mergeArrayable, mode, move, partition, range, remove, sample, shuffle, sum, toArray, uniq, unique, uniqueBy };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.53.1",
-  "packageManager": "pnpm@8.5.1",
+  "version": "0.56.23",
+  "packageManager": "pnpm@8.6.5",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -30,6 +30,7 @@
       "import": "./dist/index.mjs"
     }
   },
+  "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "contributors": [
@@ -40,12 +41,16 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@stacksjs/types": "0.53.1",
-    "@stacksjs/utils": "0.53.1"
+    "macroable": "^7.0.2",
+    "@stacksjs/types": "0.56.23",
+    "@stacksjs/utils": "0.56.23"
+  },
+  "dependencies": {
+    "macroable": "^7.0.2"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.53.1",
-    "@stacksjs/types": "0.53.1"
+    "@stacksjs/development": "0.56.23",
+    "@stacksjs/types": "0.56.23"
   },
   "scripts": {
     "build": "unbuild",