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

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/core/shared/AsyncService.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Async Service Base - Shared Utilities
+ *
+ * Base class for services with automatic error handling.
+ */
+import type { Result } from './Result';
+export declare abstract class AsyncService {
+    protected readonly serviceName: string;
+    constructor(serviceName: string);
+    /**
+     * Execute async operation with automatic error handling
+     */
+    protected execute<T>(operation: string, fn: () => Promise<T>): Promise<Result<T>>;
+    /**
+     * Log error in development mode
+     */
+    protected logError(operation: string, error: unknown): void;
+    protected logWarning(message: string): void;
+    protected logInfo(message: string): void;
+}

package/dist/core/shared/Result.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Result Type - Shared Utilities
+ *
+ * Functional error handling without exceptions.
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+    error?: never;
+} | {
+    success: false;
+    data?: never;
+    error: E;
+};
+export declare const ResultHelper: {
+    ok: <T>(data: T) => Result<T>;
+    fail: <E = Error>(error: E) => Result<never, E>;
+    fromAsync: <T>(fn: () => Promise<T>) => Promise<Result<T, Error>>;
+    map: <T, U>(result: Result<T>, fn: (data: T) => U) => Result<U>;
+};

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

@@ -0,0 +1,5 @@
+/**
+ * Shared Core Utilities
+ */
+export * from './Result';
+export * from './AsyncService';

package/dist/device/detection/deviceDetection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Device Detection Utilities
+ *
+ * Uses expo-device (optional) for primary device type detection.
+ * Falls back to Platform.isPad + screen dimensions when expo-device is not installed.
+ */
+export declare enum DeviceType {
+    SMALL_PHONE = "SMALL_PHONE",
+    MEDIUM_PHONE = "MEDIUM_PHONE",
+    LARGE_PHONE = "LARGE_PHONE",
+    TABLET = "TABLET"
+}
+export declare const getScreenDimensions: () => {
+    width: number;
+    height: number;
+};
+export declare const isTablet: () => boolean;
+export declare const isPhone: () => boolean;
+export declare const isSmallPhone: (offset?: {
+    width: number;
+}) => boolean;
+export declare const isLargePhone: (offset?: {
+    width: number;
+}) => boolean;
+export declare const isLandscape: (offset?: {
+    width: number;
+    height: number;
+}) => boolean;
+export declare const getDeviceType: (offset?: {
+    width: number;
+}) => DeviceType;
+export declare const getSpacingMultiplier: (offset?: {
+    width: number;
+}) => number;

package/dist/device/detection/iPadBreakpoints.d.ts

@@ -0,0 +1,51 @@
+/**
+ * iPad Breakpoints and Constants
+ * Apple HIG compliant values for iPad responsive design
+ */
+/**
+ * iPad specific breakpoints following Apple HIG
+ */
+export declare const IPAD_BREAKPOINTS: {
+    readonly IPAD_MINI: 744;
+    readonly IPAD_10_2: 810;
+    readonly IPAD_AIR: 820;
+    readonly IPAD_11_PRO: 834;
+    readonly IPAD_12_9_PRO: 1024;
+    readonly IPAD_LANDSCAPE_MINI: 1133;
+    readonly IPAD_LANDSCAPE_AIR: 1180;
+    readonly IPAD_LANDSCAPE_PRO: 1366;
+};
+/**
+ * Apple HIG Touch Target Guidelines
+ */
+export declare const TOUCH_TARGETS: {
+    readonly MINIMUM: 44;
+    readonly RECOMMENDED: 48;
+    readonly IPAD_RECOMMENDED: 50;
+};
+/**
+ * Content width constraints for iPad
+ */
+export declare const CONTENT_WIDTH_CONSTRAINTS: {
+    readonly READABLE_MAX: 672;
+    readonly FORM_MAX: 580;
+    readonly CARD_MAX: 400;
+    readonly MODAL_MAX: 600;
+    readonly PAYWALL_MAX: 540;
+};
+/**
+ * iPad Layout Configuration
+ */
+export declare const IPAD_LAYOUT_CONFIG: {
+    readonly SCREEN_PADDING: 24;
+    readonly SECTION_SPACING: 32;
+    readonly CARD_SPACING: 20;
+    readonly GRID_COLUMNS_PORTRAIT: 2;
+    readonly GRID_COLUMNS_LANDSCAPE: 3;
+    readonly GRID_GAP: 20;
+    readonly MODAL_CORNER_RADIUS: 16;
+    readonly SHEET_CORNER_RADIUS: 20;
+    readonly MODAL_HORIZONTAL_MARGIN: 48;
+    readonly FONT_SCALE: 1.1;
+    readonly HEADING_SCALE: 1.15;
+};

