@fluixi/utils 1.0.0-alpha.100

package/dist/lib/array/utils.cjs

@@ -0,0 +1,103 @@
+"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/lib/array/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  at: () => at,
+  first: () => first,
+  flattenArray: () => flattenArray,
+  groupArrayBy: () => groupArrayBy,
+  isArray: () => isArray,
+  isArrayLike: () => isArrayLike,
+  isDoubleArray: () => isDoubleArray,
+  isEmptyArray: () => isEmptyArray,
+  isIterable: () => isIterable,
+  isNonEmptyArray: () => isNonEmptyArray,
+  isObjectArray: () => isObjectArray,
+  isReadonlyArray: () => isReadonlyArray,
+  isStaticArray: () => isStaticArray,
+  isTypedArray: () => isTypedArray,
+  last: () => last,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(utils_exports);
+var import_object = require("@fluixi/utils/object");
+var isObjectArray = (value) => {
+  return Array.isArray(value) && value.every((item) => (0, import_object.isObject)(item));
+};
+function isArray(v) {
+  return Array.isArray(v);
+}
+function isStaticArray(v) {
+  return Array.isArray(v);
+}
+function isDoubleArray(v) {
+  return Array.isArray(v) && v.every((item) => Array.isArray(item) && item.length === 2);
+}
+function isIterable(v) {
+  return v != null && typeof v[Symbol.iterator] === "function";
+}
+function isArrayLike(v) {
+  return v != null && typeof v === "object" && "length" in v && typeof v.length === "number" && v.length >= 0 && (v.length === 0 || v.length - 1 in v);
+}
+function isEmptyArray(v) {
+  return Array.isArray(v) && v.length === 0;
+}
+function isNonEmptyArray(v) {
+  return Array.isArray(v) && v.length > 0;
+}
+function isTypedArray(v) {
+  return ArrayBuffer.isView(v) && !(v instanceof DataView);
+}
+function isReadonlyArray(v) {
+  return Array.isArray(v);
+}
+function last(arr) {
+  return arr.length > 0 ? arr[arr.length - 1] : void 0;
+}
+function first(arr) {
+  return arr.length > 0 ? arr[0] : void 0;
+}
+function toArray(iterable) {
+  if (Array.isArray(iterable)) {
+    return [...iterable];
+  }
+  if (isIterable(iterable)) {
+    return [...iterable];
+  }
+  return Array.from(iterable);
+}
+function groupArrayBy(arr, keyFn) {
+  return arr.reduce((groups, item) => {
+    const key = keyFn(item);
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+    return groups;
+  }, {});
+}
+function flattenArray(arr) {
+  return arr.flat();
+}
+function at(arr, index) {
+  const normalizedIndex = index < 0 ? arr.length + index : index;
+  return arr[normalizedIndex];
+}

package/dist/lib/array/utils.d.ts

