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

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

package/dist/storage/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Storage Domain - Public API
+ *
+ * Domain-Driven Design (DDD) Architecture
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all storage operations.
+ * ALL imports from the storage domain MUST go through this file.
+ *
+ * Architecture:
+ * - domain: Entities, value objects, errors (business logic)
+ * - application: Ports (interfaces), use cases (not needed for simple CRUD)
+ * - infrastructure: Repository implementation (AsyncStorage adapter)
+ * - presentation: Hooks (React integration)
+ *
+ * Usage:
+ *   import { useStorage, useStorageState, createStore } from '@umituz/react-native-design-system';
+ */
+export { StorageKey, createUserKey, createAppKey, } from './domain/value-objects/StorageKey';
+export type { DynamicStorageKey } from './domain/value-objects/StorageKey';
+export { StorageError, StorageReadError, StorageWriteError, StorageDeleteError, StorageSerializationError, StorageDeserializationError, } from './domain/errors/StorageError';
+export type { StorageResult } from './domain/entities/StorageResult';
+export { success, failure, unwrap, map, isSuccess, isFailure, } from './domain/entities/StorageResult';
+export type { CachedValue } from './domain/entities/CachedValue';
+export { createCachedValue, isCacheExpired, getRemainingTTL, getCacheAge, } from './domain/entities/CachedValue';
+export { generateCacheKey, generateListCacheKey, parseCacheKey, isCacheKey, } from './domain/utils/CacheKeyGenerator';
+export { TIME_MS, DEFAULT_TTL, CACHE_VERSION } from './domain/constants/CacheDefaults';
+export { isDev } from './domain/utils/devUtils';
+export type { StoreConfig, PersistedState, SetState, GetState, ActionsCreator, } from './domain/types/Store';
+export { createStore } from './domain/factories/StoreFactory';
+export type { StoreApi, UseBoundStore } from 'zustand';
+export type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+export type { IStorageRepository } from './application/ports/IStorageRepository';
+export { AsyncStorageRepository, storageRepository, } from './infrastructure/repositories/AsyncStorageRepository';
+export { storageService } from './infrastructure/adapters/StorageService';
+export type { StateStorage } from './domain/types/Store';
+export { useStorage } from './presentation/hooks/useStorage';
+export { useStorageState } from './presentation/hooks/useStorageState';
+export { useStore } from './presentation/hooks/useStore';
+export { usePersistentCache, type PersistentCacheOptions, type PersistentCacheResult, } from './presentation/hooks/usePersistentCache';
+export { useCacheState } from './presentation/hooks/useCacheState';
+export { CacheStorageOperations } from './presentation/hooks/CacheStorageOperations';
+export { Cache } from './cache/domain/Cache';
+export { CacheManager, cacheManager } from './cache/domain/CacheManager';
+export { CacheStatsTracker } from './cache/domain/CacheStatsTracker';
+export { PatternMatcher } from './cache/domain/PatternMatcher';
+export { ErrorHandler, CacheError } from './cache/domain/ErrorHandler';
+export { TTLCache } from './cache/infrastructure/TTLCache';
+export type { CacheEntry, CacheConfig, CacheStats, EvictionStrategy, } from './cache/domain/types/Cache';
+export type { EvictionStrategy as IEvictionStrategy } from './cache/domain/strategies/EvictionStrategy';
+export { LRUStrategy } from './cache/domain/strategies/LRUStrategy';
+export { LFUStrategy } from './cache/domain/strategies/LFUStrategy';
+export { FIFOStrategy } from './cache/domain/strategies/FIFOStrategy';
+export { TTLStrategy as TTLEvictionStrategy } from './cache/domain/strategies/TTLStrategy';
+export { useCache } from './cache/presentation/useCache';
+export { useCachedValue } from './cache/presentation/useCachedValue';

package/dist/storage/infrastructure/adapters/StorageService.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Storage Service
+ *
+ * Zustand persist middleware compatible StateStorage implementation.
+ * Uses AsyncStorage under the hood for React Native persistence.
+ */
+import type { StateStorage } from '../../domain/types/Store';
+/**
+ * Storage service for Zustand persist middleware
+ * Direct AsyncStorage implementation with proper error handling
+ */
+export declare const storageService: StateStorage;

