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

package/dist/constants/index.d.ts

@@ -0,0 +1,263 @@
+/**
+ * Centralized Design System Constants
+ *
+ * All base size configurations for components.
+ * Prevents file proliferation and makes maintenance easier.
+ */
+export declare const AVATAR_SIZES: {
+    readonly xs: {
+        readonly size: 24;
+        readonly fontSize: 10;
+        readonly iconSize: 12;
+        readonly statusSize: 6;
+        readonly borderWidth: 1;
+    };
+    readonly sm: {
+        readonly size: 32;
+        readonly fontSize: 12;
+        readonly iconSize: 16;
+        readonly statusSize: 8;
+        readonly borderWidth: 1.5;
+    };
+    readonly md: {
+        readonly size: 40;
+        readonly fontSize: 14;
+        readonly iconSize: 20;
+        readonly statusSize: 10;
+        readonly borderWidth: 2;
+    };
+    readonly lg: {
+        readonly size: 56;
+        readonly fontSize: 18;
+        readonly iconSize: 28;
+        readonly statusSize: 12;
+        readonly borderWidth: 2;
+    };
+    readonly xl: {
+        readonly size: 80;
+        readonly fontSize: 24;
+        readonly iconSize: 40;
+        readonly statusSize: 16;
+        readonly borderWidth: 2.5;
+    };
+    readonly xxl: {
+        readonly size: 120;
+        readonly fontSize: 36;
+        readonly iconSize: 60;
+        readonly statusSize: 20;
+        readonly borderWidth: 3;
+    };
+};
+export declare const ICON_SIZES: {
+    readonly tiny: 16;
+    readonly xs: 24;
+    readonly sm: 28;
+    readonly md: 32;
+    readonly lg: 40;
+    readonly xl: 56;
+    readonly xxl: 80;
+};
+export declare const BUTTON_SIZES: {
+    readonly sm: {
+        readonly paddingVertical: 8;
+        readonly paddingHorizontal: 14;
+        readonly fontSize: 10;
+        readonly iconSize: 16;
+        readonly minHeight: 32;
+    };
+    readonly md: {
+        readonly paddingVertical: 14;
+        readonly paddingHorizontal: 20;
+        readonly fontSize: 16;
+        readonly iconSize: 20;
+        readonly minHeight: 44;
+    };
+    readonly lg: {
+        readonly paddingVertical: 16;
+        readonly paddingHorizontal: 24;
+        readonly fontSize: 18;
+        readonly iconSize: 24;
+        readonly minHeight: 52;
+    };
+};
+export declare const FAB_SIZE = 56;
+export declare const INPUT_SIZES: {
+    readonly sm: {
+        readonly paddingVertical: 8;
+        readonly paddingHorizontal: 12;
+        readonly fontSize: 12;
+        readonly iconSize: 16;
+        readonly minHeight: 40;
+    };
+    readonly md: {
+        readonly paddingVertical: 12;
+        readonly paddingHorizontal: 16;
+        readonly fontSize: 16;
+        readonly iconSize: 20;
+        readonly minHeight: 48;
+    };
+    readonly lg: {
+        readonly paddingVertical: 16;
+        readonly paddingHorizontal: 20;
+        readonly fontSize: 18;
+        readonly iconSize: 24;
+        readonly minHeight: 56;
+    };
+};
+export declare const CARD_SIZES: {
+    readonly padding: 16;
+    readonly borderRadius: 12;
+    readonly elevation: 2;
+};
+export declare const MODAL_SIZES: {
+    readonly maxWidth: 360;
+    readonly padding: 28;
+    readonly overlayPadding: 24;
+};
+export declare const BOTTOM_SHEET_HANDLE: {
+    readonly width: 40;
+    readonly height: 4;
+    readonly borderRadius: 2;
+};
+export declare const LIST_ITEM: {
+    readonly minHeight: 56;
+    readonly paddingVertical: 12;
+    readonly paddingHorizontal: 16;
+};
+export declare const INFO_GRID_ICONS: {
+    readonly small: 28;
+    readonly large: 32;
+};
+export declare const NAVIGATION: {
+    readonly backButton: {
+        readonly width: 40;
+        readonly height: 40;
+    };
+    readonly tabBar: {
+        readonly height: 60;
+    };
+    readonly headerHeight: 60;
+};
+export declare const FONT_SIZES: {
+    readonly labelSmall: 10;
+    readonly bodySmall: 12;
+    readonly bodyMedium: 16;
+    readonly bodyLarge: 18;
+    readonly titleSmall: 20;
+    readonly titleMedium: 24;
+    readonly titleLarge: 28;
+    readonly headlineSmall: 32;
+    readonly headlineMedium: 36;
+    readonly displaySmall: 40;
+    readonly displayLarge: 48;
+};
+export declare const COUNTDOWN_SIZES: {
+    readonly small: {
+        readonly fontSize: 24;
+        readonly minHeight: 70;
+    };
+    readonly medium: {
+        readonly fontSize: 32;
+        readonly minHeight: 90;
+    };
+    readonly large: {
+        readonly fontSize: 40;
+        readonly minHeight: 110;
+    };
+};
+export declare const HERO_ICON: {
+    readonly width: 120;
+    readonly height: 120;
+    readonly borderRadius: 60;
+};
+export declare const EMPTY_STATE_ICON: {
+    readonly width: 120;
+    readonly height: 120;
+    readonly borderRadius: 60;
+};
+export declare const ALERT_MODAL_ICON: {
+    readonly width: 76;
+    readonly height: 76;
+    readonly borderRadius: 38;
+    readonly marginBottom: 20;
+};
+export declare const SPACING: {
+    readonly xs: 4;
+    readonly sm: 8;
+    readonly md: 12;
+    readonly lg: 16;
+    readonly xl: 20;
+    readonly xxl: 24;
+};
+export declare const STEP_INDICATOR: {
+    readonly dot: {
+        readonly width: 8;
+        readonly height: 8;
+        readonly borderRadius: 4;
+        readonly marginHorizontal: 4;
+    };
+    readonly progressBar: {
+        readonly height: 4;
+        readonly borderRadius: 2;
+    };
+    readonly stepHeader: {
+        readonly marginBottom: 32;
+        readonly paddingHorizontal: 24;
+    };
+    readonly title: 28;
+    readonly subtitle: 16;
+};
+export declare const DIVIDER_SIZES: {
+    readonly none: 0;
+    readonly small: 8;
+    readonly medium: 16;
+    readonly large: 24;
+};
+export declare const MISC_SIZES: {
+    readonly searchIcon: 32;
+    readonly searchInputHeight: 48;
+    readonly searchBorderRadius: 24;
+    readonly searchPadding: 2;
+    readonly swipeButtonMinWidth: 80;
+    readonly splashMinHeight: 40;
+    readonly countdownIcon: 36;
+};
+export declare const AVATAR_COLORS: readonly ["#7E57C2", "#42A5F5", "#66BB6A", "#FFA726", "#EF5350", "#26C6DA", "#AB47BC", "#FF7043"];
+export declare const STATUS_COLORS: {
+    readonly online: "#4CAF50";
+    readonly offline: "#9E9E9E";
+    readonly away: "#FFC107";
+    readonly busy: "#F44336";
+};
+export declare const SHAPE_CONFIGS: {
+    readonly rounded: 8;
+    readonly squared: 0;
+    readonly square: 0;
+};
+export declare const FAB_SIZES: {
+    readonly sm: 40;
+    readonly md: 56;
+    readonly lg: 72;
+};
+export declare const CALENDAR: {
+    readonly dayPadding: 16;
+    readonly dayNamePadding: 4;
+    readonly selectedBorderWidth: 4;
+    readonly borderRadius: 12;
+    readonly borderRadiusSm: 8;
+    readonly borderRadiusXs: 2;
+    readonly dayNameFontSize: 8;
+};
+export declare const CONFIRMATION_MODAL: {
+    readonly padding: 24;
+    readonly borderRadius: 16;
+    readonly width: "85%";
+};
+export declare const ICON_GRID: {
+    readonly borderRadius: 24;
+    readonly fontSize: 11;
+};
+export declare const COUNTDOWN_TOGGLE: {
+    readonly size: 36;
+    readonly borderRadius: 18;
+};

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,18 @@
+/**
+ * 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';
+export * from './shared';

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;