@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/utils/index.d.ts

@@ -0,0 +1,286 @@
+/**
+ * @module @fluixi/core/utils
+ *
+ * This module provides general utility functions for common operations.
+ */
+/**
+ * Debounces a function call
+ *
+ * @example
+ * ```typescript
+ * import { debounce } from '@fluixi/core/utils';
+ *
+ * const handleInput = debounce((value: string) => {
+ *   console.log('Input:', value);
+ * }, 300);
+ * ```
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Throttles a function call
+ *
+ * @example
+ * ```typescript
+ * import { throttle } from '@fluixi/core/utils';
+ *
+ * const handleScroll = throttle(() => {
+ *   console.log('Scrolled');
+ * }, 100);
+ * ```
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Creates a memoized version of a function
+ *
+ * @example
+ * ```typescript
+ * import { memoize } from '@fluixi/core/utils';
+ *
+ * const expensiveCalc = memoize((n: number) => {
+ *   return n * n;
+ * });
+ * ```
+ */
+export declare function memoize<T extends (...args: any[]) => any>(fn: T): T;
+/**
+ * Deep clones an object
+ *
+ * @example
+ * ```typescript
+ * import { deepClone } from '@fluixi/core/utils';
+ *
+ * const original = { a: 1, b: { c: 2 } };
+ * const copy = deepClone(original);
+ * ```
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Deep merges multiple objects
+ *
+ * @example
+ * ```typescript
+ * import { deepMerge } from '@fluixi/core/utils';
+ *
+ * const result = deepMerge(
+ *   { a: 1, b: { c: 2 } },
+ *   { b: { d: 3 } }
+ * );
+ * // { a: 1, b: { c: 2, d: 3 } }
+ * ```
+ */
+export declare function deepMerge<T extends Record<string, any>>(...objects: Partial<T>[]): T;
+/**
+ * Generates a unique ID
+ *
+ * @example
+ * ```typescript
+ * import { uniqueId } from '@fluixi/core/utils';
+ *
+ * const id = uniqueId('component-');
+ * // 'component-abc123def456'
+ * ```
+ */
+export declare function uniqueId(prefix?: string): string;
+/**
+ * Formats a number with commas
+ *
+ * @example
+ * ```typescript
+ * import { formatNumber } from '@fluixi/core/utils';
+ *
+ * formatNumber(1234567); // '1,234,567'
+ * ```
+ */
+export declare function formatNumber(num: number): string;
+/**
+ * Formats bytes to human readable string
+ *
+ * @example
+ * ```typescript
+ * import { formatBytes } from '@fluixi/core/utils';
+ *
+ * formatBytes(1024); // '1 KB'
+ * formatBytes(1048576); // '1 MB'
+ * ```
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Capitalizes first letter of a string
+ *
+ * @example
+ * ```typescript
+ * import { capitalize } from '@fluixi/core/utils';
+ *
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Converts string to kebab-case
+ *
+ * @example
+ * ```typescript
+ * import { kebabCase } from '@fluixi/core/utils';
+ *
+ * kebabCase('HelloWorld'); // 'hello-world'
+ * ```
+ */
+export declare function kebabCase(str: string): string;
+/**
+ * Converts string to camelCase
+ *
+ * @example
+ * ```typescript
+ * import { camelCase } from '@fluixi/core/utils';
+ *
+ * camelCase('hello-world'); // 'helloWorld'
+ * ```
+ */
+export declare function camelCase(str: string): string;
+/**
+ * Clamps a number between min and max
+ *
+ * @example
+ * ```typescript
+ * import { clamp } from '@fluixi/core/utils';
+ *
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Generates a random number between min and max
+ *
+ * @example
+ * ```typescript
+ * import { random } from '@fluixi/core/utils';
+ *
+ * const num = random(1, 100);
+ * ```
+ */
+export declare function random(min: number, max: number): number;
+/**
+ * Checks if a value is empty
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from '@fluixi/core/utils';
+ *
+ * isEmpty(''); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(null); // true
+ * isEmpty('text'); // false
+ * ```
+ */
+export declare function isEmpty(value: any): boolean;
+/**
+ * Picks specific keys from an object
+ *
+ * @example
+ * ```typescript
+ * import { pick } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * pick(obj, 'a', 'c'); // { a: 1, c: 3 }
+ * ```
+ */
+export declare function pick<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K>;
+/**
+ * Omits specific keys from an object
+ *
+ * @example
+ * ```typescript
+ * import { omit } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * omit(obj, 'b'); // { a: 1, c: 3 }
+ * ```
+ */
+export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
+/**
+ * Groups array items by a key
+ *
+ * @example
+ * ```typescript
+ * import { groupBy } from '@fluixi/core/utils';
+ *
+ * const users = [
+ *   { name: 'Alice', role: 'admin' },
+ *   { name: 'Bob', role: 'user' },
+ *   { name: 'Charlie', role: 'admin' }
+ * ];
+ * const grouped = groupBy(users, u => u.role);
+ * // Map { 'admin' => [...], 'user' => [...] }
+ * ```
+ */
+export declare function groupBy<T, K>(array: T[], fn: (item: T) => K): Map<K, T[]>;
+/**
+ * Creates an array of numbers from start to end
+ *
+ * @example
+ * ```typescript
+ * import { range } from '@fluixi/core/utils';
+ *
+ * range(0, 5); // [0, 1, 2, 3, 4, 5]
+ * range(0, 10, 2); // [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+export declare function range(start: number, end: number, step?: number): number[];
+/**
+ * Retries an async function
+ *
+ * @example
+ * ```typescript
+ * import { retry } from '@fluixi/core/utils';
+ *
+ * const data = await retry(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   3,
+ *   1000
+ * );
+ * ```
+ */
+export declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;
+/**
+ * Sleep for specified milliseconds
+ *
+ * @example
+ * ```typescript
+ * import { sleep } from '@fluixi/core/utils';
+ *
+ * await sleep(1000); // Wait 1 second
+ * ```
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Type guard to check if value is defined
+ *
+ * @example
+ * ```typescript
+ * import { isDefined } from '@fluixi/core/utils';
+ *
+ * const values = [1, null, 2, undefined, 3];
+ * const defined = values.filter(isDefined); // [1, 2, 3]
+ * ```
+ */
+export declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Creates a chainable pipe function
+ *
+ * @example
+ * ```typescript
+ * import { pipe } from '@fluixi/core/utils';
+ *
+ * const transform = pipe(
+ *   (x: number) => x * 2,
+ *   (x: number) => x + 1,
+ *   (x: number) => x.toString()
+ * );
+ * transform(5); // '11'
+ * ```
+ */
+export declare function pipe<T>(...fns: Array<(arg: any) => any>): (arg: T) => any;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/utils/index.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/utils/index.js

