@umituz/react-native-design-system 4.25.99 → 4.25.101

package/dist/responsive/validation.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Input Validation Utilities
+ *
+ * Centralized validation for all responsive utility functions.
+ * Ensures type safety and prevents runtime errors.
+ */
+/**
+ * Custom error class for responsive utilities
+ */
+export declare class ResponsiveValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates a numeric input parameter
+ * @param value - The value to validate
+ * @param paramName - Parameter name for error messages
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @throws ResponsiveValidationError if validation fails
+ */
+export declare const validateNumber: (value: number | undefined, paramName: string, min?: number, max?: number) => number;
+/**
+ * Validates font size input
+ * @param fontSize - Font size to validate
+ * @param paramName - Parameter name for error messages
+ * @returns Validated font size
+ */
+export declare const validateFontSize: (fontSize: number, paramName?: string) => number;
+/**
+ * Validates screen dimensions
+ * @param width - Screen width
+ * @param height - Screen height
+ * @throws ResponsiveValidationError if validation fails
+ */
+export declare const validateScreenDimensions: (width: number, height: number) => void;
+/**
+ * Validates safe area insets
+ * @param insets - Safe area insets object
+ * @throws ResponsiveValidationError if validation fails
+ */
+export declare const validateSafeAreaInsets: (insets: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}) => void;
+/**
+ * Validates grid column parameters
+ * @param mobileColumns - Number of columns for mobile
+ * @param tabletColumns - Number of columns for tablet
+ * @throws ResponsiveValidationError if validation fails
+ */
+export declare const validateGridColumns: (mobileColumns?: number, tabletColumns?: number) => void;
+/**
+ * Clamps a value between min and max bounds
+ * @param value - Value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * Safely calculates a percentage of a value
+ * @param value - Base value
+ * @param percentage - Percentage (0-1)
+ * @returns Calculated percentage
+ */
+export declare const safePercentage: (value: number, percentage: number) => number;

package/dist/safe-area/constants/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Constants for safe area calculations
+ */
+export declare const SAFE_AREA_DEFAULTS: {
+    readonly MIN_HEADER_PADDING: 0;
+    readonly MIN_CONTENT_PADDING: 0;
+    readonly MIN_STATUS_BAR_PADDING: 0;
+    readonly ADDITIONAL_PADDING: 0;
+};
+export declare const PLATFORM_BEHAVIORS: {
+    readonly IOS_STATUS_BAR_USES_SAFE_AREA: true;
+};
+/**
+ * Default configuration that can be overridden by applications
+ */
+export declare const DEFAULT_CONFIG: {
+    readonly minHeaderPadding: 0;
+    readonly minContentPadding: 0;
+    readonly minStatusBarPadding: 0;
+    readonly additionalPadding: 0;
+    readonly iosStatusBarUsesSafeArea: true;
+};

package/dist/safe-area/hooks/useSafeAreaInsets.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useSafeAreaInsets Hook
+ * Get safe area insets
+ */
+import { useSafeAreaInsets as useNativeSafeAreaInsets } from 'react-native-safe-area-context';
+export declare const useSafeAreaInsets: typeof useNativeSafeAreaInsets;

package/dist/safe-area/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Safe Area Module
+ * Refactored: Simplified to only provide essential safe area utilities.
+ *
+ * We use manual inset management in ScreenLayout for maximum stability
+ * across different React Native versions and devices.
+ */
+export { useSafeAreaInsets } from './hooks/useSafeAreaInsets';
+export { SafeAreaProvider, initialWindowMetrics, SafeAreaView } from 'react-native-safe-area-context';
+export type { Edge, SafeAreaProviderProps } from 'react-native-safe-area-context';

package/dist/storage/__tests__/mocks/asyncStorage.mock.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AsyncStorage Mock
+ *
+ * Mock implementation for testing
+ */
+export declare class AsyncStorageMock {
+    private storage;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    getAllKeys(): Promise<readonly string[]>;
+    multiGet(keys: readonly string[]): Promise<readonly (readonly [string, string | null])[]>;
+    __clear(): void;
+    __size(): number;
+    __has(key: string): boolean;
+    __get(key: string): string | undefined;
+}
+export declare const AsyncStorage: AsyncStorageMock;

