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

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

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

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

@@ -0,0 +1,32 @@
+/**
+ * Repository Types
+ * Interfaces for data repository operations
+ */
+import type { CacheConfig } from '../types/CacheStrategy';
+export interface CreateParams<TVariables> {
+    variables: TVariables;
+}
+export interface UpdateParams<TVariables> {
+    id: string | number;
+    variables: TVariables;
+}
+export interface ListParams {
+    page?: number;
+    limit?: number;
+    filter?: Record<string, unknown>;
+}
+export interface RepositoryOptions {
+    /**
+     * Cache strategy for queries
+     * @default CacheStrategies.PUBLIC_DATA
+     */
+    cacheStrategy?: CacheConfig;
+    /**
+     * Stale time override
+     */
+    staleTime?: number;
+    /**
+     * GC time override
+     */
+    gcTime?: number;
+}

package/dist/tanstack/domain/repositories/helpers/repositoryHelpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Repository Helper Functions
+ * Common helper functions for repository operations
+ */
+import type { RepositoryOptions } from '../RepositoryTypes';
+/**
+ * Gets cache options for repository queries
+ *
+ * @param options - Repository options
+ * @returns Cache options with staleTime and gcTime
+ */
+export declare function getCacheOptions(options: RepositoryOptions): {
+    staleTime: number;
+    gcTime: number;
+};
+/**
+ * Merges repository options with defaults
+ *
+ * @param options - User provided options
+ * @returns Merged options
+ */
+export declare function mergeRepositoryOptions(options?: RepositoryOptions): Required<Pick<RepositoryOptions, 'cacheStrategy'>> & RepositoryOptions;
+/**
+ * Checks if a query key matches a resource
+ *
+ * @param queryKey - Query key to check
+ * @param resource - Resource name to match
+ * @returns True if query key matches resource
+ */
+export declare function matchesResource(queryKey: readonly unknown[], resource: string): boolean;

package/dist/tanstack/domain/repositories/mixins/repositoryInvalidationMethods.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Repository Invalidation Methods
+ * Cache invalidation methods for repository operations
+ */
+import type { IBaseRepository } from '../IBaseRepository';
+/**
+ * Invalidate all queries for this resource
+ *
+ * @param repository - Repository instance
+ */
+export declare function invalidateAll<TData>(repository: IBaseRepository<TData, unknown, unknown>): Promise<void>;
+/**
+ * Invalidate list queries
+ *
+ * @param repository - Repository instance
+ */
+export declare function invalidateLists<TData>(repository: IBaseRepository<TData, unknown, unknown>): Promise<void>;
+/**
+ * Invalidate detail query
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function invalidateDetail<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<void>;
+/**
+ * Set query data (optimistic update)
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @param data - Data to set
+ */
+export declare function setData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number, data: TData): void;
+/**
+ * Get query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Cached data or undefined
+ */
+export declare function getData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): TData | undefined;
+/**
+ * Remove query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function clearData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): void;

package/dist/tanstack/domain/repositories/mixins/repositoryQueryMethods.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Repository Query Methods
+ * Query methods for repository operations
+ */
+import type { ListParams } from '../RepositoryTypes';
+import type { IBaseRepository } from '../IBaseRepository';
+/**
+ * Query all items with caching
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ * @returns Promise of data array
+ */
+export declare function queryAll<TData>(repository: IBaseRepository<TData, unknown, unknown>, params?: ListParams): Promise<TData[]>;
+/**
+ * Query item by ID with caching
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Promise of data or undefined if not found
+ */
+export declare function queryById<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<TData | undefined>;
+/**
+ * Prefetch all items
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ */
+export declare function prefetchAll<TData>(repository: IBaseRepository<TData, unknown, unknown>, params?: ListParams): Promise<void>;
+/**
+ * Prefetch item by ID
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function prefetchById<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<void>;

package/dist/tanstack/domain/types/CacheStrategy.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache Strategy Types
+ * Domain layer - Cache configuration types
+ *
+ * General-purpose cache strategies for any React Native app
+ */
+import type { UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Cache configuration for TanStack Query
+ */
+export interface CacheConfig {
+    /**
+     * Time in ms data is considered fresh (no refetch)
+     */
+    staleTime: number;
+    /**
+     * Time in ms inactive data stays in cache before garbage collection
+     */
+    gcTime: number;
+    /**
+     * Whether to refetch when component mounts
+     */
+    refetchOnMount?: boolean | 'always';
+    /**
+     * Whether to refetch when window regains focus
+     */
+    refetchOnWindowFocus?: boolean | 'always';
+    /**
+     * Whether to refetch when network reconnects
+     */
+    refetchOnReconnect?: boolean | 'always';
+    /**
+     * Number of retry attempts on failure
+     */
+    retry?: boolean | number;
+    /**
+     * Interval for automatic background refetching (in ms)
+     * Set to false to disable
+     */
+    refetchInterval?: number | false;
+}
+/**
+ * Cache strategy enum for different data types
+ */
+export declare enum CacheStrategyType {
+    /**
+     * Real-time data that changes frequently
+     * Example: Live chat, stock prices, sports scores
+     */
+    REALTIME = "REALTIME",
+    /**
+     * User-specific data
+     * Example: User profile, settings, preferences
+     */
+    USER_DATA = "USER_DATA",
+    /**
+     * Master data that rarely changes
+     * Example: Countries list, categories, app configuration
+     */
+    MASTER_DATA = "MASTER_DATA",
+    /**
+     * Public read-heavy data
+     * Example: Blog posts, product catalog, news feed
+     */
+    PUBLIC_DATA = "PUBLIC_DATA",
+    /**
+     * Custom strategy (user-defined)
+     */
+    CUSTOM = "CUSTOM"
+}
+/**
+ * Query options type (generic, works with any data)
+ */
+export type QueryConfig<TData = unknown, TError = Error> = Partial<UseQueryOptions<TData, TError>>;
+/**
+ * Mutation options type (generic, works with any data)
+ */
+export interface MutationConfig<TData = unknown, TError = Error, TVariables = unknown> {
+    /**
+     * Function to call on mutation success
+     */
+    onSuccess?: (data: TData, variables: TVariables) => void | Promise<void>;
+    /**
+     * Function to call on mutation error
+     */
+    onError?: (error: TError, variables: TVariables) => void | Promise<void>;
+    /**
+     * Function to call on mutation settled (success or error)
+     */
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables) => void | Promise<void>;
+    /**
+     * Number of retry attempts
+     */
+    retry?: boolean | number;
+}

