@umituz/react-native-design-system 4.25.86 → 4.25.88

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;
+}

package/dist/storage/domain/utils/CacheKeyGenerator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cache Key Generator
+ * Domain layer - Utility for generating consistent cache keys
+ *
+ * General-purpose key generation for any app
+ */
+/**
+ * Generate a cache key from prefix and identifier
+ * @param prefix - Cache key prefix (e.g., 'posts', 'products', 'user')
+ * @param id - Unique identifier
+ * @returns Formatted cache key
+ *
+ * @example
+ * generateCacheKey('posts', '123') // 'cache:posts:123'
+ * generateCacheKey('user', 'profile') // 'cache:user:profile'
+ */
+export declare function generateCacheKey(prefix: string, id: string | number): string;
+/**
+ * Generate a cache key for a list/collection
+ * @param prefix - Cache key prefix
+ * @param params - Optional query parameters
+ *
+ * @example
+ * generateListCacheKey('posts') // 'cache:posts:list'
+ * generateListCacheKey('posts', { page: 1 }) // 'cache:posts:list:page=1'
+ */
+export declare function generateListCacheKey(prefix: string, params?: Record<string, string | number>): string;
+/**
+ * Parse a cache key to extract prefix and id
+ * @param key - Cache key to parse
+ * @returns Object with prefix and id, or null if invalid
+ */
+export declare function parseCacheKey(key: string): {
+    prefix: string;
+    id: string;
+} | null;
+/**
+ * Check if a key is a cache key
+ */
+export declare function isCacheKey(key: string): boolean;

package/dist/storage/domain/utils/ValidationUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Runtime validation utilities for storage operations
+ */
+/**
+ * Check if parsed value is a valid object (not null, not array)
+ */
+export declare function isValidObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Check if parsed value is a valid array
+ */
+export declare function isValidArray(value: unknown): value is unknown[];
+/**
+ * Validate cached value structure
+ */
+export declare function isValidCachedValue(value: unknown): boolean;
+/**
+ * Validate calendar event structure
+ */
+export declare function isValidCalendarEvent(value: unknown): boolean;

package/dist/storage/domain/utils/devUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Development utilities
+ */
+/**
+ * Check if running in development mode
+ */
+export declare const isDev: () => boolean;

package/dist/storage/domain/value-objects/StorageKey.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Storage Key Value Object
+ *
+ * Domain-Driven Design: Value Object for storage keys
+ * Ensures type safety and prevents invalid key usage
+ */
+/**
+ * Storage key with dynamic suffix
+ */
+export type DynamicStorageKey = {
+    base: string;
+    suffix: string;
+};
+/**
+ * Helper to create user-specific storage key
+ *
+ * @param baseKey Base storage key
+ * @param userId User identifier
+ * @returns User-specific key
+ */
+export declare const createUserKey: (baseKey: string, userId: string) => string;
+/**
+ * Helper to create app-specific storage key
+ *
+ * @param baseKey Base storage key
+ * @param appName App identifier
+ * @returns App-specific key
+ */
+export declare const createAppKey: (baseKey: string, appName: string) => string;
+/**
+ * Helper to create namespaced storage key
+ *
+ * @param namespace Key namespace
+ * @param key Specific key
+ * @returns Namespaced key
+ */
+export declare const createNamespacedKey: (namespace: string, key: string) => string;
+/**
+ * Common storage keys for cross-app usage
+ * Generic keys that can be used across multiple applications
+ */
+export declare enum StorageKey {
+    USER_PREFERENCES = "@user_preferences",
+    APP_SETTINGS = "@app_settings",
+    LANGUAGE = "@language",
+    UI_PREFERENCES = "@ui_preferences",
+    QUERY_CACHE = "@query_cache",
+    DATA_CACHE = "@data_cache"
+}