@zairakai/js-utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Stanislas Poisson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,270 @@
+# @zairakai/js-utils
+
+[![Main][pipeline-main-badge]][pipeline-main-link]
+[![Develop][pipeline-develop-badge]][pipeline-develop-link]
+[![Coverage][coverage-badge]][coverage-link]
+
+[![npm][npm-badge]][npm-link]
+[![GitLab Release][gitlab-release-badge]][gitlab-release]
+[![License][license-badge]][license]
+
+[![Node.js][node-badge]][node]
+[![ESLint][eslint-badge]][eslint]
+[![Prettier][prettier-badge]][prettier]
+
+Collection of JavaScript utility functions for string manipulation, validation, and formatting. Inspired by Laravel's helpers with modern TypeScript support.
+
+---
+
+## Features
+
+- **Fluent Strings (`str`)** — Chained string manipulation (title, slug, limit, etc.)
+- **Fluent Numbers (`num`)** — Formatting (currency, filesize), abbreviating, and calculations
+- **Fluent Objects (`obj`)** — Dot notation access, deep merging, and state tracking (dirty/clean)
+- **Enhanced Collections** — Laravel-like collection methods for arrays and maps
+- **Runtime Validation (`validator`)** — Zod-powered validation with a familiar API
+- **PHP-like Arrays** — Direct API parity for PHP's array functions (`array_chunk`, `array_merge`, etc.)
+- **Runtime Schemas** — Pre-defined Zod schemas for common data types (Email, Phone, URL, etc.)
+- **Deep Equality** — Robust deep comparison and diffing utilities
+- **Type Guards** — Reliable type checking (isRecord, isEmail, etc.)
+- **DateTime** — Lightweight wrapper around dayjs with useful presets
+
+---
+
+## Install
+
+```bash
+npm install @zairakai/js-utils
+```
+
+To use `validator` and `schemas` features, install `zod` (optional peer dependency):
+
+```bash
+npm install zod
+```
+
+---
+
+## Usage Examples
+
+### Fluent Strings
+
+```typescript
+import { str } from '@zairakai/js-utils'
+
+const result = str('hello world').title().append(' extra').slug().get() // "hello-world-extra"
+```
+
+### Fluent Numbers
+
+```typescript
+import { num } from '@zairakai/js-utils'
+
+num(1024).fileSize() // "1 KB"
+num(1500).abbreviate() // "1.5K"
+num(10).add(5).mul(2).get() // 30
+```
+
+### State Tracking (Dirty)
+
+```typescript
+import { obj } from '@zairakai/js-utils'
+
+const user = obj({ name: 'John', status: 'active' })
+user.dataSet('name', 'Jane')
+
+user.isDirty() // true
+user.getDirty() // { name: 'Jane' }
+user.syncOriginal() // Mark as clean
+```
+
+### Validation
+
+```typescript
+import { validator } from '@zairakai/js-utils'
+import { z } from 'zod'
+
+const v = validator(data, {
+  email: z.string().email(),
+  age: z.number().min(18),
+})
+
+if (v.fails()) {
+  console.log(v.errors())
+}
+```
+
+---
+
+## API Reference
+
+<details>
+<summary><strong>Fluent Strings (str / Stringable)</strong></summary>
+
+| Method                        | Description                                             |
+| ----------------------------- | ------------------------------------------------------- |
+| `append(...values)`           | Append the given values to the string.                  |
+| `camel()`                     | Convert the string to camelCase.                        |
+| `capitalize()`                | Capitalize the first character.                         |
+| `contains(needles)`           | Determine if the string contains any of the needles.    |
+| `containsAll(needles)`        | Determine if the string contains all of the needles.    |
+| `endsWith(needles)`           | Determine if the string ends with any of the needles.   |
+| `finish(cap)`                 | Cap the string with a single instance of a given value. |
+| `get()` / `toString()`        | Get the raw string value.                               |
+| `kebab()`                     | Convert the string to kebab-case.                       |
+| `limit(size, end)`            | Limit the number of characters in a string.             |
+| `lower()`                     | Convert the string to lower case.                       |
+| `mask(char, index, length)`   | Mask a portion of the string with a character.          |
+| `prepend(...values)`          | Prepend the given values to the string.                 |
+| `replace(search, replace)`    | Replace the first occurrence of a value.                |
+| `replaceAll(search, replace)` | Replace all occurrences of a value.                     |
+| `reverse()`                   | Reverse the string.                                     |
+| `slug()`                      | Convert the string to a URL friendly slug.              |
+| `snake()`                     | Convert the string to snake_case.                       |
+| `start(prefix)`               | Begin a string with a single instance of a given value. |
+| `startsWith(needles)`         | Determine if the string starts with any of the needles. |
+| `studly()`                    | Convert the string to StudlyCase.                       |
+| `title()`                     | Convert the string to Title Case.                       |
+| `trim(chars?)`                | Trim the string (optional custom characters).           |
+| `upper()`                     | Convert the string to upper case.                       |
+| `when(condition, callback)`   | Conditionally execute a callback.                       |
+
+</details>
+
+<details>
+<summary><strong>Fluent Numbers (num / Numberable)</strong></summary>
+
+| Method                           | Description                                        |
+| -------------------------------- | -------------------------------------------------- |
+| `abbreviate(precision)`          | Abbreviate the number (e.g., 1K, 1.5M).            |
+| `add(value)` / `sub(value)`      | Arithmetic operations.                             |
+| `mul(value)` / `div(value)`      | Arithmetic operations.                             |
+| `ceil()` / `floor()` / `round()` | Rounding operations.                               |
+| `clamp(min, max)`                | Clamp the number between min and max.              |
+| `currency(code, locale)`         | Format as currency (default: USD).                 |
+| `fileSize(precision)`            | Format as human-readable file size (KB, MB, etc.). |
+| `format(decimals, locale)`       | Format the number with locale-specific separators. |
+| `isBetween(min, max)`            | Check if number is between min and max.            |
+| `ordinal()`                      | Add an ordinal suffix (1st, 2nd, 3rd...).          |
+| `percentage(decimals)`           | Format as a percentage.                            |
+
+</details>
+
+<details>
+<summary><strong>Fluent Objects (obj / Objectable)</strong></summary>
+
+| Method                  | Description                                                    |
+| ----------------------- | -------------------------------------------------------------- |
+| `clone()`               | Deep clone the object.                                         |
+| `dataGet(key, default)` | Get a value using dot notation (e.g., `user.profile.id`).      |
+| `dataSet(key, value)`   | Set a value using dot notation.                                |
+| `except(keys)`          | Get all properties except those specified.                     |
+| `filter(callback)`      | Filter object properties.                                      |
+| `getDirty()`            | Get the properties that have been modified.                    |
+| `isDirty(key?)`         | Determine if the object (or a specific key) has been modified. |
+| `map(callback)`         | Map over the object properties.                                |
+| `merge(other)`          | Shallow merge with another object.                             |
+| `mergeDeep(other)`      | Recursive deep merge.                                          |
+| `only(keys)`            | Get only the specified properties.                             |
+| `syncOriginal()`        | Sync current state as the "clean" state.                       |
+
+</details>
+
+<details>
+<summary><strong>Enhanced Collections (collect / EnhancedArray / EnhancedMap)</strong></summary>
+
+Extends native `Array` and `Map` with 50+ methods including:
+
+- **Navigation**: `at(index)`, `before(item)`, `after(item)`
+- **Transformation**: `pluck(key)`, `groupBy(key)`, `unique(key)`, `chunk(size)`, `chunkBy(key)`, `deepFlatten()`, `transpose()`, `filterMap(cb)`, `extract(keys)`, `rotate(n)`, `getNth(n)`
+- **Statistical**: `median()`, `mode()`, `standardDeviation()`, `percentile(p)`, `frequencies()`
+- **Advanced**: `cartesian(...arrays)`, `interleave(...arrays)`, `sliding(size, step)`, `paginate(perPage, page)`, `weightedRandom(weights?)`, `recursive()`
+- **State**: `isDirty()`, `isClean()`, `syncOriginal()`, `isEquivalent(other)`
+
+</details>
+
+<details>
+<summary><strong>PHP-like Arrays (php_array)</strong></summary>
+
+Provides direct API parity for PHP's array functions (only those that add value beyond native JS):
+`array_chunk`, `array_filter`, `array_map`, `array_reduce`, `array_merge`, `array_unique`, `array_reverse`, `array_slice`, `array_splice`, `array_keys`, `array_search`, `array_key_exists`, `array_pop`, `array_push`, `array_shift`, `array_unshift`, `array_sum`, `array_product`, `array_rand`, `array_flip`, `array_count_values`, `array_intersect`, `array_diff`, `array_column`, `range`, and sorting functions (`sort`, `rsort`, `usort`, `uasort`, `uksort`, `shuffle`).
+
+</details>
+
+<details>
+<summary><strong>Runtime Schemas</strong></summary>
+
+Pre-defined Zod schemas and TypeScript types for common primitives:
+
+- `EmailSchema` / `Email`
+- `PhoneSchema` / `Phone`
+- `UrlSchema` / `Url`
+- `DateSchema`
+- `ApiResponseSchema<T>` / `ApiResponse<T>`
+- `PaginationSchema` / `Pagination`
+- `PaginatedResponseSchema<T>` / `PaginatedResponse<T>`
+
+Utility functions: `validateSchema(schema, data)`, `safeValidateSchema(schema, data)`.
+
+> Requires `zod` — install separately (`npm install zod`).
+
+</details>
+
+<details>
+<summary><strong>Standard Utilities</strong></summary>
+
+- **Validators**: `isEmail`, `isUrl`, `isUuid`, `isIp`, `isMacAddress`, `isRecord`, `isInteger`, etc.
+- **Formatters**: `snakeCase`, `kebabCase`, `camelCase`, `slugify`, `numberFormat`, etc.
+- **Runtime**: `tap`, `when(condition, () => R)`, `retry`, `optional`, `data_get`, `data_set`, `throw_if`, `throw_unless`.
+- **Deep Equality**: `isEqual(a, b)`, `diff(original, current)`.
+- **DateTime**: `now()`, `today()`, `tomorrow()`, `yesterday()`, `isBetweenDates(date, start, end)`, `fromNow(date)`, `isToday(date)`, `isPast(date)`, `isFuture(date)`.
+
+</details>
+
+---
+
+## Development
+
+```bash
+npm test              # run vitest
+npm run build         # build with tsup
+npm run docs          # generate TypeDoc documentation
+npm run typecheck     # run tsc
+make quality          # run full quality suite
+```
+
+---
+
+## Getting Help
+
+[![License][license-badge]][license]
+[![Security Policy][security-badge]][security]
+[![Issues][issues-badge]][issues]
+
+**Made with ❤️ by [Zairakai][ecosystem]**
+
+<!-- Reference Links -->
+
+[pipeline-main-badge]: https://gitlab.com/zairakai/npm-packages/js-utils/badges/main/pipeline.svg?ignore_skipped=true&key_text=Main
+[pipeline-main-link]: https://gitlab.com/zairakai/npm-packages/js-utils/-/commits/main
+[pipeline-develop-badge]: https://gitlab.com/zairakai/npm-packages/js-utils/badges/develop/pipeline.svg?ignore_skipped=true&key_text=Develop
+[pipeline-develop-link]: https://gitlab.com/zairakai/npm-packages/js-utils/-/commits/develop
+[coverage-badge]: https://gitlab.com/zairakai/npm-packages/js-utils/badges/main/coverage.svg
+[coverage-link]: https://gitlab.com/zairakai/npm-packages/js-utils/-/pipelines?ref=main
+[npm-badge]: https://img.shields.io/npm/v/@zairakai/js-utils
+[npm-link]: https://www.npmjs.com/package/@zairakai/js-utils
+[gitlab-release-badge]: https://img.shields.io/gitlab/v/release/zairakai/npm-packages/js-utils?logo=gitlab
+[gitlab-release]: https://gitlab.com/zairakai/npm-packages/js-utils/-/releases
+[license-badge]: https://img.shields.io/badge/license-MIT-blue.svg
+[license]: ./LICENSE
+[security-badge]: https://img.shields.io/badge/security-scanned-green.svg
+[security]: ./SECURITY.md
+[issues-badge]: https://img.shields.io/gitlab/issues/open-raw/zairakai%2Fnpm-packages%2Fhelpers?logo=gitlab&label=Issues
+[issues]: https://gitlab.com/zairakai/npm-packages/js-utils/-/issues
+[node-badge]: https://img.shields.io/badge/node.js-%3E%3D22-green.svg?logo=node.js
+[node]: https://nodejs.org
+[eslint-badge]: https://img.shields.io/badge/code%20style-eslint-4B32C3.svg?logo=eslint
+[eslint]: https://eslint.org
+[prettier-badge]: https://img.shields.io/badge/formatter-prettier-F7B93E.svg?logo=prettier
+[prettier]: https://prettier.io
+[ecosystem]: https://gitlab.com/zairakai