package/dist/tanstack/domain/utils/ErrorHelpers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Error Helpers
+ * Domain layer - Error handling utilities
+ *
+ * General-purpose error handling for TanStack Query
+ */
+/**
+ * Check if error is a QueryError (from TanStack Query)
+ */
+export declare function isQueryError(error: unknown): boolean;
+/**
+ * Check if error is a MutationError (from TanStack Query)
+ */
+export declare function isMutationError(error: unknown): boolean;
+/**
+ * Check if error is a network error
+ */
+export declare function isNetworkError(error: unknown): boolean;
+/**
+ * Check if error is an abort error
+ */
+export declare function isAbortError(error: unknown): boolean;
+/**
+ * Extract error message from error
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Get user-friendly error message
+ * Maps technical errors to user-friendly messages
+ */
+export declare function getUserFriendlyMessage(error: unknown): string;
+/**
+ * Parse error response (for API errors with structured data)
+ */
+export interface ErrorResponse {
+    message: string;
+    errors?: Record<string, string[]>;
+    code?: string;
+}
+export declare function parseErrorResponse(error: unknown): ErrorResponse | null;
+/**
+ * Get validation errors from error response
+ */
+export declare function getValidationErrors(error: unknown): Record<string, string[]> | null;
+/**
+ * Get error code from error response
+ */
+export declare function getErrorCode(error: unknown): string | null;
+/**
+ * Log error in development
+ */
+export declare function logError(_context: string, _error: unknown): void;

