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

package/dist/init/env/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Environment Configuration Types
+ */
+/**
+ * Environment source configuration
+ */
+export interface EnvSourceConfig {
+    /** Expo Constants extra config */
+    expoExtra?: Record<string, unknown>;
+    /** Process env (for EXPO_PUBLIC_ vars) */
+    processEnv?: Record<string, string | undefined>;
+}
+/**
+ * Key mapping from EXPO_PUBLIC_ to extra key
+ */
+export interface EnvKeyMapping {
+    /** Environment variable name (e.g., 'EXPO_PUBLIC_FAL_API_KEY') */
+    envKey: string;
+    /** Extra config key (e.g., 'falApiKey') */
+    extraKey: string;
+}
+/**
+ * RevenueCat configuration
+ */
+export interface RevenueCatEnvConfig {
+    /** iOS API key */
+    iosKey?: string;
+    /** Android API key */
+    androidKey?: string;
+    /** Test store key (for development) */
+    testStoreKey?: string;
+}
+/**
+ * FAL AI configuration
+ */
+export interface FalEnvConfig {
+    /** API key */
+    apiKey?: string;
+    /** Base URL (default: https://fal.run) */
+    baseUrl?: string;
+}
+/**
+ * Firebase configuration
+ */
+export interface FirebaseEnvConfig {
+    apiKey?: string;
+    authDomain?: string;
+    projectId?: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+}
+/**
+ * Full environment configuration
+ */
+export interface EnvConfig {
+    revenueCat?: RevenueCatEnvConfig;
+    fal?: FalEnvConfig;
+    firebase?: FirebaseEnvConfig;
+    /** Custom keys */
+    custom?: Record<string, string | undefined>;
+}
+/**
+ * Created environment accessor
+ */
+export interface EnvAccessor {
+    /** Get RevenueCat API key (platform-specific) */
+    getRevenueCatApiKey: () => string;
+    /** Get RevenueCat test store key (dev only) */
+    getRevenueCatTestStoreKey: () => string | undefined;
+    /** Get FAL API key */
+    getFalApiKey: () => string;
+    /** Get FAL base URL */
+    getFalBaseUrl: () => string;
+    /** Get Firebase config */
+    getFirebaseConfig: () => FirebaseEnvConfig;
+    /** Get custom env value */
+    get: (key: string) => string | undefined;
+}

package/dist/init/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * App Initialization Module
+ *
+ * Provides utilities for app initialization:
+ * - createAppInitializer: Factory for creating app initializers
+ * - useAppInitialization: Hook for managing initialization state
+ * - createEnvConfig: Environment configuration factory
+ */
+export { createAppInitializer, createInitModule, } from "./createAppInitializer";
+export { useAppInitialization } from "./useAppInitialization";
+export * from "./env";
+export type { InitModule, AppInitializerConfig, AppInitializerResult, UseAppInitializationOptions, UseAppInitializationReturn, } from "./types";