@@ -0,0 +1,434 @@
+/**
+ * @module @fluixi/core/utils
+ *
+ * This module provides general utility functions for common operations.
+ */
+/**
+ * Debounces a function call
+ *
+ * @example
+ * ```typescript
+ * import { debounce } from '@fluixi/core/utils';
+ *
+ * const handleInput = debounce((value: string) => {
+ *   console.log('Input:', value);
+ * }, 300);
+ * ```
+ */
+export function debounce(fn, delay) {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => fn(...args), delay);
+    };
+}
+/**
+ * Throttles a function call
+ *
+ * @example
+ * ```typescript
+ * import { throttle } from '@fluixi/core/utils';
+ *
+ * const handleScroll = throttle(() => {
+ *   console.log('Scrolled');
+ * }, 100);
+ * ```
+ */
+export function throttle(fn, limit) {
+    let inThrottle;
+    return (...args) => {
+        if (!inThrottle) {
+            fn(...args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+/**
+ * Creates a memoized version of a function
+ *
+ * @example
+ * ```typescript
+ * import { memoize } from '@fluixi/core/utils';
+ *
+ * const expensiveCalc = memoize((n: number) => {
+ *   return n * n;
+ * });
+ * ```
+ */
+export function memoize(fn) {
+    const cache = new Map();
+    return ((...args) => {
+        const key = JSON.stringify(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    });
+}
+/**
+ * Deep clones an object
+ *
+ * @example
+ * ```typescript
+ * import { deepClone } from '@fluixi/core/utils';
+ *
+ * const original = { a: 1, b: { c: 2 } };
+ * const copy = deepClone(original);
+ * ```
+ */
+export function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return Array.from(obj).map((item) => deepClone(item));
+    }
+    if (obj instanceof Set) {
+        return new Set(Array.from(obj).map((item) => deepClone(item)));
+    }
+    if (obj instanceof Map) {
+        return new Map(Array.from(obj.entries()).map(([key, value]) => [
+            deepClone(key),
+            deepClone(value),
+        ]));
+    }
+    const clonedObj = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            clonedObj[key] = deepClone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Deep merges multiple objects
+ *
+ * @example
+ * ```typescript
+ * import { deepMerge } from '@fluixi/core/utils';
+ *
+ * const result = deepMerge(
+ *   { a: 1, b: { c: 2 } },
+ *   { b: { d: 3 } }
+ * );
+ * // { a: 1, b: { c: 2, d: 3 } }
+ * ```
+ */
+export function deepMerge(...objects) {
+    const result = {};
+    for (const obj of objects) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const value = obj[key];
+                if (value !== null &&
+                    typeof value === 'object' &&
+                    !Array.isArray(value)) {
+                    result[key] = deepMerge(result[key] || {}, value);
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Generates a unique ID
+ *
+ * @example
+ * ```typescript
+ * import { uniqueId } from '@fluixi/core/utils';
+ *
+ * const id = uniqueId('component-');
+ * // 'component-abc123def456'
+ * ```
+ */
+export function uniqueId(prefix = '') {
+    return prefix + Math.random().toString(36).substr(2, 9);
+}
+/**
+ * Formats a number with commas
+ *
+ * @example
+ * ```typescript
+ * import { formatNumber } from '@fluixi/core/utils';
+ *
+ * formatNumber(1234567); // '1,234,567'
+ * ```
+ */
+export function formatNumber(num) {
+    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+/**
+ * Formats bytes to human readable string
+ *
+ * @example
+ * ```typescript
+ * import { formatBytes } from '@fluixi/core/utils';
+ *
+ * formatBytes(1024); // '1 KB'
+ * formatBytes(1048576); // '1 MB'
+ * ```
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+/**
+ * Capitalizes first letter of a string
+ *
+ * @example
+ * ```typescript
+ * import { capitalize } from '@fluixi/core/utils';
+ *
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Converts string to kebab-case
+ *
+ * @example
+ * ```typescript
+ * import { kebabCase } from '@fluixi/core/utils';
+ *
+ * kebabCase('HelloWorld'); // 'hello-world'
+ * ```
+ */
+export function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/**
+ * Converts string to camelCase
+ *
+ * @example
+ * ```typescript
+ * import { camelCase } from '@fluixi/core/utils';
+ *
+ * camelCase('hello-world'); // 'helloWorld'
+ * ```
+ */
+export function camelCase(str) {
+    return str.replace(/[-_\s](.)/g, (_, char) => char.toUpperCase());
+}
+/**
+ * Clamps a number between min and max
+ *
+ * @example
+ * ```typescript
+ * import { clamp } from '@fluixi/core/utils';
+ *
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Generates a random number between min and max
+ *
+ * @example
+ * ```typescript
+ * import { random } from '@fluixi/core/utils';
+ *
+ * const num = random(1, 100);
+ * ```
+ */
+export function random(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Checks if a value is empty
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from '@fluixi/core/utils';
+ *
+ * isEmpty(''); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(null); // true
+ * isEmpty('text'); // false
+ * ```
+ */
+export function 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;
+}
+/**
+ * Picks specific keys from an object
+ *
+ * @example
+ * ```typescript
+ * import { pick } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * pick(obj, 'a', 'c'); // { a: 1, c: 3 }
+ * ```
+ */
+export function pick(obj, ...keys) {
+    const result = {};
+    keys.forEach((key) => {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    });
+    return result;
+}
+/**
+ * Omits specific keys from an object
+ *
+ * @example
+ * ```typescript
+ * import { omit } from '@fluixi/core/utils';
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * omit(obj, 'b'); // { a: 1, c: 3 }
+ * ```
+ */
+export function omit(obj, ...keys) {
+    const result = { ...obj };
+    keys.forEach((key) => {
+        delete result[key];
+    });
+    return result;
+}
+/**
+ * Groups array items by a key
+ *
+ * @example
+ * ```typescript
+ * import { groupBy } from '@fluixi/core/utils';
+ *
+ * const users = [
+ *   { name: 'Alice', role: 'admin' },
+ *   { name: 'Bob', role: 'user' },
+ *   { name: 'Charlie', role: 'admin' }
+ * ];
+ * const grouped = groupBy(users, u => u.role);
+ * // Map { 'admin' => [...], 'user' => [...] }
+ * ```
+ */
+export function groupBy(array, fn) {
+    return array.reduce((acc, item) => {
+        const key = fn(item);
+        const group = acc.get(key) || [];
+        group.push(item);
+        acc.set(key, group);
+        return acc;
+    }, new Map());
+}
+/**
+ * Creates an array of numbers from start to end
+ *
+ * @example
+ * ```typescript
+ * import { range } from '@fluixi/core/utils';
+ *
+ * range(0, 5); // [0, 1, 2, 3, 4, 5]
+ * range(0, 10, 2); // [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+export function range(start, end, step = 1) {
+    const result = [];
+    for (let i = start; i <= end; i += step) {
+        result.push(i);
+    }
+    return result;
+}
+/**
+ * Retries an async function
+ *
+ * @example
+ * ```typescript
+ * import { retry } from '@fluixi/core/utils';
+ *
+ * const data = await retry(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   3,
+ *   1000
+ * );
+ * ```
+ */
+export async function retry(fn, retries = 3, delay = 1000) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (retries <= 0)
+            throw error;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return retry(fn, retries - 1, delay);
+    }
+}
+/**
+ * Sleep for specified milliseconds
+ *
+ * @example
+ * ```typescript
+ * import { sleep } from '@fluixi/core/utils';
+ *
+ * await sleep(1000); // Wait 1 second
+ * ```
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Type guard to check if value is defined
+ *
+ * @example
+ * ```typescript
+ * import { isDefined } from '@fluixi/core/utils';
+ *
+ * const values = [1, null, 2, undefined, 3];
+ * const defined = values.filter(isDefined); // [1, 2, 3]
+ * ```
+ */
+export function isDefined(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Creates a chainable pipe function
+ *
+ * @example
+ * ```typescript
+ * import { pipe } from '@fluixi/core/utils';
+ *
+ * const transform = pipe(
+ *   (x: number) => x * 2,
+ *   (x: number) => x + 1,
+ *   (x: number) => x.toString()
+ * );
+ * transform(5); // '11'
+ * ```
+ */
+export function pipe(...fns) {
+    return (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+}