@umituz/react-native-design-system 4.25.85 → 4.25.87

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

package/dist/tanstack/domain/repositories/BaseRepository.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Base Repository
+ * Domain layer - Abstract repository for data operations
+ *
+ * Provides generic CRUD operations with TanStack Query integration.
+ * Subclass this for specific entities to get type-safe data operations.
+ *
+ * @example
+ * ```typescript
+ * class UserRepository extends BaseRepository<User, CreateUserVars, UpdateUserVars> {
+ *   constructor() {
+ *     super('users');
+ *   }
+ *
+ *   async fetchAll(): Promise<User[]> {
+ *     return api.get('/users');
+ *   }
+ *
+ *   async fetchById(id: string): Promise<User> {
+ *     return api.get(`/users/${id}`);
+ *   }
+ *
+ *   async create(data: CreateUserVars): Promise<User> {
+ *     return api.post('/users', data);
+ *   }
+ *
+ *   async update(id: string, data: UpdateUserVars): Promise<User> {
+ *     return api.put(`/users/${id}`, data);
+ *   }
+ *
+ *   async remove(id: string): Promise<void> {
+ *     return api.delete(`/users/${id}`);
+ *   }
+ * }
+ * ```
+ */
+import type { QueryClient } from '@tanstack/react-query';
+import { createQueryKeyFactory } from '../utils/QueryKeyFactory';
+import type { CreateParams, UpdateParams, ListParams, RepositoryOptions } from './RepositoryTypes';
+/**
+ * Base repository for CRUD operations
+ *
+ * @template TData - Entity type
+ * @template TCreateVariables - Variables for create mutation
+ * @template TUpdateVariables - Variables for update mutation
+ */
+export declare abstract class BaseRepository<TData, TCreateVariables = unknown, TUpdateVariables = Partial<TData>> {
+    readonly resource: string;
+    readonly options: RepositoryOptions;
+    /**
+     * Query key factory for this repository
+     */
+    readonly keys: ReturnType<typeof createQueryKeyFactory>;
+    constructor(resource: string, options?: RepositoryOptions);
+    /**
+     * Get query client instance
+     */
+    getClient(): QueryClient;
+    /**
+     * Get cache options for queries
+     */
+    getCacheOptions(): {
+        staleTime: number;
+        gcTime: number;
+    };
+    /**
+     * Fetch all items - to be implemented by subclass
+     */
+    abstract fetchAll(params?: ListParams): Promise<TData[]>;
+    /**
+     * Fetch item by ID - to be implemented by subclass
+     */
+    abstract fetchById(id: string | number): Promise<TData>;
+    /**
+     * Create item - to be implemented by subclass
+     */
+    abstract create(params: CreateParams<TCreateVariables>): Promise<TData>;
+    /**
+     * Update item - to be implemented by subclass
+     */
+    abstract update(params: UpdateParams<TUpdateVariables>): Promise<TData>;
+    /**
+     * Delete item - to be implemented by subclass
+     */
+    abstract remove(id: string | number): Promise<void>;
+    /**
+     * Query all items with caching
+     */
+    queryAll(params?: ListParams): Promise<TData[]>;
+    /**
+     * Query item by ID with caching
+     */
+    queryById(id: string | number): Promise<TData | undefined>;
+    /**
+     * Prefetch all items
+     */
+    prefetchAll(params?: ListParams): Promise<void>;
+    /**
+     * Prefetch item by ID
+     */
+    prefetchById(id: string | number): Promise<void>;
+    /**
+     * Invalidate all queries for this resource
+     */
+    invalidateAll(): Promise<void>;
+    /**
+     * Invalidate list queries
+     */
+    invalidateLists(): Promise<void>;
+    /**
+     * Invalidate detail query
+     */
+    invalidateDetail(id: string | number): Promise<void>;
+    /**
+     * Set query data (optimistic update)
+     */
+    setData(id: string | number, data: TData): void;
+    /**
+     * Get query data from cache
+     */
+    getData(id: string | number): TData | undefined;
+    /**
+     * Remove query data from cache
+     */
+    clearData(id: string | number): void;
+}

package/dist/tanstack/domain/repositories/IBaseRepository.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base Repository Interface
+ * Defines the contract for repository implementations
+ */
+import type { QueryClient } from '@tanstack/react-query';
+import type { CreateParams, UpdateParams, ListParams } from './RepositoryTypes';
+export interface IBaseRepository<TData, TCreateVariables, TUpdateVariables> {
+    /** Query client instance */
+    getClient(): QueryClient;
+    /** Resource name */
+    readonly resource: string;
+    /** Query key factory */
+    readonly keys: ReturnType<typeof import('../utils/QueryKeyFactory').createQueryKeyFactory>;
+    /** Cache options */
+    getCacheOptions(): {
+        staleTime: number;
+        gcTime: number;
+    };
+    /** Abstract methods to be implemented by subclasses */
+    fetchAll(params?: ListParams): Promise<TData[]>;
+    fetchById(id: string | number): Promise<TData>;
+    create(data: CreateParams<TCreateVariables>): Promise<TData>;
+    update(params: UpdateParams<TUpdateVariables>): Promise<TData>;
+    remove(id: string | number): Promise<void>;
+}