@@ -0,0 +1,100 @@
+import { type AnyObject } from '@fluixi/utils/object';
+/**
+ * Type guard to check if a value is an object array
+ * @param value - Value to check
+ * @returns True if value is an object array
+ */
+export declare const isObjectArray: (value: any) => value is AnyObject[];
+/**
+ * Type guard to check if a value is an array
+ * @param v - Value to check
+ * @returns True if value is an array
+ */
+export declare function isArray<T = any>(v: unknown): v is T[];
+/**
+ * Type guard to check if a value is a static array
+ * @param v - Value to check
+ * @returns True if value is a static array
+ */
+export declare function isStaticArray<T = any, U = any>(v: unknown): v is [T, U];
+/**
+ * Type guard to check if a value is an array of 2-item tuples: [T, U][]
+ * @param v - Value to check
+ * @returns True if value is an array of 2-item tuples
+ */
+export declare function isDoubleArray<T = any, U = any>(v: unknown): v is [T, U][];
+/**
+ * Type guard to check if a value is iterable
+ * @param v - Value to check
+ * @returns True if value is iterable
+ */
+export declare function isIterable(v: unknown): v is Iterable<unknown>;
+/**
+ * Type guard to check if a value is array-like
+ * @param v - Value to check
+ * @returns True if value is array-like
+ */
+export declare function isArrayLike(v: unknown): v is ArrayLike<unknown>;
+/**
+ * Type guard to check if an array is empty
+ * @param v - Array to check
+ * @returns True if array is empty
+ */
+export declare function isEmptyArray<T>(v: T[]): boolean;
+/**
+ * Type guard to check if a value is a non-empty array
+ * @param v - Value to check
+ * @returns True if value is a non-empty array
+ */
+export declare function isNonEmptyArray<T>(v: unknown): v is [T, ...T[]];
+/**
+ * Type guard to check if a value is a typed array
+ * @param v - Value to check
+ * @returns True if value is a typed array (Int8Array, Uint8Array, etc.)
+ */
+export declare function isTypedArray(v: unknown): v is Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Type guard to check if a value is a readonly array
+ * @param v - Value to check
+ * @returns True if value is a readonly array
+ */
+export declare function isReadonlyArray<T = any>(v: unknown): v is readonly T[];
+/**
+ * Safely get the last element of an array
+ * @param arr - Array to get last element from
+ * @returns Last element or undefined if array is empty
+ */
+export declare function last<T>(arr: T[]): T | undefined;
+/**
+ * Safely get the first element of an array
+ * @param arr - Array to get first element from
+ * @returns First element or undefined if array is empty
+ */
+export declare function first<T>(arr: T[]): T | undefined;
+/**
+ * Create an array from an iterable or array-like object with type safety
+ * @param iterable - Iterable or array-like object
+ * @returns Array from the iterable
+ */
+export declare function toArray<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+/**
+ * Group array items by a key
+ * @param arr - Array to group
+ * @param keyFn - Function to extract group key
+ * @returns Object with keys mapping to arrays of items
+ */
+export declare function groupArrayBy<T, K extends string | number | symbol>(arr: T[], keyFn: (item: T) => K): Record<K, T[]>;
+/**
+ * Flatten an array of arrays
+ * @param arr - Array of arrays to flatten
+ * @returns Flattened array
+ */
+export declare function flattenArray<T>(arr: T[][]): T[];
+/**
+ * Get array element by index with support for negative indices
+ * @param arr - Array to get element from
+ * @param index - Index (negative counts from end)
+ * @returns Element at index or undefined if out of bounds
+ */
+export declare function at<T>(arr: T[], index: number): T | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/array/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/array/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,GAAG,KAAG,KAAK,IAAI,SAAS,EAE5D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,CAAC,EAAE,CAErD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAKzE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,CAS/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,OAAO,GACT,CAAC,IACA,SAAS,GACT,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,cAAc,CAEjB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAAC,EAAE,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAQpE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAChE,GAAG,EAAE,CAAC,EAAE,EACR,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAShB;AAkBD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAG5D"}

package/dist/lib/array/utils.js

@@ -0,0 +1,165 @@
+import { isObject } from '@fluixi/utils/object';
+/**
+ * Type guard to check if a value is an object array
+ * @param value - Value to check
+ * @returns True if value is an object array
+ */
+export const isObjectArray = (value) => {
+    return Array.isArray(value) && value.every((item) => isObject(item));
+};
+/**
+ * Type guard to check if a value is an array
+ * @param v - Value to check
+ * @returns True if value is an array
+ */
+export function isArray(v) {
+    return Array.isArray(v);
+}
+/**
+ * Type guard to check if a value is a static array
+ * @param v - Value to check
+ * @returns True if value is a static array
+ */
+export function isStaticArray(v) {
+    return Array.isArray(v);
+}
+/**
+ * Type guard to check if a value is an array of 2-item tuples: [T, U][]
+ * @param v - Value to check
+ * @returns True if value is an array of 2-item tuples
+ */
+export function isDoubleArray(v) {
+    return (Array.isArray(v) &&
+        v.every((item) => Array.isArray(item) && item.length === 2));
+}
+/**
+ * Type guard to check if a value is iterable
+ * @param v - Value to check
+ * @returns True if value is iterable
+ */
+export function isIterable(v) {
+    return v != null && typeof v[Symbol.iterator] === 'function';
+}
+/**
+ * Type guard to check if a value is array-like
+ * @param v - Value to check
+ * @returns True if value is array-like
+ */
+export function isArrayLike(v) {
+    return (v != null &&
+        typeof v === 'object' &&
+        'length' in v &&
+        typeof v.length === 'number' &&
+        v.length >= 0 &&
+        (v.length === 0 || v.length - 1 in v));
+}
+/**
+ * Type guard to check if an array is empty
+ * @param v - Array to check
+ * @returns True if array is empty
+ */
+export function isEmptyArray(v) {
+    return Array.isArray(v) && v.length === 0;
+}
+/**
+ * Type guard to check if a value is a non-empty array
+ * @param v - Value to check
+ * @returns True if value is a non-empty array
+ */
+export function isNonEmptyArray(v) {
+    return Array.isArray(v) && v.length > 0;
+}
+/**
+ * Type guard to check if a value is a typed array
+ * @param v - Value to check
+ * @returns True if value is a typed array (Int8Array, Uint8Array, etc.)
+ */
+export function isTypedArray(v) {
+    return ArrayBuffer.isView(v) && !(v instanceof DataView);
+}
+/**
+ * Type guard to check if a value is a readonly array
+ * @param v - Value to check
+ * @returns True if value is a readonly array
+ */
+export function isReadonlyArray(v) {
+    return Array.isArray(v);
+}
+/**
+ * Safely get the last element of an array
+ * @param arr - Array to get last element from
+ * @returns Last element or undefined if array is empty
+ */
+export function last(arr) {
+    return arr.length > 0 ? arr[arr.length - 1] : undefined;
+}
+/**
+ * Safely get the first element of an array
+ * @param arr - Array to get first element from
+ * @returns First element or undefined if array is empty
+ */
+export function first(arr) {
+    return arr.length > 0 ? arr[0] : undefined;
+}
+/**
+ * Create an array from an iterable or array-like object with type safety
+ * @param iterable - Iterable or array-like object
+ * @returns Array from the iterable
+ */
+export function toArray(iterable) {
+    if (Array.isArray(iterable)) {
+        return [...iterable];
+    }
+    if (isIterable(iterable)) {
+        return [...iterable];
+    }
+    return Array.from(iterable);
+}
+/**
+ * Group array items by a key
+ * @param arr - Array to group
+ * @param keyFn - Function to extract group key
+ * @returns Object with keys mapping to arrays of items
+ */
+export function groupArrayBy(arr, keyFn) {
+    return arr.reduce((groups, item) => {
+        const key = keyFn(item);
+        if (!groups[key]) {
+            groups[key] = [];
+        }
+        groups[key].push(item);
+        return groups;
+    }, {});
+}
+// /**
+//  * Chunk an array into smaller arrays of specified size
+//  * @param arr - Array to chunk
+//  * @param size - Size of each chunk
+//  * @returns Array of chunks
+//  */
+// export function chunk<T>(arr: T[], size: number): T[][] {
+//   if (size <= 0) return [];
+//   const chunks: T[][] = [];
+//   for (let i = 0; i < arr.length; i += size) {
+//     chunks.push(arr.slice(i, i + size));
+//   }
+//   return chunks;
+// }
+/**
+ * Flatten an array of arrays
+ * @param arr - Array of arrays to flatten
+ * @returns Flattened array
+ */
+export function flattenArray(arr) {
+    return arr.flat();
+}
+/**
+ * Get array element by index with support for negative indices
+ * @param arr - Array to get element from
+ * @param index - Index (negative counts from end)
+ * @returns Element at index or undefined if out of bounds
+ */
+export function at(arr, index) {
+    const normalizedIndex = index < 0 ? arr.length + index : index;
+    return arr[normalizedIndex];
+}