package/dist/storage/__tests__/setup.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Test Setup
+ *
+ * Global test configuration and mocks
+ */
+import 'jest-environment-jsdom';
+export declare const mockPerformance: () => {
+    now: jest.Mock<number, [], any>;
+    mark: jest.Mock<any, any, any>;
+    measure: jest.Mock<any, any, any>;
+};
+export declare const trackMemoryUsage: () => {
+    addListener: (listener: () => void) => () => boolean;
+    getListenerCount: () => number;
+    cleanup: () => void;
+};

package/dist/storage/application/ports/IStorageRepository.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Storage Repository Interface (Port)
+ *
+ * Domain-Driven Design: Application port for storage operations
+ * Infrastructure layer implements this interface
+ */
+import type { StorageResult } from '../../domain/entities/StorageResult';
+/**
+ * Storage Repository Interface
+ * Defines contract for storage operations
+ */
+export interface IStorageRepository {
+    /**
+     * Get item from storage with JSON parsing
+     */
+    getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>>;
+    /**
+     * Set item in storage with JSON serialization
+     */
+    setItem<T>(key: string, value: T): Promise<StorageResult<T>>;
+    /**
+     * Get string value (no JSON parsing)
+     */
+    getString(key: string, defaultValue: string): Promise<StorageResult<string>>;
+    /**
+     * Set string value (no JSON serialization)
+     */
+    setString(key: string, value: string): Promise<StorageResult<string>>;
+    /**
+     * Remove item from storage
+     */
+    removeItem(key: string): Promise<StorageResult<void>>;
+    /**
+     * Check if key exists in storage
+     */
+    hasItem(key: string): Promise<boolean>;
+    /**
+     * Clear all storage data
+     */
+    clearAll(): Promise<StorageResult<void>>;
+    /**
+     * Get multiple items at once
+     */
+    getMultiple(keys: string[]): Promise<StorageResult<Record<string, string | null>>>;
+    /**
+     * Get all keys from storage
+     */
+    getAllKeys(): Promise<StorageResult<string[]>>;
+}

package/dist/storage/cache/__tests__/setup.d.ts

@@ -0,0 +1,3 @@
+/**
+ * Test Setup
+ */

package/dist/storage/cache/domain/Cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * In-Memory Cache
+ */
+import type { CacheEntry, CacheConfig, CacheStats } from './types/Cache';
+import { CacheStatsTracker } from './CacheStatsTracker';
+export declare class Cache<T = unknown> {
+    protected store: Map<string, CacheEntry<T>>;
+    private config;
+    protected statsTracker: CacheStatsTracker;
+    private strategies;
+    constructor(config?: CacheConfig);
+    set(key: string, value: T, ttl?: number): void;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    invalidatePattern(pattern: string): number;
+    clear(): void;
+    getStats(): CacheStats;
+    keys(): string[];
+    private isExpired;
+    private evictOne;
+}

package/dist/storage/cache/domain/CacheManager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cache Manager
+ * Manages multiple cache instances
+ */
+import { Cache } from './Cache';
+import type { CacheConfig } from './types/Cache';
+export declare class CacheManager {
+    private static instance;
+    private caches;
+    private constructor();
+    static getInstance(): CacheManager;
+    getCache<T>(name: string, config?: CacheConfig): Cache<T>;
+    deleteCache(name: string): boolean;
+    clearAll(): void;
+    getCacheNames(): string[];
+}
+export declare const cacheManager: CacheManager;

package/dist/storage/cache/domain/CacheStatsTracker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cache Statistics Tracker
+ */
+import type { CacheStats } from './types/Cache';
+export declare class CacheStatsTracker {
+    private stats;
+    recordHit(): void;
+    recordMiss(): void;
+    recordEviction(): void;
+    recordExpiration(): void;
+    updateSize(size: number): void;
+    getStats(): CacheStats;
+    reset(): void;
+}

