@umituz/react-native-design-system 4.25.98 → 4.25.100

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

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+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;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Device Capability Service
+ *
+ * Single Responsibility: Check device capabilities and features
+ * Follows SOLID principles - only handles capability checks
+ */
+/**
+ * Service for checking device capabilities
+ */
+export declare class DeviceCapabilityService {
+    /**
+     * Check if device supports specific features
+     */
+    static getDeviceCapabilities(): Promise<{
+        isDevice: boolean;
+        isTablet: boolean;
+        hasNotch: boolean;
+        totalMemoryGB: number | null;
+    }>;
+    /**
+     * Check if device has notch/dynamic island from existing info
+     */
+    private static hasNotchFromInfo;
+    /**
+     * Check if device has notch/dynamic island
+     */
+    static hasNotch(): Promise<boolean>;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Device Extras Collector
+ *
+ * Collects device and application information for user documents.
+ * Used with @umituz/react-native-auth's UserDocumentService.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+/**
+ * Device extras for user documents
+ * Compatible with UserDocumentExtras from @umituz/react-native-auth
+ * Index signature added for Record<string, unknown> compatibility
+ */
+export interface DeviceExtras {
+    [key: string]: string | number | boolean | undefined;
+    /** The stable ID stored in Keychain/SecureStore */
+    deviceId: string;
+    /** Alias for deviceId for clarity in Firestore */
+    persistentDeviceId: string;
+    /** The raw native platform ID (IDFV on iOS, Android ID on Android) */
+    nativeDeviceId: string;
+    platform: string;
+    deviceModel: string;
+    deviceBrand: string;
+    deviceName: string;
+    deviceType: number | string;
+    deviceYearClass: number | string;
+    isDevice: boolean;
+    osName: string;
+    osVersion: string;
+    osBuildId: string;
+    totalMemory: number | string;
+    appVersion: string;
+    buildNumber: string;
+    locale: string;
+    region: string;
+    timezone: string;
+    screenWidth: number;
+    screenHeight: number;
+    screenScale: number;
+    fontScale: number;
+    isLandscape: boolean;
+}
+/**
+ * Collect device extras for user documents
+ *
+ * @example
+ * ```typescript
+ * import { collectDeviceExtras } from '@umituz/react-native-design-system';
+ * import { initializeAuth } from '@umituz/react-native-auth';
+ *
+ * await initializeAuth({
+ *   userCollection: 'users',
+ *   collectExtras: collectDeviceExtras,
+ * });
+ * ```
+ */
+export declare function collectDeviceExtras(): Promise<DeviceExtras>;

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

@@ -0,0 +1,22 @@
+/**
+ * Device Feature Service
+ *
+ * Generic service for tracking device-based feature usage.
+ * Apps configure feature limits via props, service tracks usage.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+import type { DeviceFeatureConfig, DeviceFeatureAccess } from '../../domain/entities/DeviceFeatureConfig';
+export declare class DeviceFeatureService {
+    private static config;
+    static setConfig(config: DeviceFeatureConfig): void;
+    static checkFeatureAccess(featureName: string): Promise<DeviceFeatureAccess>;
+    static incrementFeatureUsage(featureName: string): Promise<void>;
+    private static getFeatureUsage;
+    private static setFeatureUsage;
+    private static resetFeatureUsage;
+    private static shouldResetUsage;
+    private static calculateNextReset;
+    private static getStorageKey;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Device ID Service
+ *
+ * Single Responsibility: Get device unique identifiers
+ * Follows SOLID principles - only handles device ID retrieval
+ */
+/**
+ * Service for retrieving device unique identifiers
+ */
+export declare class DeviceIdService {
+    /**
+     * Get device unique identifier (platform-specific)
+     *
+     * WARNING: Use with caution - user privacy considerations!
+     * Android: androidId (can be reset)
+     * iOS: iosIdForVendor (changes on reinstall)
+     * Web: null (not supported)
+     *
+     * SAFE: Returns null if native modules are not ready
+     */
+    static getDeviceId(): Promise<string | null>;
+    /**
+     * Get offline user ID with fallback (iOS/Android only)
+     *
+     * For offline apps that need a persistent user ID:
+     * 1. Try to get platform-specific device ID (iOS/Android)
+     * 2. Fallback to a default offline user ID if device ID not available
+     *
+     * NOTE: Returns null for web platform (not supported)
+     */
+    static getOfflineUserId(fallbackId?: string): Promise<string | null>;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Device Info Service
+ *
+ * Single Responsibility: Get device information from native modules.
+ * Uses expo-device (optional peer dep) with safe fallback.
+ */
+import type { DeviceInfo } from '../../domain/entities/Device';
+export declare class DeviceInfoService {
+    static getDeviceInfo(): Promise<DeviceInfo>;
+    private static getMinimalDeviceInfo;
+}

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

@@ -0,0 +1,66 @@
+/**
+ * Device Service - Facade/Orchestrator
+ *
+ * Main entry point for device operations.
+ * Delegates to specialized services following Single Responsibility Principle.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+import type { DeviceInfo, ApplicationInfo, SystemInfo } from '../../domain/entities/Device';
+/**
+ * Device Service - Facade for all device operations
+ *
+ * This is a facade that delegates to specialized services.
+ * Each service has a single responsibility (SOLID principles).
+ */
+export declare class DeviceService {
+    /**
+     * Get device information
+     * Delegates to DeviceInfoService
+     */
+    static getDeviceInfo(): Promise<DeviceInfo>;
+    /**
+     * Get application information
+     * Delegates to ApplicationInfoService
+     */
+    static getApplicationInfo(): Promise<ApplicationInfo>;
+    /**
+     * Get complete system information (device + app)
+     * @param options - Optional configuration
+     * @param options.userId - Optional user ID to include in system info
+     */
+    static getSystemInfo(options?: {
+        userId?: string;
+    }): Promise<SystemInfo>;
+    /**
+     * Get device unique identifier (platform-specific)
+     * Delegates to DeviceIdService
+     */
+    static getDeviceId(): Promise<string | null>;
+    /**
+     * Get offline user ID with fallback
+     * Delegates to DeviceIdService
+     */
+    static getOfflineUserId(fallbackId?: string): Promise<string | null>;
+    /**
+     * Check if device supports specific features
+     * Delegates to DeviceCapabilityService
+     */
+    static getDeviceCapabilities(): Promise<{
+        isDevice: boolean;
+        isTablet: boolean;
+        hasNotch: boolean;
+        totalMemoryGB: number | null;
+    }>;
+    /**
+     * Check if device has notch/dynamic island
+     * Delegates to DeviceCapabilityService
+     */
+    static hasNotch(): Promise<boolean>;
+    /**
+     * Get user friendly device ID
+     * Delegates to UserFriendlyIdService
+     */
+    static getUserFriendlyId(): Promise<string>;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Persistent Device ID Service
+ *
+ * Provides a stable device identifier that survives app reinstalls.
+ * Priority: SecureStore (true keychain persistence) > Migration > Native ID > Generated UUID
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+export declare class PersistentDeviceIdService {
+    private static secureRepo;
+    /**
+     * Get device ID with caching and concurrent request handling
+     */
+    static getDeviceId(): Promise<string>;
+    /**
+     * Logic to establish a persistent ID
+     */
+    private static initializeDeviceId;
+    /**
+     * Generates a new ID based on platform info if possible
+     */
+    private static createNewDeviceId;
+    /**
+     * Check if an ID exists without initializing
+     */
+    static hasStoredId(): Promise<boolean>;
+    /**
+     * Fully clear all stored identifiers
+     */
+    static clearStoredId(): Promise<void>;
+    /**
+     * Get current cached ID synchronously
+     */
+    static getCachedId(): string | null;
+}