@umituz/react-native-design-system 4.27.15 → 4.27.17

package/dist/core/cache/domain/CleanupStrategy.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Cleanup Strategy
+ *
+ * Strategy pattern for cache cleanup mechanisms.
+ * Allows switching between interval-based and recursive timeout-based cleanup.
+ */
+import type { CleanupType } from './types';
+/**
+ * Cleanup strategy interface for cache expiration
+ */
+export interface CleanupStrategy {
+    /**
+     * Start cleanup mechanism
+     * @param callback - Function to call on each cleanup cycle
+     */
+    start(callback: () => void): void;
+    /**
+     * Stop cleanup mechanism and release resources
+     */
+    stop(): void;
+    /**
+     * Strategy type identifier
+     */
+    readonly type: CleanupType;
+}
+/**
+ * Interval-based cleanup strategy
+ * Uses setInterval for periodic cleanup
+ *
+ * @example
+ * ```ts
+ * const strategy = new IntervalCleanupStrategy(60000); // Every minute
+ * strategy.start(() => cache.cleanup());
+ * ```
+ */
+export declare class IntervalCleanupStrategy implements CleanupStrategy {
+    private readonly intervalMs;
+    private interval;
+    constructor(intervalMs: number);
+    start(callback: () => void): void;
+    stop(): void;
+    get type(): 'interval';
+}
+/**
+ * Timeout-based cleanup strategy
+ * Uses recursive setTimeout for cleanup
+ *
+ * @example
+ * ```ts
+ * const strategy = new TimeoutCleanupStrategy(60000); // Every minute
+ * strategy.start(() => cache.cleanup());
+ * ```
+ */
+export declare class TimeoutCleanupStrategy implements CleanupStrategy {
+    private readonly timeoutMs;
+    private timeout;
+    private destroyed;
+    constructor(timeoutMs: number);
+    start(callback: () => void): void;
+    stop(): void;
+    get type(): 'timeout';
+}

package/dist/core/cache/domain/UnifiedCache.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Unified Cache
+ *
+ * Generic TTL-based cache with pluggable cleanup strategy.
+ * Merges functionality from SimpleCache and TTLCache.
+ *
+ * @example
+ * ```ts
+ * // With interval cleanup (like TTLCache)
+ * const cache = new UnifiedCache<string>({
+ *   defaultTTL: 60000,
+ *   cleanupStrategy: new IntervalCleanupStrategy(60000)
+ * });
+ *
+ * // With timeout cleanup (like SimpleCache)
+ * const cache = new UnifiedCache<string>({
+ *   defaultTTL: 60000,
+ *   cleanupStrategy: new TimeoutCleanupStrategy(60000)
+ * });
+ * ```
+ */
+import type { CacheEntry, CacheConfig } from './types';
+import { CleanupStrategy } from './CleanupStrategy';
+export interface UnifiedCacheConfig extends CacheConfig {
+    cleanupStrategy?: CleanupStrategy;
+    onExpired?: (key: string, count: number) => void;
+}
+/**
+ * Unified generic cache with TTL support and pluggable cleanup
+ */
+export declare class UnifiedCache<T = unknown> {
+    protected cache: Map<string, CacheEntry<T>>;
+    protected defaultTTL: number;
+    private cleanupStrategy;
+    private isDestroyed;
+    private onExpiredCallback?;
+    constructor(config?: UnifiedCacheConfig);
+    /**
+     * Set value with optional TTL override
+     */
+    set(key: string, value: T, ttl?: number): void;
+    /**
+     * Get value, returns undefined if expired or not found
+     */
+    get(key: string): T | undefined;
+    /**
+     * Check if key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Delete specific key
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get all non-expired keys
+     */
+    keys(): string[];
+    /**
+     * Get cache size (excluding expired entries)
+     */
+    size(): number;
+    /**
+     * Destroy cache and stop cleanup
+     */
+    destroy(): void;
+    /**
+     * Cleanup expired entries
+     */
+    protected cleanup(): void;
+    /**
+     * Check if entry is expired
+     */
+    private isExpired;
+    /**
+     * Warn about operation on destroyed cache
+     */
+    private warnDestroyed;
+}

package/dist/core/cache/domain/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core Cache Domain Types
+ *
+ * Shared types for cache implementations
+ */
+export interface CacheEntry<T> {
+    value: T;
+    expires: number;
+    timestamp: number;
+}
+export interface CacheConfig {
+    defaultTTL?: number;
+    cleanupIntervalMs?: number;
+}
+export type CleanupType = 'interval' | 'timeout';