package/dist/storage/cache/domain/ErrorHandler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Error Handler for Cache Operations
+ */
+export declare class CacheError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class ErrorHandler {
+    static handle(error: unknown, context: string): never;
+    static withTimeout<T>(promise: Promise<T>, timeoutMs: number, context: string): Promise<T>;
+}

package/dist/storage/cache/domain/PatternMatcher.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pattern Matcher for Cache Keys
+ */
+export declare class PatternMatcher {
+    static convertPatternToRegex(pattern: string): RegExp;
+    static matchesPattern(key: string, pattern: string): boolean;
+    static clearCache(): void;
+}

package/dist/storage/cache/domain/strategies/EvictionStrategy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Eviction Strategy Interface
+ */
+import type { CacheEntry } from '../types/Cache';
+export interface EvictionStrategy<T> {
+    findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/dist/storage/cache/domain/strategies/FIFOStrategy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * FIFO (First In First Out) Eviction Strategy
+ */
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+export declare class FIFOStrategy<T> implements EvictionStrategy<T> {
+    findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/dist/storage/cache/domain/strategies/LFUStrategy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LFU (Least Frequently Used) Eviction Strategy
+ */
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+export declare class LFUStrategy<T> implements EvictionStrategy<T> {
+    findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/dist/storage/cache/domain/strategies/LRUStrategy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LRU (Least Recently Used) Eviction Strategy
+ */
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+export declare class LRUStrategy<T> implements EvictionStrategy<T> {
+    findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/dist/storage/cache/domain/strategies/TTLStrategy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TTL (Time To Live) Eviction Strategy
+ */
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+export declare class TTLStrategy<T> implements EvictionStrategy<T> {
+    findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/dist/storage/cache/domain/types/Cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Cache Types
+ */
+export interface CacheEntry<T> {
+    value: T;
+    timestamp: number;
+    ttl: number;
+    accessCount: number;
+    lastAccess: number;
+}
+export interface CacheConfig {
+    maxSize?: number;
+    defaultTTL?: number;
+    onEvict?: (key: string, entry: CacheEntry<unknown>) => void;
+    onExpire?: (key: string, entry: CacheEntry<unknown>) => void;
+}
+export interface CacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    evictions: number;
+    expirations: number;
+}
+export type EvictionStrategy = 'lru' | 'lfu' | 'fifo' | 'ttl';

package/dist/storage/cache/infrastructure/TTLCache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TTL Cache
+ * Time-to-live cache with automatic cleanup
+ */
+import { Cache } from '../domain/Cache';
+import type { CacheConfig } from '../domain/types/Cache';
+export declare class TTLCache<T = unknown> extends Cache<T> {
+    private cleanupInterval;
+    private isDestroyed;
+    private readonly cleanupIntervalMs;
+    constructor(config?: CacheConfig & {
+        cleanupIntervalMs?: number;
+    });
+    private startCleanup;
+    private cleanup;
+    destroy(): void;
+    set(key: string, value: T, ttl?: number): void;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+}

package/dist/storage/cache/presentation/useCache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useCache Hook
+ */
+import type { CacheConfig } from '../domain/types/Cache';
+export declare function useCache<T>(cacheName: string, config?: CacheConfig): {
+    set: (key: string, value: T, ttl?: number) => void;
+    get: (key: string) => T | undefined;
+    has: (key: string) => boolean;
+    remove: (key: string) => boolean;
+    clear: () => void;
+    invalidatePattern: (pattern: string) => number;
+    getStats: () => import("../..").CacheStats;
+};

package/dist/storage/cache/presentation/useCachedValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * useCachedValue Hook
+ */
+import type { CacheConfig } from '../domain/types/Cache';
+export declare function useCachedValue<T>(cacheName: string, key: string, fetcher: () => Promise<T>, config?: CacheConfig & {
+    ttl?: number;
+}): {
+    value: T | null | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    invalidate: () => void;
+    invalidatePattern: (pattern: string) => number;
+    refetch: () => void;
+};

package/dist/storage/domain/constants/CacheDefaults.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Cache Default Constants
+ * Domain layer - Default values for caching
+ *
+ * General-purpose constants for any app
+ */
+/**
+ * Time constants in milliseconds
+ */
+export declare const TIME_MS: {
+    readonly SECOND: 1000;
+    readonly MINUTE: number;
+    readonly HOUR: number;
+    readonly DAY: number;
+    readonly WEEK: number;
+};
+/**
+ * Default TTL values for different cache types
+ */
+export declare const DEFAULT_TTL: {
+    /**
+     * Very short cache (1 minute)
+     * Use for: Real-time data, live updates
+     */
+    readonly VERY_SHORT: number;
+    /**
+     * Short cache (5 minutes)
+     * Use for: Frequently changing data
+     */
+    readonly SHORT: number;
+    /**
+     * Medium cache (30 minutes)
+     * Use for: Moderately changing data, user-specific content
+     */
+    readonly MEDIUM: number;
+    /**
+     * Long cache (2 hours)
+     * Use for: Slowly changing data, public content
+     */
+    readonly LONG: number;
+    /**
+     * Very long cache (24 hours)
+     * Use for: Rarely changing data, master data
+     */
+    readonly VERY_LONG: number;
+    /**
+     * Permanent cache (7 days)
+     * Use for: Static content, app configuration
+     */
+    readonly PERMANENT: number;
+};
+/**
+ * Cache version for global invalidation
+ * Increment this to invalidate all caches across the app
+ */
+export declare const CACHE_VERSION = 1;

package/dist/storage/domain/entities/CachedValue.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Cached Value Entity
+ * Domain layer - Represents a cached value with TTL metadata
+ *
+ * General-purpose cache entity for any app that needs persistent caching
+ */
+/**
+ * Cached value with time-to-live metadata
+ * Generic type T can be any serializable data
+ */
+export interface CachedValue<T> {
+    /**
+     * The actual cached data
+     */
+    value: T;
+    /**
+     * Timestamp when the value was cached (milliseconds)
+     */
+    cachedAt: number;
+    /**
+     * Timestamp when the cache expires (milliseconds)
+     */
+    expiresAt: number;
+    /**
+     * Optional version for cache invalidation
+     * Increment version to invalidate all caches
+     */
+    version?: number;
+}
+/**
+ * Create a new cached value with TTL
+ * @param value - Data to cache
+ * @param ttlMs - Time-to-live in milliseconds
+ * @param version - Optional version number
+ */
+export declare function createCachedValue<T>(value: T, ttlMs: number, version?: number): CachedValue<T>;
+/**
+ * Check if cached value is expired
+ * @param cached - Cached value to check
+ * @param currentVersion - Optional current version to check against
+ */
+export declare function isCacheExpired<T>(cached: CachedValue<T>, currentVersion?: number): boolean;
+/**
+ * Get remaining TTL in milliseconds
+ * Returns 0 if expired
+ */
+export declare function getRemainingTTL<T>(cached: CachedValue<T>): number;
+/**
+ * Get cache age in milliseconds
+ */
+export declare function getCacheAge<T>(cached: CachedValue<T>): number;

package/dist/storage/domain/entities/StorageResult.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Storage Result Entity
+ *
+ * Domain-Driven Design: Entity representing storage operation result
+ * Functional programming pattern for error handling (Result type)
+ */
+import type { StorageError } from '../errors/StorageError';
+/**
+ * Storage Operation Result
+ * Success/Failure pattern for type-safe error handling
+ */
+export type StorageResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: StorageError;
+    fallback?: T;
+};
+/**
+ * Create success result
+ */
+export declare const success: <T>(data: T) => StorageResult<T>;
+/**
+ * Create failure result
+ */
+export declare const failure: <T>(error: StorageError, fallback?: T) => StorageResult<T>;
+/**
+ * Type guard for success result
+ */
+export declare const isSuccess: <T>(result: StorageResult<T>) => result is {
+    success: true;
+    data: T;
+};
+/**
+ * Type guard for failure result
+ */
+export declare const isFailure: <T>(result: StorageResult<T>) => result is {
+    success: false;
+    error: StorageError;
+    fallback?: T;
+};
+/**
+ * Unwrap result with default value
+ */
+export declare const unwrap: <T>(result: StorageResult<T>, defaultValue: T) => T;
+/**
+ * Map result data
+ */
+export declare const map: <T, U>(result: StorageResult<T>, fn: (data: T) => U) => StorageResult<U>;

package/dist/storage/domain/errors/StorageError.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Storage Error Types
+ *
+ * Domain-Driven Design: Domain errors for storage operations
+ * Typed errors for better error handling and debugging
+ */
+/**
+ * Base Storage Error
+ */
+export declare class StorageError extends Error {
+    readonly key?: string | undefined;
+    constructor(message: string, key?: string | undefined);
+}
+/**
+ * Storage Read Error
+ */
+export declare class StorageReadError extends StorageError {
+    readonly cause?: unknown;
+    constructor(key: string, cause?: unknown);
+}
+/**
+ * Storage Write Error
+ */
+export declare class StorageWriteError extends StorageError {
+    readonly cause?: unknown;
+    constructor(key: string, cause?: unknown);
+}
+/**
+ * Storage Delete Error
+ */
+export declare class StorageDeleteError extends StorageError {
+    readonly cause?: unknown;
+    constructor(key: string, cause?: unknown);
+}
+/**
+ * Storage Serialization Error
+ */
+export declare class StorageSerializationError extends StorageError {
+    readonly cause?: unknown;
+    constructor(key: string, cause?: unknown);
+}
+/**
+ * Storage Deserialization Error
+ */
+export declare class StorageDeserializationError extends StorageError {
+    readonly cause?: unknown;
+    constructor(key: string, cause?: unknown);
+}

package/dist/storage/domain/factories/StoreFactory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Store Factory
+ * Create Zustand stores with AsyncStorage persistence and actions
+ */
+import type { StoreApi } from 'zustand';
+import type { StoreConfig } from '../types/Store';
+/**
+ * Create a Zustand store with optional persistence and actions
+ */
+export declare function createStore<TState extends object, TActions extends object = object>(config: StoreConfig<TState, TActions>): import("zustand").UseBoundStore<StoreApi<TState & TActions>>;

package/dist/storage/domain/types/Store.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Store Types
+ * Zustand store configuration with actions support
+ */
+import type { StoreApi } from 'zustand';
+/** StateStorage interface for Zustand persist middleware */
+export interface StateStorage {
+    getItem: (name: string) => string | null | Promise<string | null>;
+    setItem: (name: string, value: string) => void | Promise<void>;
+    removeItem: (name: string) => void | Promise<void>;
+}
+/** Set function type for Zustand */
+export type SetState<T> = StoreApi<T>['setState'];
+/** Get function type for Zustand */
+export type GetState<T> = StoreApi<T>['getState'];
+/** Actions creator function */
+export type ActionsCreator<TState, TActions> = (set: SetState<TState & TActions>, get: GetState<TState & TActions>) => TActions;
+/** Store configuration */
+export interface StoreConfig<TState extends object, TActions extends object = object> {
+    /** Unique store name (used as storage key) */
+    name: string;
+    /** Initial state */
+    initialState: TState;
+    /** Actions creator function */
+    actions?: ActionsCreator<TState, TActions>;
+    /** Enable AsyncStorage persistence */
+    persist?: boolean;
+    /** State version for migrations */
+    version?: number;
+    /** Select which state to persist */
+    partialize?: (state: TState & TActions) => Partial<TState>;
+    /** Callback after rehydration */
+    onRehydrate?: (state: TState & TActions) => void;
+    /** Migration function for version changes */
+    migrate?: (persistedState: unknown, version: number) => TState;
+    /** Custom storage adapter (required when persist is true) */
+    storage?: StateStorage;
+}
+/** Persisted state wrapper */
+export interface PersistedState<T> {
+    state: T;
+    version: number;
+}