ts-array-lite 1.0.0

package/dist/array.d.ts

@@ -0,0 +1,26 @@
+export declare class ArrayUtils {
+    unique<T>(arr: T[]): T[];
+    chunk<T>(arr: T[], size: number): T[][];
+    groupBy<T>(arr: T[], key: keyof T | ((item: T) => string)): Record<string, T[]>;
+    sortBy<T>(arr: T[], key: keyof T, order?: 'asc' | 'desc'): T[];
+    shuffle<T>(arr: T[]): T[];
+    sample<T>(arr: T[]): T | undefined;
+    intersection<T>(a: T[], b: T[]): T[];
+    difference<T>(a: T[], b: T[]): T[];
+    compact<T>(arr: (T | null | undefined | false | 0 | '')[]): T[];
+    flatten<T>(arr: (T | T[])[]): T[];
+    flattenDeep<T>(arr: unknown[]): T[];
+    partition<T>(arr: T[], predicate: (item: T) => boolean): [T[], T[]];
+    pluck<T, K extends keyof T>(arr: T[], key: K): T[K][];
+    first<T>(arr: T[]): T | undefined;
+    last<T>(arr: T[]): T | undefined;
+    drop<T>(arr: T[], n?: number): T[];
+    take<T>(arr: T[], n?: number): T[];
+    sum(arr: number[]): number;
+    average(arr: number[]): number;
+    min(arr: number[]): number | undefined;
+    max(arr: number[]): number | undefined;
+    range(start: number, end: number, step?: number): number[];
+    zip<T>(...arrays: T[][]): T[][];
+    uniqBy<T>(arr: T[], key: keyof T): T[];
+}

package/dist/array.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtils = void 0;
+class ArrayUtils {
+    unique(arr) {
+        return [...new Set(arr)];
+    }
+    chunk(arr, size) {
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += size) {
+            chunks.push(arr.slice(i, i + size));
+        }
+        return chunks;
+    }
+    groupBy(arr, key) {
+        return arr.reduce((groups, item) => {
+            const groupKey = typeof key === 'function' ? key(item) : String(item[key]);
+            (groups[groupKey] = groups[groupKey] || []).push(item);
+            return groups;
+        }, {});
+    }
+    sortBy(arr, key, order = 'asc') {
+        return [...arr].sort((a, b) => {
+            const aVal = a[key], bVal = b[key];
+            if (aVal < bVal)
+                return order === 'asc' ? -1 : 1;
+            if (aVal > bVal)
+                return order === 'asc' ? 1 : -1;
+            return 0;
+        });
+    }
+    shuffle(arr) {
+        const result = [...arr];
+        for (let i = result.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [result[i], result[j]] = [result[j], result[i]];
+        }
+        return result;
+    }
+    sample(arr) {
+        return arr[Math.floor(Math.random() * arr.length)];
+    }
+    intersection(a, b) {
+        return a.filter(x => b.includes(x));
+    }
+    difference(a, b) {
+        return a.filter(x => !b.includes(x));
+    }
+    compact(arr) {
+        return arr.filter(Boolean);
+    }
+    flatten(arr) {
+        return arr.reduce((flat, item) => flat.concat(Array.isArray(item) ? item : item), []);
+    }
+    flattenDeep(arr) {
+        return arr.reduce((flat, item) => flat.concat(Array.isArray(item) ? this.flattenDeep(item) : item), []);
+    }
+    partition(arr, predicate) {
+        const pass = [], fail = [];
+        arr.forEach(item => (predicate(item) ? pass : fail).push(item));
+        return [pass, fail];
+    }
+    pluck(arr, key) {
+        return arr.map(item => item[key]);
+    }
+    first(arr) { return arr[0]; }
+    last(arr) { return arr[arr.length - 1]; }
+    drop(arr, n = 1) { return arr.slice(n); }
+    take(arr, n = 1) { return arr.slice(0, n); }
+    sum(arr) { return arr.reduce((a, b) => a + b, 0); }
+    average(arr) { return arr.length ? this.sum(arr) / arr.length : 0; }
+    min(arr) { return arr.length ? Math.min(...arr) : undefined; }
+    max(arr) { return arr.length ? Math.max(...arr) : undefined; }
+    range(start, end, step = 1) {
+        const result = [];
+        for (let i = start; i < end; i += step)
+            result.push(i);
+        return result;
+    }
+    zip(...arrays) {
+        const maxLen = Math.max(...arrays.map(a => a.length));
+        return Array(maxLen).fill(0).map((_, i) => arrays.map(a => a[i]));
+    }
+    uniqBy(arr, key) {
+        const seen = new Set();
+        return arr.filter(item => { const v = item[key]; if (seen.has(v))
+            return false; seen.add(v); return true; });
+    }
+}
+exports.ArrayUtils = ArrayUtils;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './array';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ts-array-lite",
+  "version": "1.0.0",
+  "description": "Lightweight, type-safe array utility library for web developers",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "keywords": ["utils", "typescript", "array", "helpers", "lite"],
+  "author": "Gaurang Mody - G8X",
+  "license": "MIT"
+}