package/dist/core/cache/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Core Cache Module
+ *
+ * Unified cache implementation with strategy pattern.
+ * Replaces SimpleCache and TTLCache with single implementation.
+ */
+export { UnifiedCache } from './domain/UnifiedCache';
+export type { UnifiedCacheConfig } from './domain/UnifiedCache';
+export type { CleanupStrategy } from './domain/CleanupStrategy';
+export { IntervalCleanupStrategy, TimeoutCleanupStrategy } from './domain/CleanupStrategy';
+export type { CleanupType } from './domain/types';
+export { CacheFactory } from './infrastructure/CacheFactory';
+export type { CacheEntry, CacheConfig } from './domain/types';

package/dist/core/cache/infrastructure/CacheFactory.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Cache Factory
+ *
+ * Factory for creating cache instances with common configurations.
+ * Provides convenient methods for different cache types.
+ */
+import { UnifiedCache } from '../domain/UnifiedCache';
+import type { UnifiedCacheConfig } from '../domain/UnifiedCache';
+/**
+ * Factory for creating cache instances
+ */
+export declare class CacheFactory {
+    /**
+     * Create cache with interval-based cleanup (like TTLCache)
+     *
+     * @param defaultTTL - Default time-to-live in milliseconds
+     * @param cleanupInterval - Cleanup interval in milliseconds
+     *
+     * @example
+     * ```ts
+     * const cache = CacheFactory.createIntervalCache(60000, 60000);
+     * ```
+     */
+    static createIntervalCache<T = unknown>(defaultTTL?: number, cleanupInterval?: number): UnifiedCache<T>;
+    /**
+     * Create cache with timeout-based cleanup (like SimpleCache)
+     *
+     * @param defaultTTL - Default time-to-live in milliseconds
+     * @param cleanupTimeout - Cleanup timeout in milliseconds
+     *
+     * @example
+     * ```ts
+     * const cache = CacheFactory.createTimeoutCache(60000, 60000);
+     * ```
+     */
+    static createTimeoutCache<T = unknown>(defaultTTL?: number, cleanupTimeout?: number): UnifiedCache<T>;
+    /**
+     * Create cache with custom configuration
+     *
+     * @example
+     * ```ts
+     * const cache = CacheFactory.createCustomCache({
+     *   defaultTTL: 120000,
+     *   cleanupStrategy: new IntervalCleanupStrategy(30000),
+     *   onExpired: (key, count) => console.log(`Expired ${count} items`)
+     * });
+     * ```
+     */
+    static createCustomCache<T = unknown>(config: UnifiedCacheConfig): UnifiedCache<T>;
+    /**
+     * Create cache without automatic cleanup (manual cleanup only)
+     *
+     * @param defaultTTL - Default time-to-live in milliseconds
+     *
+     * @example
+     * ```ts
+     * const cache = CacheFactory.createManualCache(60000);
+     * // ... later
+     * cache.cleanup(); // Manual cleanup
+     * ```
+     */
+    static createManualCache<T = unknown>(defaultTTL?: number): UnifiedCache<T>;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Core Module
+ *
+ * Shared abstractions and utilities for the design system.
+ * Provides cache, permissions, errors, and repository foundations.
+ */
+export { UnifiedCache } from './cache/domain/UnifiedCache';
+export { CacheFactory } from './cache/infrastructure/CacheFactory';
+export type { CleanupStrategy } from './cache/domain/CleanupStrategy';
+export { IntervalCleanupStrategy, TimeoutCleanupStrategy } from './cache/domain/CleanupStrategy';
+export type { UnifiedCacheConfig } from './cache/domain/UnifiedCache';
+export type { CacheEntry, CacheConfig, CleanupType } from './cache/domain/types';
+export { PermissionHandler } from './permissions/domain/PermissionHandler';
+export type { PermissionMethod, PermissionStatus, PermissionResult, PermissionHandlerConfig, PermissionMethods } from './permissions/domain/types';
+export { createRepositoryKeyFactory } from './repositories/domain/RepositoryKeyFactory';
+export { mergeRepositoryOptions, getCacheOptions, normalizeListParams, createRepositoryLogger } from './repositories/domain/RepositoryUtils';
+export type { RepositoryOptions, ListParams, CreateParams, UpdateParams, QueryKeyFactory } from './repositories/domain/types';

package/dist/core/permissions/domain/PermissionHandler.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Generic Permission Handler
+ *
+ * Generic permission handling using strategy pattern.
+ * Reduces permission method duplication from 4 methods → 1 generic handler.
+ *
+ * @example
+ * ```ts
+ * const handler = new PermissionHandler({
+ *   methods: {
+ *     request: {
+ *       camera: ImagePicker.requestCameraPermissionsAsync,
+ *       mediaLibrary: ImagePicker.requestMediaLibraryPermissionsAsync,
+ *     },
+ *     get: {
+ *       camera: ImagePicker.getCameraPermissionsAsync,
+ *       mediaLibrary: ImagePicker.getMediaLibraryPermissionsAsync,
+ *     },
+ *   },
+ *   statusMapper: mapPermissionStatus,
+ *   defaultStatus: MediaLibraryPermission.DENIED,
+ * });
+ *
+ * // Request permission
+ * const status = await handler.handle('request', 'camera');
+ *
+ * // Check if granted
+ * if (handler.isGranted(status)) {
+ *   // Proceed with operation
+ * }
+ * ```
+ */
+import type { PermissionMethod, PermissionStatus, PermissionHandlerConfig } from './types';
+/**
+ * Generic permission handler with configurable methods and status mapping
+ */
+export declare class PermissionHandler<TPermission extends PermissionStatus = PermissionStatus> {
+    private methods;
+    private statusMapper;
+    private defaultStatus;
+    constructor(config: PermissionHandlerConfig<TPermission>);
+    /**
+     * Handle permission request or status check
+     *
+     * @param method - 'request' or 'get'
+     * @param type - Permission type key (e.g., 'camera', 'mediaLibrary')
+     * @returns Permission status
+     */
+    handle(method: PermissionMethod, type: string): Promise<TPermission>;
+    /**
+     * Check if permission status is granted
+     *
+     * @param status - Permission status to check
+     * @returns true if permission is granted or limited
+     */
+    isGranted(status: TPermission): boolean;
+    /**
+     * Check if permission status is denied
+     *
+     * @param status - Permission status to check
+     * @returns true if permission is denied
+     */
+    isDenied(status: TPermission): boolean;
+    /**
+     * Request permission by type
+     *
+     * @example
+     * ```ts
+     * const status = await handler.request('camera');
+     * ```
+     */
+    request(type: string): Promise<TPermission>;
+    /**
+     * Get permission status by type
+     *
+     * @example
+     * ```ts
+     * const status = await handler.getStatus('camera');
+     * ```
+     */
+    getStatus(type: string): Promise<TPermission>;
+}

package/dist/core/permissions/domain/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Core Permissions Domain Types
+ *
+ * Generic types for permission handling
+ */
+export type PermissionMethod = 'request' | 'get';
+/**
+ * Permission status types
+ * Apps can extend this for custom permission types
+ */
+export type PermissionStatus = 'granted' | 'denied' | 'limited' | 'undetermined';
+/**
+ * Permission result with metadata
+ */
+export interface PermissionResult {
+    status: PermissionStatus;
+    canAskAgain?: boolean;
+}
+/**
+ * Permission handler configuration
+ */
+export interface PermissionHandlerConfig<TPermission extends PermissionStatus = PermissionStatus> {
+    /**
+     * Map permission API methods
+     */
+    methods: PermissionMethods;
+    /**
+     * Map API status to domain permission type
+     */
+    statusMapper: (apiStatus: string) => TPermission;
+    /**
+     * Default status when permission fails
+     */
+    defaultStatus?: TPermission;
+}
+/**
+ * Permission API methods mapping
+ */
+export interface PermissionMethods {
+    request: Record<string, () => Promise<PermissionResult>>;
+    get: Record<string, () => Promise<PermissionResult>>;
+}

package/dist/core/permissions/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Core Permissions Module
+ *
+ * Generic permission handling with configurable methods and status mapping.
+ */
+export { PermissionHandler } from './domain/PermissionHandler';
+export type { PermissionMethod, PermissionStatus, PermissionResult, PermissionHandlerConfig, PermissionMethods, } from './domain/types';

package/dist/core/repositories/domain/RepositoryKeyFactory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Repository Key Factory
+ *
+ * Generic query key factory for repositories.
+ * Provides consistent query key structure across all repositories.
+ */
+import type { QueryKeyFactory } from './types';
+/**
+ * Create query key factory for a resource
+ *
+ * @param resource - Resource name (e.g., 'users', 'posts')
+ * @returns Query key factory
+ *
+ * @example
+ * ```ts
+ * const keys = createRepositoryKeyFactory('users');
+ *
+ * keys.all(); // ['users']
+ * keys.lists(); // ['users', 'list']
+ * keys.list({ page: 1 }); // ['users', 'list', { page: 1 }]
+ * keys.details(); // ['users', 'detail']
+ * keys.detail(123); // ['users', 'detail', 123]
+ * ```
+ */
+export declare function createRepositoryKeyFactory(resource: string): QueryKeyFactory;

package/dist/core/repositories/domain/RepositoryUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Repository Utilities
+ *
+ * Common utilities for repository implementations.
+ * Provides caching options and helper functions.
+ */
+import type { RepositoryOptions, ListParams } from './types';
+/**
+ * Merge repository options with defaults
+ *
+ * @param options - User provided options
+ * @returns Merged options
+ */
+export declare function mergeRepositoryOptions(options?: RepositoryOptions): Required<RepositoryOptions>;
+/**
+ * Get cache options from repository options
+ *
+ * @param options - Repository options
+ * @returns Cache options with defaults
+ */
+export declare function getCacheOptions(options: RepositoryOptions): {
+    staleTime: number;
+    gcTime: number;
+};
+/**
+ * Normalize list parameters
+ *
+ * @param params - List parameters
+ * @returns Normalized parameters
+ */
+export declare function normalizeListParams(params?: ListParams): ListParams;
+/**
+ * Create debug logger for repository
+ *
+ * @param resource - Resource name
+ * @param enabled - Enable logging
+ * @returns Logger function
+ */
+export declare function createRepositoryLogger(resource: string, enabled?: boolean): (method: string, ...args: unknown[]) => void;

package/dist/core/repositories/domain/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Core Repository Domain Types
+ *
+ * Shared types for repository implementations
+ */
+/**
+ * Repository options
+ */
+export interface RepositoryOptions {
+    /**
+     * Cache configuration
+     */
+    cache?: {
+        staleTime?: number;
+        gcTime?: number;
+    };
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+}
+/**
+ * List parameters for fetch operations
+ */
+export interface ListParams {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    filter?: Record<string, unknown>;
+}
+/**
+ * Create parameters
+ */
+export interface CreateParams<TVariables> {
+    data: TVariables;
+}
+/**
+ * Update parameters
+ */
+export interface UpdateParams<TVariables> {
+    id: string | number;
+    data: TVariables;
+}
+/**
+ * Query key factory result
+ */
+export type QueryKeyFactory = {
+    all: () => readonly string[];
+    lists: () => readonly string[];
+    list: (params: ListParams) => readonly unknown[];
+    details: () => readonly string[];
+    detail: (id: string | number) => readonly unknown[];
+};

package/dist/core/repositories/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Core Repositories Module
+ *
+ * Common utilities and types for repository implementations.
+ * TanStack and Storage repositories remain separate but share these utilities.
+ */
+export { createRepositoryKeyFactory } from './domain/RepositoryKeyFactory';
+export type { QueryKeyFactory } from './domain/types';
+export { mergeRepositoryOptions, getCacheOptions, normalizeListParams, createRepositoryLogger, } from './domain/RepositoryUtils';
+export type { RepositoryOptions, ListParams, CreateParams, UpdateParams, } from './domain/types';

package/dist/hooks/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @umituz/react-native-design-system/hooks - Centralized Hooks Export
+ *
+ * Re-exports all commonly used hooks from the design system
+ *
+ * Usage:
+ *   import {
+ *     useAppDesignTokens,
+ *     useTheme,
+ *     useInfiniteScroll,
+ *     useOffline,
+ *     useResponsive,
+ *     useSafeArea
+ *   } from '@umituz/react-native-design-system/hooks';
+ */
+export { useAppDesignTokens, } from '../theme/hooks/useAppDesignTokens';
+export { useTheme as useThemeStore } from '../theme/infrastructure/stores/themeStore';
+export { useResponsive, useScreenWidth, useScreenHeight, useScreenDimensions, type UseResponsiveReturn, } from '../responsive';
+export { useSafeAreaInsets, } from '../safe-area';
+export { useInfiniteScroll, type InfiniteScrollConfig, type UseInfiniteScrollReturn, } from '../infinite-scroll';
+export { useOffline, type NetworkState, } from '../offline';
+export { useDeviceInfo, useDeviceCapabilities, useDeviceId, type DeviceInfo, type AnonymousUser, } from '../device';
+export { useStorage, useStorageState, useStore, usePersistentCache, useCache, useCachedValue, useCacheState, type PersistentCacheOptions, type PersistentCacheResult, } from '../storage';
+export { useMedia, type MediaPickerResult, } from '../media';
+export { useTimezone, type TimezoneInfo, } from '../timezone';
+export { useHaptics, } from '../haptics';
+export { useGlobalLoading, type LoadingState, } from '../loading';

package/dist/index.d.ts

@@ -36,5 +36,6 @@
  *   /carousel     - Carousel components
  *   /init         - createAppInitializer, createEnvConfig
  *   /device       - DeviceService, useDeviceInfo
+ *   /core         - UnifiedCache, PermissionHandler, Repository utilities
  */
 export {};

package/dist/media/domain/strategies/CameraPickerStrategy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Camera Picker Strategy
+ *
+ * Strategy for capturing images/videos using device camera.
+ */
+import { PermissionManager } from '../../infrastructure/utils/PermissionManager';
+import type { PickerStrategy, LaunchOptions } from './PickerStrategy';
+import type { MediaLibraryPermission } from '../entities/Media';
+/**
+ * Camera picker strategy configuration
+ */
+export interface CameraPickerConfig {
+    mediaType: 'images' | 'videos';
+}
+/**
+ * Camera picker strategy implementation
+ */
+export declare class CameraPickerStrategy implements PickerStrategy {
+    private config;
+    private permissionManager;
+    readonly name = "CameraPicker";
+    constructor(config: CameraPickerConfig, permissionManager?: typeof PermissionManager);
+    getPermission(): Promise<MediaLibraryPermission>;
+    launch(options: LaunchOptions): Promise<any>;
+}

package/dist/media/domain/strategies/LibraryPickerStrategy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Library Picker Strategy
+ *
+ * Strategy for picking images/videos from device gallery.
+ */
+import { PermissionManager } from '../../infrastructure/utils/PermissionManager';
+import type { PickerStrategy, LaunchOptions } from './PickerStrategy';
+import type { MediaLibraryPermission } from '../entities/Media';
+/**
+ * Library picker strategy implementation
+ */
+export declare class LibraryPickerStrategy implements PickerStrategy {
+    private permissionManager;
+    readonly name = "LibraryPicker";
+    constructor(permissionManager?: typeof PermissionManager);
+    getPermission(): Promise<MediaLibraryPermission>;
+    launch(options: LaunchOptions): Promise<any>;
+}

package/dist/media/domain/strategies/PickerStrategy.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Media Picker Strategy Interface
+ *
+ * Strategy pattern for different media picker types.
+ * Allows MediaPickerService to support camera, video, and library pickers polymorphically.
+ */
+import type { MediaLibraryPermission } from '../entities/Media';
+/**
+ * Common picker options
+ */
+export interface LaunchOptions {
+    allowsEditing?: boolean;
+    quality?: number;
+    aspect?: [number, number];
+    videoMaxDuration?: number;
+    videoMaxBitrate?: number;
+    videoQuality?: 'low' | 'medium' | 'high';
+    base64?: boolean;
+    exif?: boolean;
+    allowsMultipleSelection?: boolean;
+    selectionLimit?: number;
+    mediaTypes?: string;
+    maxFileSizeMB?: number;
+}
+/**
+ * Result from picker launch
+ */
+export interface PickerLaunchResult {
+    canceled: boolean;
+    assets?: Array<{
+        uri: string;
+        width?: number;
+        height?: number;
+        type?: 'image' | 'video';
+        duration?: number;
+        fileSize?: number;
+    }>;
+}
+/**
+ * Media picker strategy interface
+ */
+export interface PickerStrategy {
+    /**
+     * Get required permission for this picker type
+     */
+    getPermission(): Promise<MediaLibraryPermission>;
+    /**
+     * Launch the picker with options
+     */
+    launch(options: LaunchOptions): Promise<PickerLaunchResult>;
+    /**
+     * Strategy name for debugging
+     */
+    readonly name: string;
+}

package/dist/media/domain/strategies/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Media Picker Strategies
+ *
+ * Strategy pattern implementations for different picker types.
+ */
+export type { PickerStrategy } from './PickerStrategy';
+export type { LaunchOptions, PickerLaunchResult } from './PickerStrategy';
+export { CameraPickerStrategy } from './CameraPickerStrategy';
+export type { CameraPickerConfig } from './CameraPickerStrategy';
+export { LibraryPickerStrategy } from './LibraryPickerStrategy';