package/dist/lib/array/utils.mjs

@@ -0,0 +1,82 @@
+// src/lib/array/utils.ts
+import { isObject } from "@fluixi/utils/object";
+var isObjectArray = (value) => {
+  return Array.isArray(value) && value.every((item) => isObject(item));
+};
+function isArray(v) {
+  return Array.isArray(v);
+}
+function isStaticArray(v) {
+  return Array.isArray(v);
+}
+function isDoubleArray(v) {
+  return Array.isArray(v) && v.every((item) => Array.isArray(item) && item.length === 2);
+}
+function isIterable(v) {
+  return v != null && typeof v[Symbol.iterator] === "function";
+}
+function isArrayLike(v) {
+  return v != null && typeof v === "object" && "length" in v && typeof v.length === "number" && v.length >= 0 && (v.length === 0 || v.length - 1 in v);
+}
+function isEmptyArray(v) {
+  return Array.isArray(v) && v.length === 0;
+}
+function isNonEmptyArray(v) {
+  return Array.isArray(v) && v.length > 0;
+}
+function isTypedArray(v) {
+  return ArrayBuffer.isView(v) && !(v instanceof DataView);
+}
+function isReadonlyArray(v) {
+  return Array.isArray(v);
+}
+function last(arr) {
+  return arr.length > 0 ? arr[arr.length - 1] : void 0;
+}
+function first(arr) {
+  return arr.length > 0 ? arr[0] : void 0;
+}
+function toArray(iterable) {
+  if (Array.isArray(iterable)) {
+    return [...iterable];
+  }
+  if (isIterable(iterable)) {
+    return [...iterable];
+  }
+  return Array.from(iterable);
+}
+function groupArrayBy(arr, keyFn) {
+  return arr.reduce((groups, item) => {
+    const key = keyFn(item);
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+    return groups;
+  }, {});
+}
+function flattenArray(arr) {
+  return arr.flat();
+}
+function at(arr, index) {
+  const normalizedIndex = index < 0 ? arr.length + index : index;
+  return arr[normalizedIndex];
+}
+export {
+  at,
+  first,
+  flattenArray,
+  groupArrayBy,
+  isArray,
+  isArrayLike,
+  isDoubleArray,
+  isEmptyArray,
+  isIterable,
+  isNonEmptyArray,
+  isObjectArray,
+  isReadonlyArray,
+  isStaticArray,
+  isTypedArray,
+  last,
+  toArray
+};