package/dist/init/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * App Initialization Types
+ */
+/**
+ * Single initialization module
+ */
+export interface InitModule {
+    /** Module name for logging */
+    name: string;
+    /** Initialize function - returns success status */
+    init: () => Promise<boolean> | boolean;
+    /** Optional: Whether this module is critical (default: false) */
+    critical?: boolean;
+    /** Optional: Dependencies - other module names that must run first */
+    dependsOn?: string[];
+}
+/**
+ * App initializer configuration
+ */
+export interface AppInitializerConfig {
+    /** Initialization modules to run */
+    modules: InitModule[];
+    /** Enable debug logging (default: __DEV__) */
+    debug?: boolean;
+    /** Continue on non-critical module failure (default: true) */
+    continueOnError?: boolean;
+    /** Callback when all modules complete */
+    onComplete?: () => void;
+    /** Callback on error */
+    onError?: (moduleName: string, error: unknown) => void;
+}
+/**
+ * App initializer result
+ */
+export interface AppInitializerResult {
+    success: boolean;
+    failedModules: string[];
+    duration: number;
+}
+/**
+ * useAppInitialization hook options
+ */
+export interface UseAppInitializationOptions {
+    /** Skip initialization (useful for testing) */
+    skip?: boolean;
+    /** Callback when initialization completes */
+    onReady?: () => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * useAppInitialization hook return type
+ */
+export interface UseAppInitializationReturn {
+    isReady: boolean;
+    isLoading: boolean;
+    error: Error | null;
+}

package/dist/init/useAppInitialization.d.ts

@@ -0,0 +1,19 @@
+/**
+ * useAppInitialization Hook
+ * Manages app initialization state in React components
+ */
+import type { UseAppInitializationOptions, UseAppInitializationReturn, AppInitializerResult } from "./types";
+/**
+ * Hook to manage app initialization
+ *
+ * @example
+ * ```typescript
+ * const { isReady, isLoading, error } = useAppInitialization(initializeApp, {
+ * });
+ *
+ * if (isLoading) return <SplashScreen />;
+ * if (error) return <ErrorScreen error={error} />;
+ * return <App />;
+ * ```
+ */
+export declare function useAppInitialization(initializer: () => Promise<AppInitializerResult>, options?: UseAppInitializationOptions): UseAppInitializationReturn;

package/dist/layouts/AppHeader/AppHeader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AppHeader Organism - Application Header Component
+ *
+ * Complex header combining atoms and molecules
+ * Generic component suitable for any application
+ *
+ * Atomic Design Level: ORGANISM
+ * Composition: AtomicIcon + AtomicText + AtomicButton
+ */
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+import { type IconName } from '../../atoms';
+/**
+ * AppHeader component props
+ *
+ * leftIcon/rightIcon: Any MaterialIcons name
+ * @see https://fonts.google.com/icons
+ */
+export interface AppHeaderProps {
+    title: string;
+    subtitle?: string;
+    leftIcon?: IconName;
+    onLeftPress?: () => void;
+    rightIcon?: IconName;
+    onRightPress?: () => void;
+    backgroundColor?: string;
+    style?: ViewStyle;
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+    accessible?: boolean;
+}
+export declare const AppHeader: React.FC<AppHeaderProps>;

package/dist/layouts/Container/Container.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Container - Max-Width Content Container (Molecule)
+ *
+ * Centers content with responsive max-width based on device
+ * Prevents content from being too wide on tablets
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface ContainerProps {
+    /** Container content */
+    children: React.ReactNode;
+    /** Maximum width (default: responsive based on device) */
+    maxWidth?: number;
+    /** Horizontal padding (uses responsive tokens) */
+    padding?: boolean;
+    /** Center content horizontally */
+    center?: boolean;
+    /** Container style */
+    style?: StyleProp<ViewStyle>;
+    /** Test ID */
+    testID?: string;
+}
+/**
+ * Responsive container with max-width
+ *
+ * @example
+ * ```tsx
+ * <Container maxWidth={600} padding center>
+ *   <Text>Centered content with max width</Text>
+ * </Container>
+ * ```
+ */
+export declare const Container: React.FC<ContainerProps>;

package/dist/layouts/Container/index.d.ts

@@ -0,0 +1 @@
+export { Container, type ContainerProps } from './Container';

package/dist/layouts/FormLayout/FormLayout.d.ts

@@ -0,0 +1,36 @@
+/**
+ * FormLayout - Responsive Form Container
+ *
+ * Organism for creating responsive forms with consistent spacing
+ * Automatically handles keyboard avoidance and scrolling
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface FormLayoutProps {
+    /** Form fields and content */
+    children: React.ReactNode;
+    /** Footer content (e.g., submit button) */
+    footer?: React.ReactNode;
+    /** Form container style */
+    style?: StyleProp<ViewStyle>;
+    /** Disable keyboard avoiding behavior */
+    disableKeyboardAvoid?: boolean;
+    /** Disable scroll */
+    disableScroll?: boolean;
+    /** Test ID */
+    testID?: string;
+}
+/**
+ * Responsive form layout with keyboard avoidance
+ *
+ * @example
+ * ```tsx
+ * <FormLayout
+ *   footer={<AtomicButton title="Submit" onPress={handleSubmit} />}
+ * >
+ *   <FormField label="Name" value={name} onChangeText={setName} />
+ *   <FormField label="Email" value={email} onChangeText={setEmail} />
+ * </FormLayout>
+ * ```
+ */
+export declare const FormLayout: React.FC<FormLayoutProps>;