package/dist/arrays.cjs

@@ -0,0 +1,210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/arrays.ts
+var arrays_exports = {};
+__export(arrays_exports, {
+  arrayAdd: () => arrayAdd,
+  arrayCollapse: () => arrayCollapse,
+  arrayDivide: () => arrayDivide,
+  arrayDot: () => arrayDot,
+  arrayExcept: () => arrayExcept,
+  arrayFirst: () => arrayFirst,
+  arrayFlatten: () => arrayFlatten,
+  arrayGet: () => arrayGet,
+  arrayGroupBy: () => arrayGroupBy,
+  arrayHas: () => arrayHas,
+  arrayOnly: () => arrayOnly,
+  arrayPluck: () => arrayPluck,
+  arrayUnique: () => arrayUnique,
+  arrayWhere: () => arrayWhere
+});
+module.exports = __toCommonJS(arrays_exports);
+var arrayAdd = (array, key, value) => {
+  const result = Array.isArray(array) ? Object.fromEntries(array.map((v, i) => [i, v])) : { ...array };
+  result[key] = value;
+  return result;
+};
+var arrayCollapse = (array) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.reduce((flat, item) => {
+    if (Array.isArray(item)) {
+      return flat.concat(item);
+    }
+    return flat.concat([item]);
+  }, []);
+};
+var arrayDivide = (array) => {
+  if (!Array.isArray(array)) {
+    return [[], []];
+  }
+  const keys = array.map((_, index) => index.toString());
+  const values = [...array];
+  return [keys, values];
+};
+var arrayDot = (array, prepend = "") => {
+  const result = {};
+  for (const [key, value] of Object.entries(array)) {
+    const newKey = prepend ? `${prepend}.${key}` : key;
+    if (value && "object" === typeof value && !Array.isArray(value)) {
+      Object.assign(result, arrayDot(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+};
+var arrayExcept = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return array;
+  }
+  return array.filter((_, index) => !keys.includes(index.toString()));
+};
+var arrayFirst = (array, callback, defaultValue) => {
+  if (!Array.isArray(array)) {
+    return defaultValue;
+  }
+  if (!callback) {
+    return 0 < array.length ? array[0] : defaultValue;
+  }
+  for (let i = 0; i < array.length; i++) {
+    if (callback(array[i], i)) {
+      return array[i];
+    }
+  }
+  return defaultValue;
+};
+var arrayFlatten = (array, depth = Infinity) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const flatten = (arr, currentDepth) => {
+    const result = [];
+    for (const item of arr) {
+      if (Array.isArray(item) && 0 < currentDepth) {
+        result.push(...flatten(item, currentDepth - 1));
+      } else {
+        result.push(item);
+      }
+    }
+    return result;
+  };
+  return flatten(array, depth);
+};
+var arrayGet = (array, key, defaultValue) => {
+  if (!array || "object" !== typeof array) {
+    return defaultValue;
+  }
+  const keys = key.split(".");
+  let current = array;
+  for (const k of keys) {
+    if (null === current || current === void 0 || "object" !== typeof current || !(k in current)) {
+      return defaultValue;
+    }
+    current = current[k];
+  }
+  return current;
+};
+var arrayHas = (array, keys) => {
+  if (!array || "object" !== typeof array) {
+    return false;
+  }
+  const keyArray = Array.isArray(keys) ? keys : [keys];
+  return keyArray.every((key) => {
+    const keyParts = key.split(".");
+    let current = array;
+    for (const part of keyParts) {
+      if (null === current || current === void 0 || "object" !== typeof current || !(part in current)) {
+        return false;
+      }
+      current = current[part];
+    }
+    return true;
+  });
+};
+var arrayOnly = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return [];
+  }
+  return array.filter((_, index) => keys.includes(index.toString()));
+};
+var arrayWhere = (array, callback) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.filter(callback);
+};
+var arrayPluck = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.map((item) => item && "object" === typeof item ? item[key] : void 0).filter((value) => value !== void 0);
+};
+var arrayGroupBy = (array, keyOrFn) => {
+  if (!Array.isArray(array)) {
+    return {};
+  }
+  return array.reduce(
+    (groups, item) => {
+      const key = "function" === typeof keyOrFn ? String(keyOrFn(item)) : String(item && "object" === typeof item ? item[keyOrFn] : item);
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+      return groups;
+    },
+    {}
+  );
+};
+var arrayUnique = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  if (!key) {
+    return [...new Set(array)];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return array.filter((item) => {
+    const value = item && "object" === typeof item ? item[key] : item;
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+    return true;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayAdd,
+  arrayCollapse,
+  arrayDivide,
+  arrayDot,
+  arrayExcept,
+  arrayFirst,
+  arrayFlatten,
+  arrayGet,
+  arrayGroupBy,
+  arrayHas,
+  arrayOnly,
+  arrayPluck,
+  arrayUnique,
+  arrayWhere
+});

package/dist/arrays.d.cts

@@ -0,0 +1,119 @@
+/**
+ * Array manipulation and utility functions
+ * Inspired by Laravel's array helpers
+ */
+/**
+ * Add an element to an array or record at a specific key.
+ *
+ * @param {T[] | Record<string, T>} array The source array or record
+ * @param {string} key The key to add the value at
+ * @param {T} value The value to add
+ * @returns {Record<string, unknown>} The resulting record
+ */
+declare const arrayAdd: <T>(array: T[] | Record<string, T>, key: string, value: T) => Record<string, unknown>;
+/**
+ * Collapse an array of arrays into a single array.
+ *
+ * @param {T[][]} array The array of arrays to collapse
+ * @returns {T[]} The collapsed array
+ */
+declare const arrayCollapse: <T>(array: T[][]) => T[];
+/**
+ * Divide an array into two arrays: one with keys (indices) and one with values.
+ *
+ * @param {T[]} array The array to divide
+ * @returns {[string[], T[]]} A tuple containing keys and values
+ */
+declare const arrayDivide: <T>(array: T[]) => [string[], T[]];
+/**
+ * Flatten a multi-dimensional record into a single-level record using dot notation.
+ *
+ * @param {Record<string, unknown>} array The record to flatten
+ * @param {string} prepend The string to prepend to keys
+ * @returns {Record<string, unknown>} The flattened record
+ */
+declare const arrayDot: (array: Record<string, unknown>, prepend?: string) => Record<string, unknown>;
+/**
+ * Get all of the given array except for a specified array of keys (indices).
+ *
+ * @param {T[]} array The source array
+ * @param {string[]} keys The keys to exclude
+ * @returns {T[]} The filtered array
+ */
+declare const arrayExcept: <T>(array: T[], keys: string[]) => T[];
+/**
+ * Return the first element in an array passing a given truth test.
+ *
+ * @param {T[]} array The source array
+ * @param {Function} [callback] Optional callback for truth test
+ * @param {T} [defaultValue] Optional default value if no element found
+ * @returns {T | undefined} The first matching element or default value
+ */
+declare const arrayFirst: <T>(array: T[], callback?: (item: T, index: number) => boolean, defaultValue?: T) => T | undefined;
+/**
+ * Flatten a multi-dimensional array into a single level.
+ *
+ * @param {unknown[]} array The array to flatten
+ * @param {number} [depth=Infinity] The depth to flatten to
+ * @returns {T[]} The flattened array
+ */
+declare const arrayFlatten: <T>(array: unknown[], depth?: number) => T[];
+/**
+ * Get an item from a record using dot notation.
+ *
+ * @param {Record<string, unknown>} array The source record
+ * @param {string} key The key to retrieve
+ * @param {unknown} [defaultValue] The default value if key not found
+ * @returns {unknown} The value at the key or default value
+ */
+declare const arrayGet: (array: Record<string, unknown>, key: string, defaultValue?: unknown) => unknown;
+/**
+ * Check if an item or items exist in a record using "dot" notation.
+ *
+ * @param {Record<string, unknown>} array The source record
+ * @param {string | string[]} keys The key or keys to check
+ * @returns {boolean} True if all keys exist, false otherwise
+ */
+declare const arrayHas: (array: Record<string, unknown>, keys: string | string[]) => boolean;
+/**
+ * Get a subset of the array's elements specified by keys (indices).
+ *
+ * @param {T[]} array The source array
+ * @param {string[]} keys The keys to include
+ * @returns {T[]} The filtered array
+ */
+declare const arrayOnly: <T>(array: T[], keys: string[]) => T[];
+/**
+ * Filter the array using the given callback.
+ *
+ * @param {T[]} array The source array
+ * @param {Function} callback The callback to use for filtering
+ * @returns {T[]} The filtered array
+ */
+declare const arrayWhere: <T>(array: T[], callback: (item: T, index: number) => boolean) => T[];
+/**
+ * Pluck an array of values from an array of objects.
+ *
+ * @param {T[]} array The source array
+ * @param {K} key The key to pluck
+ * @returns {T[K][]} The plucked values
+ */
+declare const arrayPluck: <T, K extends keyof T>(array: T[], key: K) => T[K][];
+/**
+ * Group an array's items by a given key or callback.
+ *
+ * @param {T[]} array The source array
+ * @param {keyof T | Function} keyOrFn The key or callback to group by
+ * @returns {Record<string, T[]>} The grouped items
+ */
+declare const arrayGroupBy: <T>(array: T[], keyOrFn: keyof T | ((item: T) => string | number)) => Record<string, T[]>;
+/**
+ * Filter the array to only unique elements.
+ *
+ * @param {T[]} array The source array
+ * @param {keyof T} [key] Optional key to use for uniqueness
+ * @returns {T[]} The array with unique elements
+ */
+declare const arrayUnique: <T>(array: T[], key?: keyof T) => T[];
+
+export { arrayAdd, arrayCollapse, arrayDivide, arrayDot, arrayExcept, arrayFirst, arrayFlatten, arrayGet, arrayGroupBy, arrayHas, arrayOnly, arrayPluck, arrayUnique, arrayWhere };