package/dist/device/detection/iPadDetection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * iPad Device Detection Utilities
+ *
+ * Uses expo-device for system-level tablet detection,
+ * then uses screen dimensions for iPad-specific sub-categories.
+ *
+ * ⚠️ NOTE: These functions use Dimensions.get() which doesn't update on
+ * device rotation, iPad Split View, or Stage Manager. For reactive detection
+ * that updates on dimension changes, consider using useWindowDimensions() hook
+ * directly in your components.
+ */
+export declare function isIPad(): boolean;
+export declare function isIPadMini(): boolean;
+export declare function isIPadPro(): boolean;
+export declare function isIPadLandscape(): boolean;

package/dist/device/detection/iPadLayoutUtils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * iPad Layout Utilities
+ */
+/**
+ * Get optimal content max width based on screen size
+ */
+export declare function getContentMaxWidth(screenWidth: number): number;
+/**
+ * Get grid columns based on screen width
+ */
+export declare function getIPadGridColumns(screenWidth: number): number;
+/**
+ * Get touch target size based on device
+ */
+export declare function getTouchTargetSize(): number;
+/**
+ * Get screen padding based on device type
+ */
+export declare function getIPadScreenPadding(): number;
+/**
+ * Get font scale for iPad
+ * Optimized for readability - Apple HIG recommends slightly larger fonts on iPad
+ * but not too large to avoid crowding
+ */
+export declare function getIPadFontScale(): number;
+export interface IPadLayoutInfo {
+    isIPad: boolean;
+    isLandscape: boolean;
+    screenWidth: number;
+    screenHeight: number;
+    contentMaxWidth: number;
+    gridColumns: number;
+    touchTargetSize: number;
+    screenPadding: number;
+    fontScale: number;
+}
+/**
+ * Get complete iPad layout information
+ */
+export declare function getIPadLayoutInfo(): IPadLayoutInfo;

package/dist/device/detection/iPadModalUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * iPad Modal Utilities
+ * Modal dimensions optimized for iPad following Apple HIG
+ */
+export interface ModalDimensions {
+    width: number | string;
+    maxWidth: number;
+    maxHeight: string | number;
+    horizontalMargin: number;
+    borderRadius: number;
+}
+/**
+ * Get modal dimensions optimized for iPad
+ */
+export declare function getIPadModalDimensions(): ModalDimensions;
+export interface PaywallDimensions {
+    width: number | string;
+    maxWidth: number;
+    maxHeight: string | number;
+    padding: number;
+    buttonHeight: number;
+    priceTextScale: number;
+}
+/**
+ * Get paywall modal dimensions - Apple HIG compliant
+ */
+export declare function getPaywallDimensions(): PaywallDimensions;

package/dist/device/detection/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Device Detection Module - Public API
+ *
+ * Centralized device detection utilities including:
+ * - Device type detection (phone, tablet, iPad variants)
+ * - Screen dimension utilities
+ * - Layout utilities for different device types
+ */
+export { IPAD_BREAKPOINTS, TOUCH_TARGETS, CONTENT_WIDTH_CONSTRAINTS, IPAD_LAYOUT_CONFIG, } from './iPadBreakpoints';
+export { DeviceType, getScreenDimensions, isPhone, isSmallPhone, isLargePhone, isTablet, isLandscape, getDeviceType, getSpacingMultiplier, } from './deviceDetection';
+export { isIPad, isIPadMini, isIPadPro, isIPadLandscape, } from './iPadDetection';
+export { getContentMaxWidth, getIPadGridColumns, getTouchTargetSize, getIPadScreenPadding, getIPadFontScale, getIPadLayoutInfo, type IPadLayoutInfo, } from './iPadLayoutUtils';
+export { getIPadModalDimensions, getPaywallDimensions, type ModalDimensions, type PaywallDimensions, } from './iPadModalUtils';