package/dist/layouts/FormLayout/index.d.ts

@@ -0,0 +1 @@
+export { FormLayout, type FormLayoutProps } from './FormLayout';

package/dist/layouts/Grid/Grid.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Grid - Responsive Grid Layout (Molecule)
+ *
+ * Automatic responsive grid that adjusts columns based on device
+ * Uses design system responsive utilities
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface GridProps {
+    /** Grid items to render */
+    children: React.ReactNode;
+    /** Number of columns on mobile (default: 2) */
+    mobileColumns?: number;
+    /** Number of columns on tablet (default: 4) */
+    tabletColumns?: number;
+    /** Gap between grid items (uses design tokens spacing) */
+    gap?: number;
+    /** Container style */
+    style?: StyleProp<ViewStyle>;
+    /** Test ID for testing */
+    testID?: string;
+}
+/**
+ * Responsive grid component
+ *
+ * @example
+ * ```tsx
+ * <Grid mobileColumns={2} tabletColumns={4} gap={16}>
+ *   <Card />
+ *   <Card />
+ *   <Card />
+ * </Grid>
+ * ```
+ */
+export declare const Grid: React.FC<GridProps>;

package/dist/layouts/Grid/index.d.ts

@@ -0,0 +1 @@
+export { Grid, type GridProps } from './Grid';

package/dist/layouts/ScreenHeader/ScreenHeader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ScreenHeader Component
+ *
+ * Reusable screen header with consistent back button placement
+ *
+ * Features:
+ * - Top-left back button (configurable icon)
+ * - Centered title text
+ * - Optional right action button
+ * - Consistent spacing and layout
+ * - Theme-aware styling
+ * - Fully configurable for general purpose use
+ */
+import React from 'react';
+import { ViewStyle } from 'react-native';
+export interface ScreenHeaderProps {
+    /** Screen title (centered) */
+    title: string;
+    /** Optional right action button */
+    rightAction?: React.ReactNode;
+    /** Custom back button action (required if back button is visible) */
+    onBackPress?: () => void;
+    /** Hide back button (rare cases only) */
+    hideBackButton?: boolean;
+    /** Additional header style */
+    style?: ViewStyle;
+    /** Test ID for E2E testing */
+    testID?: string;
+    /** Custom back button icon name */
+    backIconName?: string;
+    /** Custom back button icon color */
+    backIconColor?: 'primary' | 'secondary' | 'error' | 'warning' | 'success' | 'surfaceVariant';
+}
+export declare const ScreenHeader: React.FC<ScreenHeaderProps>;

package/dist/layouts/ScreenLayout/ScreenLayout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ScreenLayout Component
+ */
+import React from 'react';
+import type { ScreenLayoutProps } from './types';
+export declare const ScreenLayout: React.FC<ScreenLayoutProps>;
+export type { ScreenLayoutProps } from './types';

package/dist/layouts/ScreenLayout/index.d.ts

@@ -0,0 +1 @@
+export * from './ScreenLayout';

package/dist/layouts/ScreenLayout/styles/screenLayoutStyles.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ScreenLayout Styles
+ */
+export interface ScreenLayoutStylesConfig {
+    readonly maxWidth?: number;
+    readonly horizontalPadding: number;
+    readonly verticalPadding: number;
+}
+export declare const getScreenLayoutStyles: (config: ScreenLayoutStylesConfig) => {
+    container: {
+        flex: number;
+    };
+    keyboardAvoidingView: {
+        flex: number;
+    };
+    responsiveWrapper: {
+        maxWidth?: number | undefined;
+        alignSelf?: "center" | undefined;
+        flex: number;
+        width: "100%";
+    };
+    scrollView: {
+        flex: number;
+    };
+    scrollContent: {
+        flexGrow: number;
+        paddingTop: number;
+        paddingHorizontal: number;
+        paddingBottom: number;
+    };
+};

