t1s-utils-lite 0.0.1

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/cookie.d.ts

@@ -0,0 +1,8 @@
+export declare class CookieUtils {
+    set(key: string, value: string, days?: number, path?: string): void;
+    get(key: string): string | null;
+    has(key: string): boolean;
+    delete(key: string, path?: string): void;
+    clear(): void;
+    all(): Record<string, string>;
+}

package/dist/cookie.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieUtils = void 0;
+class CookieUtils {
+    set(key, value, days = 7, path = '/') {
+        const expires = new Date(Date.now() + days * 864e5).toUTCString();
+        document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)};expires=${expires};path=${path}`;
+    }
+    get(key) {
+        const cookies = document.cookie.split(';');
+        for (const cookie of cookies) {
+            const [cookieKey, ...valParts] = cookie.trim().split('=');
+            if (decodeURIComponent(cookieKey) === key) {
+                return decodeURIComponent(valParts.join('='));
+            }
+        }
+        return null;
+    }
+    has(key) {
+        return this.get(key) !== null;
+    }
+    delete(key, path = '/') {
+        document.cookie = `${encodeURIComponent(key)}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path}`;
+    }
+    clear() {
+        const cookies = document.cookie.split(';');
+        for (const cookie of cookies) {
+            const key = cookie.trim().split('=')[0];
+            this.delete(decodeURIComponent(key));
+        }
+    }
+    all() {
+        const result = {};
+        const cookies = document.cookie.split(';');
+        for (const cookie of cookies) {
+            const [cookieKey, ...valParts] = cookie.trim().split('=');
+            const key = decodeURIComponent(cookieKey);
+            const value = decodeURIComponent(valParts.join('='));
+            result[key] = value;
+        }
+        return result;
+    }
+}
+exports.CookieUtils = CookieUtils;

package/dist/date.d.ts

@@ -0,0 +1,15 @@
+export declare class DateUtils {
+    format(date: Date, formatStr: string): string;
+    relative(date: Date): string;
+    isToday(date: Date): boolean;
+    add(date: Date, amount: number, unit: 'day' | 'month' | 'year'): Date;
+    diff(d1: Date, d2: Date): number;
+    startOf(date: Date, unit: 'day' | 'month' | 'year'): Date;
+    endOf(date: Date, unit: 'day' | 'month' | 'year'): Date;
+    isBefore(d1: Date, d2: Date): boolean;
+    isAfter(d1: Date, d2: Date): boolean;
+    isSame(d1: Date, d2: Date): boolean;
+    parse(dateStr: string): Date | null;
+    now(): number;
+    timestamp(): number;
+}

package/dist/date.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateUtils = void 0;
+class DateUtils {
+    format(date, formatStr) {
+        const d = new Date(date);
+        const pad = (n) => n.toString().padStart(2, '0');
+        const year = d.getFullYear();
+        const month = pad(d.getMonth() + 1);
+        const day = pad(d.getDate());
+        const hours = pad(d.getHours());
+        const minutes = pad(d.getMinutes());
+        const seconds = pad(d.getSeconds());
+        return formatStr
+            .replace('YYYY', String(year))
+            .replace('MM', month)
+            .replace('DD', day)
+            .replace('HH', hours)
+            .replace('mm', minutes)
+            .replace('ss', seconds);
+    }
+    relative(date) {
+        const now = Date.now();
+        const diff = now - new Date(date).getTime();
+        const seconds = Math.floor(diff / 1000);
+        if (seconds < 60)
+            return `${seconds} seconds ago`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60)
+            return `${minutes} minutes ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24)
+            return `${hours} hours ago`;
+        const days = Math.floor(hours / 24);
+        if (days < 30)
+            return `${days} days ago`;
+        const months = Math.floor(days / 30);
+        if (months < 12)
+            return `${months} months ago`;
+        return `${Math.floor(days / 365)} years ago`;
+    }
+    isToday(date) {
+        const d = new Date(date);
+        const today = new Date();
+        return d.getDate() === today.getDate() && d.getMonth() === today.getMonth() && d.getFullYear() === today.getFullYear();
+    }
+    add(date, amount, unit) {
+        const d = new Date(date);
+        if (unit === 'day')
+            d.setDate(d.getDate() + amount);
+        else if (unit === 'month')
+            d.setMonth(d.getMonth() + amount);
+        else
+            d.setFullYear(d.getFullYear() + amount);
+        return d;
+    }
+    diff(d1, d2) {
+        return Math.floor((new Date(d1).getTime() - new Date(d2).getTime()) / (1000 * 60 * 60 * 24));
+    }
+    startOf(date, unit) {
+        const d = new Date(date);
+        if (unit === 'day')
+            d.setHours(0, 0, 0, 0);
+        else if (unit === 'month')
+            d.setDate(1);
+        else
+            d.setMonth(0, 1);
+        return d;
+    }
+    endOf(date, unit) {
+        const d = this.startOf(date, unit);
+        if (unit === 'day')
+            d.setHours(23, 59, 59, 999);
+        else if (unit === 'month')
+            d.setMonth(d.getMonth() + 1, 0);
+        else
+            d.setFullYear(d.getFullYear() + 1, 0, 0);
+        return d;
+    }
+    isBefore(d1, d2) { return new Date(d1).getTime() < new Date(d2).getTime(); }
+    isAfter(d1, d2) { return new Date(d1).getTime() > new Date(d2).getTime(); }
+    isSame(d1, d2) { return this.isBefore(d1, d2) === false && this.isAfter(d1, d2) === false; }
+    parse(dateStr) {
+        const d = new Date(dateStr);
+        return isNaN(d.getTime()) ? null : d;
+    }
+    now() { return Date.now(); }
+    timestamp() { return Date.now(); }
+}
+exports.DateUtils = DateUtils;