package/dist/device/domain/entities/Device.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Device Domain - Core Entities
+ *
+ * This file defines core types and interfaces for device information.
+ * All types are self-contained - no external dependencies for types.
+ *
+ * @domain device
+ * @layer domain/entities
+ */
+/**
+ * Device type enumeration (matches expo-device values)
+ */
+export declare enum DeviceType {
+    UNKNOWN = 0,
+    PHONE = 1,
+    TABLET = 2,
+    DESKTOP = 3,
+    TV = 4
+}
+/**
+ * Device information interface
+ */
+export interface DeviceInfo {
+    brand: string | null;
+    manufacturer: string | null;
+    modelName: string | null;
+    modelId: string | null;
+    deviceName: string | null;
+    deviceYearClass: number | null;
+    deviceType: DeviceType | null;
+    isDevice: boolean;
+    osName: string | null;
+    osVersion: string | null;
+    osBuildId: string | null;
+    platformApiLevel: number | null;
+    totalMemory: number | null;
+    platform: 'ios' | 'android' | 'web';
+    timezone: string | null;
+    region: string | null;
+}
+/**
+ * Application information interface
+ */
+export interface ApplicationInfo {
+    applicationName: string;
+    applicationId: string;
+    nativeApplicationVersion: string | null;
+    nativeBuildVersion: string | null;
+    installTime: Date | null;
+    lastUpdateTime: Date | null;
+    androidId: string | null;
+    iosIdForVendor: string | null;
+}
+/**
+ * Combined device and app info
+ */
+export interface SystemInfo {
+    device: DeviceInfo;
+    application: ApplicationInfo;
+    timestamp: number;
+    userId?: string;
+}
+/**
+ * Device constants
+ */
+export declare const DEVICE_CONSTANTS: {
+    readonly DEVICE_TYPE: {
+        readonly UNKNOWN: 0;
+        readonly PHONE: 1;
+        readonly TABLET: 2;
+        readonly DESKTOP: 3;
+        readonly TV: 4;
+    };
+    readonly PLATFORM: {
+        readonly IOS: "ios";
+        readonly ANDROID: "android";
+        readonly WEB: "web";
+    };
+};

package/dist/device/domain/entities/DeviceFeatureConfig.d.ts

@@ -0,0 +1,21 @@
+export type ResetPeriod = 'daily' | 'weekly' | 'monthly' | 'never';
+export interface FeatureLimit {
+    maxUses: number;
+    resetPeriod: ResetPeriod;
+}
+export interface DeviceFeatureConfig {
+    features: Record<string, FeatureLimit>;
+}
+export interface DeviceFeatureUsage {
+    usageCount: number;
+    lastResetAt: number;
+    firstUsedAt: number;
+}
+export interface DeviceFeatureAccess {
+    isAllowed: boolean;
+    remainingUses: number;
+    usageCount: number;
+    resetAt: number | null;
+    maxUses: number;
+}
+export declare const DEFAULT_FEATURE_CONFIG: DeviceFeatureConfig;

package/dist/device/domain/entities/DeviceMemoryUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Device Memory Utilities
+ *
+ * Utility functions for device memory calculations and formatting
+ */
+/**
+ * Device memory utilities
+ */
+export declare class DeviceMemoryUtils {
+    /**
+     * Convert bytes to gigabytes
+     */
+    static bytesToGB(bytes: number): number;
+    /**
+     * Convert bytes to megabytes
+     */
+    static bytesToMB(bytes: number): number;
+    /**
+     * Format memory size to human readable string
+     */
+    static formatMemorySize(bytes: number | null): string;
+    /**
+     * Check if memory is sufficient for requirements
+     */
+    static hasSufficientMemory(totalMemory: number | null, requiredGB: number): boolean;
+    /**
+     * Get memory tier classification
+     */
+    static getMemoryTier(totalMemory: number | null): 'low' | 'mid' | 'high';
+}