package/dist/storage/infrastructure/repositories/AsyncStorageRepository.d.ts

@@ -0,0 +1,59 @@
+/**
+ * AsyncStorage Repository
+ *
+ * Domain-Driven Design: Infrastructure implementation of IStorageRepository
+ * Adapts React Native AsyncStorage to domain interface using composition
+ */
+import type { IStorageRepository } from '../../application/ports/IStorageRepository';
+import type { StorageResult } from '../../domain/entities/StorageResult';
+/**
+ * AsyncStorage Repository Implementation
+ * Uses composition to follow Single Responsibility Principle
+ */
+export declare class AsyncStorageRepository implements IStorageRepository {
+    private baseOps;
+    private stringOps;
+    private batchOps;
+    constructor();
+    private ensureInitialized;
+    /**
+     * Get item from AsyncStorage with type safety
+     */
+    getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>>;
+    /**
+     * Set item in AsyncStorage with automatic 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 AsyncStorage
+     */
+    removeItem(key: string): Promise<StorageResult<void>>;
+    /**
+     * Check if key exists in storage
+     */
+    hasItem(key: string): Promise<boolean>;
+    /**
+     * Clear all AsyncStorage 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[]>>;
+}
+/**
+ * Singleton instance - lazy initialization
+ */
+export declare const storageRepository: AsyncStorageRepository;

package/dist/storage/infrastructure/repositories/BaseStorageOperations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Base Storage Operations
+ *
+ * Core storage operations following Single Responsibility Principle
+ */
+import type { StorageResult } from '../../domain/entities/StorageResult';
+/**
+ * Base storage operations implementation
+ */
+export declare class BaseStorageOperations {
+    /**
+     * Get item from AsyncStorage with type safety
+     */
+    getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>>;
+    /**
+     * Set item in AsyncStorage with automatic JSON serialization
+     */
+    setItem<T>(key: string, value: T): Promise<StorageResult<T>>;
+    /**
+     * Remove item from AsyncStorage
+     */
+    removeItem(key: string): Promise<StorageResult<void>>;
+    /**
+     * Check if key exists in storage
+     */
+    hasItem(key: string): Promise<boolean>;
+    /**
+     * Clear all AsyncStorage data
+     */
+    clearAll(): Promise<StorageResult<void>>;
+}

package/dist/storage/infrastructure/repositories/BatchStorageOperations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Batch Storage Operations
+ *
+ * Batch operations following Single Responsibility Principle
+ */
+import type { StorageResult } from '../../domain/entities/StorageResult';
+/**
+ * Batch storage operations for efficiency
+ */
+export declare class BatchStorageOperations {
+    /**
+     * 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/infrastructure/repositories/StringStorageOperations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * String Storage Operations
+ *
+ * Specialized string operations following Single Responsibility Principle
+ */
+import type { StorageResult } from '../../domain/entities/StorageResult';
+/**
+ * String-specific storage operations
+ */
+export declare class StringStorageOperations {
+    /**
+     * 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>>;
+}

package/dist/storage/presentation/hooks/CacheStorageOperations.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cache Storage Operations
+ *
+ * Handles cache storage operations following Single Responsibility Principle
+ */
+import type { CachedValue } from '../../domain/entities/CachedValue';
+export interface CacheStorageOptions {
+    ttl?: number;
+    version?: number;
+    enabled?: boolean;
+}
+/**
+ * Handles cache storage operations with proper error handling and memory management
+ */
+export declare class CacheStorageOperations {
+    private static instance;
+    /**
+     * Singleton pattern to prevent memory leaks
+     */
+    static getInstance(): CacheStorageOperations;
+    /**
+     * Reset singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Load cached data from storage
+     */
+    loadFromStorage<T>(key: string): Promise<CachedValue<T> | null>;
+    /**
+     * Save data to cache storage
+     */
+    saveToStorage<T>(key: string, value: T, options?: CacheStorageOptions): Promise<void>;
+    /**
+     * Clear cached data from storage
+     */
+    clearFromStorage(key: string, enabled?: boolean): Promise<void>;
+}

package/dist/storage/presentation/hooks/useCacheState.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cache State Manager
+ *
+ * Manages cache state following Single Responsibility Principle
+ */
+export interface CacheState<T> {
+    data: T | null;
+    isLoading: boolean;
+    isExpired: boolean;
+}
+export interface CacheActions<T> {
+    setData: (value: T) => void;
+    clearData: () => void;
+    setLoading: (loading: boolean) => void;
+    setExpired: (expired: boolean) => void;
+}
+/**
+ * Hook for managing cache state
+ */
+export declare function useCacheState<T>(): [CacheState<T>, CacheActions<T>];

package/dist/storage/presentation/hooks/usePersistentCache.d.ts

@@ -0,0 +1,73 @@
+/**
+ * usePersistentCache Hook
+ * Presentation layer - Hook for persistent caching with TTL
+ *
+ * General-purpose cache hook for any app
+ */
+/**
+ * Options for persistent cache
+ */
+export interface PersistentCacheOptions {
+    /**
+     * Time-to-live in milliseconds
+     * @default DEFAULT_TTL.MEDIUM (30 minutes)
+     */
+    ttl?: number;
+    /**
+     * Cache version for invalidation
+     * Increment to invalidate existing caches
+     */
+    version?: number;
+    /**
+     * Whether cache is enabled
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result from usePersistentCache hook
+ */
+export interface PersistentCacheResult<T> {
+    /**
+     * Cached data (null if not loaded or expired)
+     */
+    data: T | null;
+    /**
+     * Whether data is being loaded from storage
+     */
+    isLoading: boolean;
+    /**
+     * Whether cached data is expired
+     */
+    isExpired: boolean;
+    /**
+     * Set data to cache
+     */
+    setData: (value: T) => Promise<void>;
+    /**
+     * Clear cached data
+     */
+    clearData: () => Promise<void>;
+    /**
+     * Refresh cache (reload from storage)
+     */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook for persistent caching with TTL support
+ *
+ * @example
+ * ```typescript
+ * const { data, setData, isExpired } = usePersistentCache<Post[]>('posts-page-1', {
+ *   ttl: TIME_MS.HOUR,
+ *   version: 1,
+ * });
+ *
+ * // Check if need to fetch
+ * if (!data || isExpired) {
+ *   const freshData = await fetchPosts();
+ *   await setData(freshData);
+ * }
+ * ```
+ */
+export declare function usePersistentCache<T>(key: string, options?: PersistentCacheOptions): PersistentCacheResult<T>;

package/dist/storage/presentation/hooks/useStorage.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useStorage Hook
+ *
+ * Domain-Driven Design: Presentation layer hook for storage operations
+ * Provides clean API for components to interact with storage domain
+ */
+import type { StorageResult } from '../../domain/entities/StorageResult';
+import type { StorageKey } from '../../domain/value-objects/StorageKey';
+/**
+ * Storage Hook
+ * Provides type-safe storage operations
+ */
+export declare const useStorage: () => {
+    getItem: <T>(key: string | StorageKey, defaultValue: T) => Promise<T>;
+    setItem: <T>(key: string | StorageKey, value: T) => Promise<boolean>;
+    getString: (key: string | StorageKey, defaultValue: string) => Promise<string>;
+    setString: (key: string | StorageKey, value: string) => Promise<boolean>;
+    removeItem: (key: string | StorageKey) => Promise<boolean>;
+    hasItem: (key: string | StorageKey) => Promise<boolean>;
+    clearAll: () => Promise<boolean>;
+    getItemWithResult: <T>(key: string | StorageKey, defaultValue: T) => Promise<StorageResult<T>>;
+};

package/dist/storage/presentation/hooks/useStorageState.d.ts

@@ -0,0 +1,18 @@
+/**
+ * useStorageState Hook
+ *
+ * Domain-Driven Design: Presentation layer hook for state + storage sync
+ * Combines React state with automatic storage persistence
+ */
+import type { StorageKey } from '../../domain/value-objects/StorageKey';
+/**
+ * Storage State Hook
+ * Syncs React state with AsyncStorage automatically
+ *
+ * @example
+ * ```typescript
+ * const [settings, setSettings] = useStorageState('user_settings', { theme: 'light' });
+ * // State is automatically persisted to storage
+ * ```
+ */
+export declare const useStorageState: <T>(key: string | StorageKey, defaultValue: T) => [T, (value: T) => Promise<void>, boolean];

package/dist/storage/presentation/hooks/useStore.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useStore Hook
+ * Helper for creating stores in components
+ */
+import type { StoreConfig } from '../../domain/types/Store';
+export declare function useStore<T extends object>(config: StoreConfig<T>): import("zustand").UseBoundStore<import("zustand").StoreApi<T>>;

package/dist/tanstack/domain/config/QueryClientAccessor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * QueryClient Accessor
+ * Domain layer - Global QueryClient access
+ *
+ * Provides access to QueryClient instance outside of React component tree.
+ * Useful for services, utilities, and callbacks that need to invalidate cache.
+ *
+ * IMPORTANT: setGlobalQueryClient must be called before using getGlobalQueryClient.
+ * This is typically done in TanstackProvider.
+ */
+import type { QueryClient } from '@tanstack/react-query';
+/**
+ * Set the global QueryClient instance.
+ * Called automatically by TanstackProvider.
+ */
+export declare function setGlobalQueryClient(client: QueryClient): void;
+/**
+ * Get the global QueryClient instance.
+ * Use this in non-React contexts (services, utilities, callbacks).
+ *
+ * @throws Error if QueryClient has not been set
+ *
+ * @example
+ * ```typescript
+ * import { getGlobalQueryClient, creditsQueryKeys } from '@umituz/react-native-tanstack';
+ *
+ * const queryClient = getGlobalQueryClient();
+ * queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
+ * ```
+ */
+export declare function getGlobalQueryClient(): QueryClient;
+/**
+ * Check if global QueryClient is available.
+ * Use this before calling getGlobalQueryClient to avoid throwing.
+ */
+export declare function hasGlobalQueryClient(): boolean;
+/**
+ * Clear the global QueryClient reference.
+ * Useful for cleanup in tests.
+ */
+export declare function clearGlobalQueryClient(): void;

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

@@ -0,0 +1,58 @@
+/**
+ * Cache Time Constants
+ * Domain layer - Time constants for cache management
+ *
+ * General-purpose time utilities for any React Native app
+ */
+/**
+ * Milliseconds constants for time calculations
+ */
+export declare const TIME_MS: {
+    readonly SECOND: 1000;
+    readonly MINUTE: number;
+    readonly HOUR: number;
+    readonly DAY: number;
+    readonly WEEK: number;
+};
+/**
+ * Default staleTime values for different cache strategies
+ * staleTime = how long data is considered fresh
+ */
+export declare const DEFAULT_STALE_TIME: {
+    readonly REALTIME: 0;
+    readonly VERY_SHORT: number;
+    readonly SHORT: number;
+    readonly MEDIUM: number;
+    readonly LONG: number;
+    readonly VERY_LONG: number;
+    readonly PERMANENT: number;
+};
+/**
+ * Default gcTime (garbage collection) values
+ * gcTime = how long unused data stays in cache before being garbage collected
+ */
+export declare const DEFAULT_GC_TIME: {
+    readonly VERY_SHORT: number;
+    readonly SHORT: number;
+    readonly MEDIUM: number;
+    readonly LONG: number;
+    readonly VERY_LONG: number;
+};
+/**
+ * Default retry configuration
+ */
+export declare const DEFAULT_RETRY: {
+    readonly NONE: false;
+    readonly MINIMAL: 1;
+    readonly STANDARD: 3;
+    readonly AGGRESSIVE: 5;
+};
+/**
+ * Default refetch intervals
+ */
+export declare const DEFAULT_REFETCH_INTERVAL: {
+    readonly REALTIME: number;
+    readonly FAST: number;
+    readonly MODERATE: number;
+    readonly SLOW: number;
+};