package/dist/id.d.ts

@@ -0,0 +1,10 @@
+export declare class IdUtils {
+    private readonly base36Chars;
+    uuid(): string;
+    nanoid(size?: number): string;
+    shortId(length?: number): string;
+    snowflake(): string;
+    hash(input: string): string;
+    generateCode(length?: number, charset?: 'numeric' | 'alpha' | 'alphanumeric'): string;
+    generateToken(length?: number): string;
+}

package/dist/id.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdUtils = void 0;
+class IdUtils {
+    constructor() {
+        this.base36Chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+    }
+    uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    nanoid(size = 21) {
+        const bytes = new Uint8Array(size);
+        crypto.getRandomValues(bytes);
+        return Array.from(bytes, b => this.base36Chars[b & 63]).join('');
+    }
+    shortId(length = 10) {
+        return this.nanoid(length).replace(/[_=-]/g, '');
+    }
+    snowflake() {
+        const timestamp = BigInt(Date.now() - 1700000000000);
+        const machineId = BigInt(Math.floor(Math.random() * 1024));
+        const sequence = BigInt(Math.floor(Math.random() * 4096));
+        const id = (timestamp << 22n) | (machineId << 12n) | sequence;
+        return id.toString();
+    }
+    hash(input) {
+        let hash = 0;
+        for (let i = 0; i < input.length; i++) {
+            const char = input.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+    generateCode(length = 6, charset = 'numeric') {
+        const charsets = {
+            numeric: '0123456789',
+            alpha: 'abcdefghijklmnopqrstuvwxyz',
+            alphanumeric: '0123456789abcdefghijklmnopqrstuvwxyz'
+        };
+        const chars = charsets[charset];
+        return Array(length).fill(0).map(() => chars[Math.floor(Math.random() * chars.length)]).join('');
+    }
+    generateToken(length = 32) {
+        const bytes = new Uint8Array(length);
+        crypto.getRandomValues(bytes);
+        return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+    }
+}
+exports.IdUtils = IdUtils;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { StringUtils } from './string';
+import { ArrayUtils } from './array';
+import { ObjectUtils } from './object';
+import { DateUtils } from './date';
+import { NumberUtils } from './number';
+import { ValidationUtils } from './validation';
+import { IdUtils } from './id';
+import { CookieUtils } from './cookie';
+export * from './string';
+export * from './array';
+export * from './object';
+export * from './date';
+export * from './number';
+export * from './validation';
+export * from './id';
+export * from './cookie';
+export { StringUtils, ArrayUtils, ObjectUtils, DateUtils, NumberUtils, ValidationUtils, IdUtils, CookieUtils };
+export declare const Utils: {
+    string: typeof StringUtils;
+    array: typeof ArrayUtils;
+    object: typeof ObjectUtils;
+    date: typeof DateUtils;
+    number: typeof NumberUtils;
+    validation: typeof ValidationUtils;
+    id: typeof IdUtils;
+    cookie: typeof CookieUtils;
+};
+export default Utils;

package/dist/index.js

@@ -0,0 +1,52 @@
+"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 });
+exports.Utils = exports.CookieUtils = exports.IdUtils = exports.ValidationUtils = exports.NumberUtils = exports.DateUtils = exports.ObjectUtils = exports.ArrayUtils = exports.StringUtils = void 0;
+const string_1 = require("./string");
+Object.defineProperty(exports, "StringUtils", { enumerable: true, get: function () { return string_1.StringUtils; } });
+const array_1 = require("./array");
+Object.defineProperty(exports, "ArrayUtils", { enumerable: true, get: function () { return array_1.ArrayUtils; } });
+const object_1 = require("./object");
+Object.defineProperty(exports, "ObjectUtils", { enumerable: true, get: function () { return object_1.ObjectUtils; } });
+const date_1 = require("./date");
+Object.defineProperty(exports, "DateUtils", { enumerable: true, get: function () { return date_1.DateUtils; } });
+const number_1 = require("./number");
+Object.defineProperty(exports, "NumberUtils", { enumerable: true, get: function () { return number_1.NumberUtils; } });
+const validation_1 = require("./validation");
+Object.defineProperty(exports, "ValidationUtils", { enumerable: true, get: function () { return validation_1.ValidationUtils; } });
+const id_1 = require("./id");
+Object.defineProperty(exports, "IdUtils", { enumerable: true, get: function () { return id_1.IdUtils; } });
+const cookie_1 = require("./cookie");
+Object.defineProperty(exports, "CookieUtils", { enumerable: true, get: function () { return cookie_1.CookieUtils; } });
+__exportStar(require("./string"), exports);
+__exportStar(require("./array"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./id"), exports);
+__exportStar(require("./cookie"), exports);
+exports.Utils = {
+    string: string_1.StringUtils,
+    array: array_1.ArrayUtils,
+    object: object_1.ObjectUtils,
+    date: date_1.DateUtils,
+    number: number_1.NumberUtils,
+    validation: validation_1.ValidationUtils,
+    id: id_1.IdUtils,
+    cookie: cookie_1.CookieUtils,
+};
+exports.default = exports.Utils;

package/dist/number.d.ts

@@ -0,0 +1,26 @@
+export declare class NumberUtils {
+    formatCurrency(value: number, currency?: string, locale?: string): string;
+    formatBytes(bytes: number, decimals?: number): string;
+    formatPercent(value: number, decimals?: number): string;
+    clamp(value: number, min: number, max: number): number;
+    round(value: number, decimals?: number): number;
+    randomInt(min: number, max: number): number;
+    randomFloat(min: number, max: number): number;
+    isEven(n: number): boolean;
+    isOdd(n: number): boolean;
+    isPositive(n: number): boolean;
+    isNegative(n: number): boolean;
+    isInteger(n: number): boolean;
+    isNaN(n: number): boolean;
+    isFinite(n: number): boolean;
+    abs(n: number): number;
+    floor(n: number): number;
+    ceil(n: number): number;
+    sqrt(n: number): number;
+    pow(n: number, exp: number): number;
+    sum(...nums: number[]): number;
+    avg(...nums: number[]): number;
+    min(...nums: number[]): number;
+    max(...nums: number[]): number;
+    range(start: number, end: number, step?: number): number[];
+}

package/dist/number.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberUtils = void 0;
+class NumberUtils {
+    formatCurrency(value, currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(value);
+    }
+    formatBytes(bytes, decimals = 2) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + ' ' + sizes[i];
+    }
+    formatPercent(value, decimals = 2) {
+        return (value * 100).toFixed(decimals) + '%';
+    }
+    clamp(value, min, max) {
+        return Math.min(Math.max(value, min), max);
+    }
+    round(value, decimals = 0) {
+        const factor = Math.pow(10, decimals);
+        return Math.round(value * factor) / factor;
+    }
+    randomInt(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    randomFloat(min, max) {
+        return Math.random() * (max - min) + min;
+    }
+    isEven(n) { return n % 2 === 0; }
+    isOdd(n) { return n % 2 !== 0; }
+    isPositive(n) { return n > 0; }
+    isNegative(n) { return n < 0; }
+    isInteger(n) { return Number.isInteger(n); }
+    isNaN(n) { return Number.isNaN(n); }
+    isFinite(n) { return Number.isFinite(n); }
+    abs(n) { return Math.abs(n); }
+    floor(n) { return Math.floor(n); }
+    ceil(n) { return Math.ceil(n); }
+    sqrt(n) { return Math.sqrt(n); }
+    pow(n, exp) { return Math.pow(n, exp); }
+    sum(...nums) { return nums.reduce((a, b) => a + b, 0); }
+    avg(...nums) { return nums.length ? this.sum(...nums) / nums.length : 0; }
+    min(...nums) { return Math.min(...nums); }
+    max(...nums) { return Math.max(...nums); }
+    range(start, end, step = 1) {
+        const result = [];
+        for (let i = start; i < end; i += step)
+            result.push(i);
+        return result;
+    }
+}
+exports.NumberUtils = NumberUtils;

package/dist/object.d.ts

@@ -0,0 +1,18 @@
+export declare class ObjectUtils {
+    deepGet(obj: unknown, path: string, defaultValue?: unknown): unknown;
+    deepSet(obj: Record<string, unknown>, path: string, value: unknown): void;
+    deepClone<T>(obj: T): T;
+    merge<T extends Record<string, unknown>>(target: T, ...sources: (Partial<T> | undefined | null)[]): T;
+    omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+    pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+    isEmpty(value: unknown): boolean;
+    isEqual(a: unknown, b: unknown): boolean;
+    keys(obj: Record<string, unknown>): string[];
+    values(obj: Record<string, unknown>): unknown[];
+    entries(obj: Record<string, unknown>): [string, unknown][];
+    has(obj: Record<string, unknown>, path: string): boolean;
+    size(obj: Record<string, unknown>): number;
+    mapValues(obj: Record<string, unknown>, fn: (v: unknown, k: string) => unknown): Record<string, unknown>;
+    invert(obj: Record<string, string>): Record<string, string>;
+    clone<T>(obj: T): T;
+}

package/dist/object.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectUtils = void 0;
+class ObjectUtils {
+    deepGet(obj, path, defaultValue) {
+        if (!obj || !path)
+            return defaultValue;
+        const keys = path.split('.');
+        let result = obj;
+        for (const key of keys) {
+            if (result === null || result === undefined)
+                return defaultValue;
+            result = result[key];
+        }
+        return result ?? defaultValue;
+    }
+    deepSet(obj, path, value) {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in current) || current[keys[i]] === null)
+                current[keys[i]] = {};
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    deepClone(obj) {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        if (obj instanceof Date)
+            return new Date(obj.getTime());
+        if (Array.isArray(obj))
+            return obj.map(item => this.deepClone(item));
+        const cloned = {};
+        for (const key in obj)
+            cloned[key] = this.deepClone(obj[key]);
+        return cloned;
+    }
+    merge(target, ...sources) {
+        for (const source of sources) {
+            if (!source)
+                continue;
+            for (const key of Object.keys(source)) {
+                const tv = target[key], sv = source[key];
+                if (tv && typeof tv === 'object' && sv && typeof sv === 'object' && !Array.isArray(tv) && !Array.isArray(sv)) {
+                    target[key] = this.merge(tv, sv);
+                }
+                else {
+                    target[key] = sv;
+                }
+            }
+        }
+        return target;
+    }
+    omit(obj, keys) {
+        const result = { ...obj };
+        keys.forEach(k => delete result[k]);
+        return result;
+    }
+    pick(obj, keys) {
+        const result = {};
+        keys.forEach(k => { if (k in obj)
+            result[k] = obj[k]; });
+        return result;
+    }
+    isEmpty(value) {
+        if (value === null || value === undefined)
+            return true;
+        if (typeof value === 'string')
+            return value.trim().length === 0;
+        if (Array.isArray(value))
+            return value.length === 0;
+        if (typeof value === 'object')
+            return Object.keys(value).length === 0;
+        return false;
+    }
+    isEqual(a, b) {
+        if (a === b)
+            return true;
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object')
+            return false;
+        const ak = Object.keys(a), bk = Object.keys(b);
+        return ak.length === bk.length && ak.every(k => this.isEqual(a[k], b[k]));
+    }
+    keys(obj) { return Object.keys(obj); }
+    values(obj) { return Object.values(obj); }
+    entries(obj) { return Object.entries(obj); }
+    has(obj, path) { return this.deepGet(obj, path) !== undefined; }
+    size(obj) { return Object.keys(obj).length; }
+    mapValues(obj, fn) {
+        const result = {};
+        for (const k of Object.keys(obj))
+            result[k] = fn(obj[k], k);
+        return result;
+    }
+    invert(obj) {
+        const result = {};
+        for (const k of Object.keys(obj))
+            result[obj[k]] = k;
+        return result;
+    }
+    clone(obj) { return this.deepClone(obj); }
+}
+exports.ObjectUtils = ObjectUtils;

package/dist/string.d.ts

@@ -0,0 +1,23 @@
+export declare class StringUtils {
+    private readonly _html_escape_map;
+    slugify(input_text: string): string;
+    truncate(input_text: string, max_length: number, suffix?: string): string;
+    capitalize(input_text: string): string;
+    titleCase(input_text: string): string;
+    camelCase(input_text: string): string;
+    kebabCase(input_text: string): string;
+    snakeCase(input_text: string): string;
+    pascalCase(input_text: string): string;
+    escapeHtml(input_text: string): string;
+    unescapeHtml(input_text: string): string;
+    repeat(input_text: string, times: number): string;
+    reverse(input_text: string): string;
+    base64Encode(input_text: string): string;
+    base64Decode(encoded: string): string;
+    randomString(length: number): string;
+    trimStart(text: string, chars?: string): string;
+    trimEnd(text: string, chars?: string): string;
+    words(text: string, delimiter?: RegExp): string[];
+    countWords(text: string): number;
+    levenshtein(a: string, b: string): number;
+}

package/dist/string.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUtils = void 0;
+class StringUtils {
+    constructor() {
+        this._html_escape_map = {
+            '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+        };
+    }
+    slugify(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.toLowerCase().trim()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/[\s_-]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    truncate(input_text, max_length, suffix = '...') {
+        if (!input_text || input_text.length <= max_length)
+            return input_text;
+        return input_text.slice(0, max_length - suffix.length) + suffix;
+    }
+    capitalize(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.charAt(0).toUpperCase() + input_text.slice(1).toLowerCase();
+    }
+    titleCase(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+    }
+    camelCase(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase()).replace(/[\s_-]+/g, '');
+    }
+    kebabCase(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase();
+    }
+    snakeCase(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/([a-z])([A-Z])/g, '$1_$2').replace(/[\s-]+/g, '_').toLowerCase();
+    }
+    pascalCase(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase()).replace(/[\s_-]+/g, '');
+    }
+    escapeHtml(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/[&<>"']/g, (m) => this._html_escape_map[m] || m);
+    }
+    unescapeHtml(input_text) {
+        if (!input_text)
+            return '';
+        return input_text.replace(/&(amp|lt|gt|quot|#39);/g, (m) => this._html_escape_map[m] || m);
+    }
+    repeat(input_text, times) {
+        return input_text.repeat(Math.max(0, times));
+    }
+    reverse(input_text) {
+        return input_text.split('').reverse().join('');
+    }
+    base64Encode(input_text) {
+        return btoa(unescape(encodeURIComponent(input_text)));
+    }
+    base64Decode(encoded) {
+        try {
+            return decodeURIComponent(escape(atob(encoded)));
+        }
+        catch {
+            return '';
+        }
+    }
+    randomString(length) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        return Array(length).fill(0).map(() => chars[Math.floor(Math.random() * chars.length)]).join('');
+    }
+    trimStart(text, chars) {
+        return chars ? text.replace(new RegExp(`^[${chars}]+`, 'g'), '') : text.trimStart();
+    }
+    trimEnd(text, chars) {
+        return chars ? text.replace(new RegExp(`[${chars}]+$`, 'g'), '') : text.trimEnd();
+    }
+    words(text, delimiter = /\s+/) {
+        return text.split(delimiter).filter(Boolean);
+    }
+    countWords(text) {
+        return this.words(text).length;
+    }
+    levenshtein(a, b) {
+        if (!a || !b)
+            return Math.max(a?.length || 0, b?.length || 0);
+        const matrix = Array(b.length + 1).fill(null).map(() => Array(a.length + 1).fill(0));
+        for (let i = 0; i <= a.length; i++)
+            matrix[0][i] = i;
+        for (let j = 0; j <= b.length; j++)
+            matrix[j][0] = j;
+        for (let j = 1; j <= b.length; j++) {
+            for (let i = 1; i <= a.length; i++) {
+                matrix[j][i] = Math.min(matrix[j][i - 1] + 1, matrix[j - 1][i] + 1, matrix[j - 1][i - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+}
+exports.StringUtils = StringUtils;

package/dist/validation.d.ts

@@ -0,0 +1,21 @@
+export declare class ValidationUtils {
+    private readonly emailRegex;
+    private readonly urlRegex;
+    private readonly phoneRegex;
+    private readonly postalCodeRegex;
+    isEmail(value: string): boolean;
+    isUrl(value: string): boolean;
+    isPhone(value: string): boolean;
+    isPostalCode(value: string): boolean;
+    isStrongPassword(password: string): {
+        valid: boolean;
+        score: number;
+        issues: string[];
+    };
+    isNumeric(value: string): boolean;
+    isAlpha(value: string): boolean;
+    isAlphanumeric(value: string): boolean;
+    isDate(value: string): boolean;
+    isJSON(value: string): boolean;
+    isCreditCard(value: string): boolean;
+}

package/dist/validation.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationUtils = void 0;
+class ValidationUtils {
+    constructor() {
+        this.emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        this.urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/;
+        this.phoneRegex = /^\+?[\d\s\-()]{10,}$/;
+        this.postalCodeRegex = /^\d{5}(-\d{4})?$/;
+    }
+    isEmail(value) {
+        return this.emailRegex.test(value);
+    }
+    isUrl(value) {
+        return this.urlRegex.test(value);
+    }
+    isPhone(value) {
+        return this.phoneRegex.test(value);
+    }
+    isPostalCode(value) {
+        return this.postalCodeRegex.test(value);
+    }
+    isStrongPassword(password) {
+        const issues = [];
+        let score = 0;
+        if (password.length >= 8)
+            score++;
+        else
+            issues.push('Min 8 characters');
+        if (/[a-z]/.test(password))
+            score++;
+        else
+            issues.push('Lowercase letter');
+        if (/[A-Z]/.test(password))
+            score++;
+        else
+            issues.push('Uppercase letter');
+        if (/[0-9]/.test(password))
+            score++;
+        else
+            issues.push('Number');
+        if (/[^a-zA-Z0-9]/.test(password))
+            score++;
+        else
+            issues.push('Special character');
+        return { valid: score >= 4, score, issues };
+    }
+    isNumeric(value) {
+        return /^\d+$/.test(value);
+    }
+    isAlpha(value) {
+        return /^[a-zA-Z]+$/.test(value);
+    }
+    isAlphanumeric(value) {
+        return /^[a-zA-Z0-9]+$/.test(value);
+    }
+    isDate(value) {
+        return !isNaN(Date.parse(value));
+    }
+    isJSON(value) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isCreditCard(value) {
+        const cleaned = value.replace(/\s/g, '');
+        if (!/^\d{13,19}$/.test(cleaned))
+            return false;
+        let sum = 0;
+        let isEven = false;
+        for (let i = cleaned.length - 1; i >= 0; i--) {
+            let digit = parseInt(cleaned[i]);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    }
+}
+exports.ValidationUtils = ValidationUtils;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "t1s-utils-lite",
+  "version": "0.0.1",
+  "description": "Lightweight, type-safe 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", "javascript", "helpers", "lodash", "underscore"],
+  "author": "Gaurang Mody - G8X",
+  "license": "MIT"
+}