package/dist/device/domain/entities/DeviceTypeUtils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Device Type Utilities
+ *
+ * Utility functions for device type detection
+ */
+import type { DeviceType } from './Device';
+/**
+ * Device type utilities
+ */
+export declare class DeviceTypeUtils {
+    /**
+     * Check if device is a tablet
+     */
+    static isTablet(deviceType: DeviceType | null): boolean;
+    /**
+     * Check if device is a phone
+     */
+    static isPhone(deviceType: DeviceType | null): boolean;
+    /**
+     * Check if device is desktop
+     */
+    static isDesktop(deviceType: DeviceType | null): boolean;
+    /**
+     * Check if device is TV
+     */
+    static isTV(deviceType: DeviceType | null): boolean;
+    /**
+     * Check if device type is unknown
+     */
+    static isUnknown(deviceType: DeviceType | null): boolean;
+    /**
+     * Get device type name
+     */
+    static getDeviceTypeName(deviceType: DeviceType | null): string;
+}

package/dist/device/domain/entities/DeviceUtils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Device Utilities
+ * Helper functions for processing device information
+ */
+import { DeviceInfo, ApplicationInfo } from './Device';
+export declare class DeviceUtils {
+    /**
+     * Check if running on physical device (not simulator/emulator)
+     */
+    static isPhysicalDevice(isDevice: boolean): boolean;
+    /**
+     * Get device display name
+     */
+    static getDeviceDisplayName(info: DeviceInfo): string;
+    /**
+     * Get OS display string
+     */
+    static getOSDisplayString(info: DeviceInfo): string;
+    /**
+     * Get app version string
+     */
+    static getAppVersionString(info: ApplicationInfo): string;
+    /**
+     * Check if device meets minimum requirements
+     */
+    static meetsMinimumRequirements(info: DeviceInfo, minMemoryGB?: number): {
+        meets: boolean;
+        reasons: string[];
+    };
+    /**
+     * Get device tier (low/mid/high) based on specs
+     */
+    static getDeviceTier(info: DeviceInfo): 'low' | 'mid' | 'high';
+}

package/dist/device/domain/types/AnonymousUserTypes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Anonymous User Types
+ *
+ * Type definitions for device-based anonymous user identification.
+ * Device ID is persistent across app reinstalls but device-specific.
+ *
+ * @domain device
+ * @layer domain/types
+ */
+/**
+ * Anonymous user data with persistent device-based identification
+ */
+export interface AnonymousUser {
+    /** Persistent device-based user ID (stable across sessions and reinstalls) */
+    userId: string;
+    /** User-friendly device name (e.g., "iPhone13-A8F2") */
+    deviceName: string;
+    /** Display name for the anonymous user */
+    displayName: string;
+    /** Always true for anonymous users */
+    isAnonymous: boolean;
+}
+/**
+ * Options for anonymous user hook
+ */
+export interface UseAnonymousUserOptions {
+    /** Custom display name for anonymous user */
+    anonymousDisplayName?: string;
+    /** Fallback user ID if device ID generation fails */
+    fallbackUserId?: string;
+}
+/**
+ * Return type for useAnonymousUser hook
+ */
+export interface UseAnonymousUserResult {
+    /** Anonymous user data with persistent device-based ID */
+    anonymousUser: AnonymousUser | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if ID generation failed */
+    error: string | null;
+    /** Refresh function to reload user data */
+    refresh: () => Promise<void>;
+}