package/dist/tanstack/domain/utils/MetricsCalculator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Metrics Calculator
+ *
+ * Calculates query performance metrics for monitoring.
+ */
+import type { Query } from '@tanstack/react-query';
+import type { QueryMetrics, DevMonitorOptions } from '../../infrastructure/monitoring/DevMonitor.types';
+/**
+ * Metrics calculator for query performance
+ */
+export declare class MetricsCalculator {
+    /**
+     * Gets unique key string for query
+     */
+    static getQueryKeyString(queryKey: readonly unknown[]): string;
+    /**
+     * Calculates fetch time for a query
+     */
+    static calculateFetchTime(query: Query): number;
+    /**
+     * Creates initial metrics for a query
+     */
+    static createInitialMetrics(query: Query): QueryMetrics;
+    /**
+     * Updates metrics with new fetch data
+     */
+    static updateMetrics(current: QueryMetrics, fetchTime: number): QueryMetrics;
+    /**
+     * Checks if fetch time exceeds slow query threshold
+     */
+    static isSlowQuery(fetchTime: number, threshold: number): boolean;
+    /**
+     * Increments slow fetch count if query is slow
+     */
+    static incrementSlowCountIfNeeded(metrics: QueryMetrics, fetchTime: number, threshold: number): QueryMetrics;
+    /**
+     * Calculates complete metrics for a query
+     */
+    static calculateQueryMetrics(query: Query, currentMetrics: QueryMetrics | null, options: Required<DevMonitorOptions>): QueryMetrics;
+}

package/dist/tanstack/domain/utils/QueryKeyFactory.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Query Key Factory
+ * Domain layer - Query key generation utilities
+ *
+ * General-purpose query key patterns for any React Native app
+ */
+/**
+ * Create a typed query key factory for a resource
+ *
+ * @example
+ * ```typescript
+ * const postKeys = createQueryKeyFactory('posts');
+ *
+ * // All posts
+ * postKeys.all() // ['posts']
+ *
+ * // Posts list
+ * postKeys.lists() // ['posts', 'list']
+ *
+ * // Posts list with filters
+ * postKeys.list({ status: 'published' }) // ['posts', 'list', { status: 'published' }]
+ *
+ * // Single post detail
+ * postKeys.detail(123) // ['posts', 'detail', 123]
+ * ```
+ */
+export declare function createQueryKeyFactory(resource: string): {
+    /**
+     * All queries for this resource
+     */
+    all: () => readonly [string];
+    /**
+     * All list queries for this resource
+     */
+    lists: () => readonly [string, "list"];
+    /**
+     * List query with optional filters
+     */
+    list: (filters?: Record<string, unknown>) => readonly [string, "list"] | readonly [string, "list", Record<string, unknown>];
+    /**
+     * All detail queries for this resource
+     */
+    details: () => readonly [string, "detail"];
+    /**
+     * Detail query for specific item
+     */
+    detail: (id: string | number) => readonly [string, "detail", string | number];
+    /**
+     * Custom query key
+     */
+    custom: (...args: unknown[]) => readonly [string, ...unknown[]];
+};
+/**
+ * Create a query key for a list with pagination
+ *
+ * @example
+ * ```typescript
+ * createPaginatedQueryKey('posts', { page: 1, limit: 10 })
+ * // ['posts', 'list', { page: 1, limit: 10 }]
+ * ```
+ */
+export declare function createPaginatedQueryKey(resource: string, pagination: {
+    page?: number;
+    limit?: number;
+    cursor?: string;
+}): readonly [string, 'list', typeof pagination];
+/**
+ * Create a query key for infinite scroll
+ *
+ * @example
+ * ```typescript
+ * createInfiniteQueryKey('feed', { limit: 20 })
+ * // ['feed', 'infinite', { limit: 20 }]
+ * ```
+ */
+export declare function createInfiniteQueryKey(resource: string, params?: Record<string, unknown>): readonly [string, 'infinite', Record<string, unknown>] | readonly [string, 'infinite'];
+/**
+ * Create a scoped query key (for user-specific data)
+ *
+ * @example
+ * ```typescript
+ * createScopedQueryKey('user123', 'posts')
+ * // ['user', 'user123', 'posts']
+ * ```
+ */
+export declare function createScopedQueryKey(scopeId: string, resource: string, ...args: unknown[]): readonly [string, string, string, ...unknown[]];
+/**
+ * Match query keys by pattern
+ * Useful for invalidating multiple related queries
+ *
+ * @example
+ * ```typescript
+ * // Invalidate all post queries
+ * queryClient.invalidateQueries({
+ *   predicate: (query) => matchQueryKey(query.queryKey, ['posts'])
+ * })
+ * ```
+ */
+export declare function matchQueryKey(queryKey: readonly unknown[], pattern: readonly unknown[]): boolean;