@umituz/react-native-design-system 4.28.22 → 4.28.23

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

@@ -0,0 +1,28 @@
+/**
+ * Persistent Storage Adapter
+ *
+ * Provides AsyncStorage in a format compatible with state management persist middleware.
+ *
+ * AsyncStorage natively supports the Promise-based API that state libraries expect:
+ * - getItem: (key: string) => Promise<string | null>
+ * - setItem: (key: string, value: string) => Promise<void>
+ * - removeItem: (key: string) => Promise<void>
+ *
+ * This is a centralized export point for persistent stores throughout the app.
+ *
+ * @example
+ * import { createStore, persistentStorage } from '@umituz/react-native-design-system/storage';
+ *
+ * const store = createStore({
+ *   persist: true,
+ *   storage: persistentStorage,
+ *   ...
+ * });
+ */
+/**
+ * Persistent storage export
+ *
+ * AsyncStorage instance that can be used directly with state management persist middleware.
+ * No wrapping needed - AsyncStorage already provides the correct interface.
+ */
+export declare const persistentStorage: import("@react-native-async-storage/async-storage").AsyncStorageStatic;

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,130 @@
+/**
+ * Base Repository
+ * Domain layer - Abstract repository for data operations
+ *
+ * Provides generic CRUD operations with TanStack Query integration.
+ * Now uses common repository utilities from core/repositories.
+ *
+ * @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>;
+    /**
+     * Debug logger for this repository
+     */
+    protected readonly log: (method: string, ...args: unknown[]) => void;
+    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>;
+}

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

@@ -0,0 +1,73 @@
+/**
+ * Repository Factory
+ * Domain layer - Factory for creating repository instances
+ *
+ * Provides singleton instances of repositories to avoid multiple instances.
+ * Repositories are registered once and reused throughout the app.
+ *
+ * @example
+ * ```typescript
+ * // Register repositories
+ * RepositoryFactory.register('users', new UserRepository());
+ * RepositoryFactory.register('posts', new PostRepository());
+ *
+ * // Get repository
+ * const userRepo = RepositoryFactory.get<UserRepository>('users');
+ * const users = await userRepo.queryAll();
+ *
+ * // Get all registered keys
+ * const keys = RepositoryFactory.keys(); // ['users', 'posts']
+ *
+ * // Invalidate all repositories
+ * RepositoryFactory.invalidateAll();
+ * ```
+ */
+import type { BaseRepository } from './BaseRepository';
+declare class RepositoryFactoryClass {
+    private repositories;
+    /**
+     * Register a repository instance
+     *
+     * @param key - Unique identifier for the repository
+     * @param repository - Repository instance
+     */
+    register<TRepository extends BaseRepository<unknown, unknown, unknown>>(key: string, repository: TRepository): void;
+    /**
+     * Get a registered repository instance
+     *
+     * @param key - Repository identifier
+     * @throws Error if repository not found
+     */
+    get<TRepository extends BaseRepository<unknown, unknown, unknown>>(key: string): TRepository;
+    /**
+     * Check if repository is registered
+     */
+    has(key: string): boolean;
+    /**
+     * Unregister a repository
+     */
+    unregister(key: string): boolean;
+    /**
+     * Get all registered repository keys
+     */
+    keys(): string[];
+    /**
+     * Clear all registered repositories
+     * Useful for testing or cleanup
+     */
+    clear(): void;
+    /**
+     * Invalidate all queries from all registered repositories
+     */
+    invalidateAll(): Promise<void>;
+    /**
+     * Prefetch all data from all registered repositories
+     * Useful for app initialization or online event
+     */
+    prefetchAll(): Promise<void>;
+}
+/**
+ * Global repository factory instance
+ */
+export declare const RepositoryFactory: RepositoryFactoryClass;
+export {};