package/dist/layouts/ScreenLayout/types/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ScreenLayout Type Definitions
+ */
+import type { ViewStyle } from 'react-native';
+import type { Edge } from 'react-native-safe-area-context';
+import type { RefreshControlProps } from 'react-native';
+export interface ScreenLayoutProps {
+    readonly children: React.ReactNode;
+    readonly scrollable?: boolean;
+    readonly edges?: Edge[];
+    readonly header?: React.ReactNode;
+    readonly footer?: React.ReactNode;
+    readonly backgroundColor?: string;
+    readonly containerStyle?: ViewStyle;
+    readonly contentContainerStyle?: ViewStyle;
+    readonly testID?: string;
+    readonly hideScrollIndicator?: boolean;
+    readonly keyboardAvoiding?: boolean;
+    readonly keyboardVerticalOffset?: number;
+    readonly accessibilityLabel?: string;
+    readonly accessibilityHint?: string;
+    readonly accessible?: boolean;
+    readonly maxWidth?: number;
+    /** Disable maxWidth constraint (useful for full-bleed layouts like paginated FlatLists) */
+    readonly fullWidth?: boolean;
+    readonly refreshControl?: React.ReactElement<RefreshControlProps>;
+}

package/dist/layouts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Container';
+export * from './FormLayout';
+export * from './Grid';
+export * from './ScreenLayout';

package/dist/loading/domain/types/loading.types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Loading Types
+ * Type definitions for global loading system
+ */
+export type LoadingSource = 'navigation' | 'fetch' | 'manual';
+export interface LoadingState {
+    isLoading: boolean;
+    message?: string;
+    source?: LoadingSource;
+    count: number;
+}
+export interface LoadingActions {
+    show: (message?: string, source?: LoadingSource) => void;
+    hide: (source?: LoadingSource) => void;
+    reset: () => void;
+}
+export interface LoadingStore extends LoadingState, LoadingActions {
+}
+export interface LoadingProviderProps {
+    children: React.ReactNode;
+    spinnerColor?: string;
+    spinnerSize?: 'sm' | 'md' | 'lg' | 'xl';
+    overlayColor?: string;
+    defaultMessage?: string;
+    detectNavigation?: boolean;
+    detectFetching?: boolean;
+    minDisplayTime?: number;
+}
+export interface LoadingOverlayProps {
+    visible: boolean;
+    message?: string;
+    spinnerColor?: string;
+    spinnerSize?: 'sm' | 'md' | 'lg' | 'xl';
+    overlayColor?: string;
+}

package/dist/loading/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Loading Module
+ * Global loading state management and auto-detection
+ */
+export type { LoadingSource, LoadingState, LoadingActions, LoadingStore, LoadingProviderProps, LoadingOverlayProps, } from './domain/types/loading.types';
+export { useLoadingStore } from './infrastructure/store/LoadingStore';
+export { LoadingOverlay } from './presentation/components/LoadingOverlay';
+export { useGlobalLoading } from './presentation/hooks/useGlobalLoading';
+export { LoadingProvider } from './presentation/providers/LoadingProvider';

package/dist/loading/infrastructure/store/LoadingStore.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LoadingStore
+ * Global loading state management with Zustand
+ */
+import type { LoadingStore } from '../../domain/types/loading.types';
+export declare const useLoadingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<LoadingStore>>;

package/dist/loading/presentation/components/LoadingOverlay.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LoadingOverlay Component
+ * Full-screen loading overlay with spinner
+ */
+import React from 'react';
+import type { LoadingOverlayProps } from '../../domain/types/loading.types';
+export declare const LoadingOverlay: React.FC<LoadingOverlayProps>;

package/dist/loading/presentation/hooks/useGlobalLoading.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useGlobalLoading Hook
+ * Manual control for global loading state
+ */
+interface UseGlobalLoadingReturn {
+    isLoading: boolean;
+    message?: string;
+    show: (message?: string) => void;
+    hide: () => void;
+    withLoading: <T>(asyncFn: () => Promise<T>, message?: string) => Promise<T>;
+}
+export declare function useGlobalLoading(): UseGlobalLoadingReturn;
+export {};