package/dist/device/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Device Module - Public API
+ *
+ * Complete device utilities including:
+ * - Device detection (phone, tablet, iPad variants)
+ * - Device info and capabilities
+ * - Anonymous user management
+ */
+export { IPAD_BREAKPOINTS, TOUCH_TARGETS, CONTENT_WIDTH_CONSTRAINTS, IPAD_LAYOUT_CONFIG, DeviceType, getScreenDimensions, isPhone, isSmallPhone, isLargePhone, isTablet, isLandscape, getDeviceType, getSpacingMultiplier, isIPad, isIPadMini, isIPadPro, isIPadLandscape, getContentMaxWidth, getIPadGridColumns, getTouchTargetSize, getIPadScreenPadding, getIPadFontScale, getIPadLayoutInfo, type IPadLayoutInfo, getIPadModalDimensions, getPaywallDimensions, type ModalDimensions, type PaywallDimensions, } from './detection';
+export type { DeviceInfo, ApplicationInfo, SystemInfo, DeviceType as DeviceInfoType, } from './domain/entities/Device';
+export { DEVICE_CONSTANTS, } from './domain/entities/Device';
+export { DeviceUtils } from './domain/entities/DeviceUtils';
+export type { DeviceFeatureConfig, DeviceFeatureUsage, DeviceFeatureAccess, FeatureLimit, ResetPeriod, } from './domain/entities/DeviceFeatureConfig';
+export { DEFAULT_FEATURE_CONFIG } from './domain/entities/DeviceFeatureConfig';
+export { DeviceTypeUtils } from './domain/entities/DeviceTypeUtils';
+export { DeviceMemoryUtils } from './domain/entities/DeviceMemoryUtils';
+export { DeviceService } from './infrastructure/services/DeviceService';
+export { UserFriendlyIdService } from './infrastructure/services/UserFriendlyIdService';
+import { PersistentDeviceIdService } from './infrastructure/services/PersistentDeviceIdService';
+export { PersistentDeviceIdService };
+export { DeviceFeatureService } from './infrastructure/services/DeviceFeatureService';
+export { collectDeviceExtras } from './infrastructure/services/DeviceExtrasCollector';
+export type { DeviceExtras } from './infrastructure/services/DeviceExtrasCollector';
+export { SecureDeviceIdRepository } from './infrastructure/repositories/SecureDeviceIdRepository';
+export { useDeviceInfo, useDeviceCapabilities, useDeviceId, } from './presentation/hooks/useDeviceInfo';
+export { useAnonymousUser, } from './presentation/hooks/useAnonymousUser';
+export type { AnonymousUser, UseAnonymousUserOptions, UseAnonymousUserResult, } from './domain/types/AnonymousUserTypes';
+export { useDeviceFeatures } from './presentation/hooks/useDeviceFeatures';
+/**
+ * Get anonymous user ID for services
+ */
+export declare function getAnonymousUserId(): Promise<string>;

package/dist/device/infrastructure/repositories/SecureDeviceIdRepository.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Secure Device ID Repository
+ *
+ * Uses iOS Keychain with AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY for:
+ * - Persistence across app reinstalls
+ * - Device-specific (no backup migration)
+ * - Accessible after first unlock (background tasks)
+ *
+ * @domain device
+ * @layer infrastructure/repositories
+ */
+export declare class SecureDeviceIdRepository {
+    get(): Promise<string | null>;
+    set(deviceId: string): Promise<void>;
+    hasMigrated(): Promise<boolean>;
+    setMigrated(): Promise<void>;
+    remove(): Promise<void>;
+}

package/dist/device/infrastructure/services/ApplicationInfoService.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Application Info Service
+ *
+ * Single Responsibility: Get application information from native modules
+ * Follows SOLID principles - only handles application info retrieval
+ */
+import type { ApplicationInfo } from '../../domain/entities/Device';
+/**
+ * Service for retrieving application information
+ */
+export declare class ApplicationInfoService {
+    /**
+     * Get application information
+     * SAFE: Returns minimal info if native modules are not ready
+     */
+    static getApplicationInfo(): Promise<ApplicationInfo>;
+    /**
+     * Get minimal application info (fallback)
+     */
+    private static getMinimalApplicationInfo;
+}