package/dist/loading/presentation/providers/LoadingProvider.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LoadingProvider
+ * Global loading provider with auto-detection
+ */
+import React from 'react';
+import type { LoadingProviderProps } from '../../domain/types/loading.types';
+export declare const LoadingProvider: React.FC<LoadingProviderProps>;

package/dist/media/domain/entities/Media.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Media Domain - Core Entities
+ *
+ * Core types and interfaces for media operations.
+ * Handles images, videos, and media library interactions.
+ */
+/**
+ * Media type enumeration
+ */
+export declare enum MediaType {
+    IMAGE = "image",
+    VIDEO = "video",
+    ALL = "all"
+}
+/**
+ * Image format enumeration
+ */
+export declare enum ImageFormat {
+    PNG = "png",
+    JPEG = "jpeg",
+    WEBP = "webp"
+}
+/**
+ * Media quality enumeration
+ */
+export declare enum MediaQuality {
+    LOW = 0.3,
+    MEDIUM = 0.7,
+    HIGH = 1
+}
+/**
+ * Media library permissions
+ */
+export declare enum MediaLibraryPermission {
+    GRANTED = "granted",
+    DENIED = "denied",
+    LIMITED = "limited"
+}
+/**
+ * Image dimensions interface
+ */
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Image manipulation actions
+ */
+export interface ImageManipulationActions {
+    resize?: ImageDimensions;
+    crop?: {
+        originX: number;
+        originY: number;
+        width: number;
+        height: number;
+    };
+    rotate?: number;
+    flip?: {
+        horizontal?: boolean;
+        vertical?: boolean;
+    };
+}
+/**
+ * Image save options
+ */
+export interface ImageSaveOptions {
+    quality?: MediaQuality;
+    format?: ImageFormat;
+    base64?: boolean;
+}
+/**
+ * Media picker options
+ */
+export interface MediaPickerOptions {
+    mediaTypes?: MediaType;
+    allowsEditing?: boolean;
+    allowsMultipleSelection?: boolean;
+    aspect?: [number, number];
+    quality?: MediaQuality;
+    selectionLimit?: number;
+    base64?: boolean;
+    maxFileSizeMB?: number;
+}
+/**
+ * Media validation error types
+ */
+export declare enum MediaValidationError {
+    FILE_TOO_LARGE = "FILE_TOO_LARGE",
+    INVALID_FORMAT = "INVALID_FORMAT",
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    PICKER_ERROR = "PICKER_ERROR"
+}
+/**
+ * Media asset interface
+ */
+export interface MediaAsset {
+    uri: string;
+    width: number;
+    height: number;
+    type: MediaType;
+    fileSize?: number;
+    fileName?: string;
+    duration?: number;
+    base64?: string;
+    mimeType?: string;
+}
+/**
+ * Media picker result
+ */
+export interface MediaPickerResult {
+    canceled: boolean;
+    assets?: MediaAsset[];
+    error?: MediaValidationError;
+    errorMessage?: string;
+}
+/**
+ * Camera options
+ */
+export interface CameraOptions {
+    quality?: MediaQuality;
+    allowsEditing?: boolean;
+    aspect?: [number, number];
+    base64?: boolean;
+    videoMaxDuration?: number;
+}
+/**
+ * Media constants
+ */
+export declare const MEDIA_CONSTANTS: {
+    readonly MAX_IMAGE_SIZE_MB: 5;
+    readonly MAX_VIDEO_SIZE_MB: 100;
+    readonly MAX_IMAGE_SIZE: number;
+    readonly MAX_VIDEO_SIZE: number;
+    readonly DEFAULT_QUALITY: MediaQuality.HIGH;
+    readonly DEFAULT_FORMAT: ImageFormat.JPEG;
+    readonly DEFAULT_ASPECT_RATIO: [number, number];
+    readonly DEFAULT_SELECTION_LIMIT: 10;
+    readonly SUPPORTED_IMAGE_FORMATS: readonly [".jpg", ".jpeg", ".png", ".gif", ".webp"];
+    readonly SUPPORTED_VIDEO_FORMATS: readonly [".mp4", ".mov"];
+};