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

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

@@ -0,0 +1,25 @@
+/**
+ * ScreenLayout Component
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface ScreenLayoutProps {
+    children: React.ReactNode;
+    scrollable?: boolean;
+    edges?: ('top' | 'bottom' | 'left' | 'right')[];
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    backgroundColor?: string;
+    containerStyle?: StyleProp<ViewStyle>;
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+    hideScrollIndicator?: boolean;
+    keyboardAvoiding?: boolean;
+    keyboardVerticalOffset?: number;
+    maxWidth?: number;
+    fullWidth?: boolean;
+    refreshControl?: any;
+    accessibilityLabel?: string;
+    accessible?: boolean;
+}
+export declare const ScreenLayout: React.FC<ScreenLayoutProps>;

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

@@ -0,0 +1,4 @@
+/**
+ * Screen Layout Component
+ */
+export { ScreenLayout } 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,12 @@
+/**
+ * Layouts - Layout components for screen and container composition
+ *
+ * Usage:
+ *   import { ScreenLayout, Container, FormLayout } from "@umituz/react-native-design-system/layouts";
+ */
+export * from './AppHeader';
+export * from './Container';
+export * from './FormLayout';
+export * from './Grid';
+export * from './ScreenHeader';
+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"];
+};

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';

package/dist/media/domain/utils/FileValidator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * File Validator
+ *
+ * File size and format validation utilities for media operations.
+ */
+import type { MediaAsset } from "../entities/Media";
+import { MediaValidationError } from "../entities/Media";
+/**
+ * File validation options
+ */
+export interface FileValidationOptions {
+    maxFileSizeMB?: number;
+    allowedFormats?: string[];
+}
+/**
+ * File validation result
+ */
+export interface FileValidationResult {
+    valid: boolean;
+    error?: MediaValidationError;
+    errorMessage?: string;
+}
+/**
+ * File validator for media operations
+ */
+export declare class FileValidator {
+    /**
+     * Validates file size against maximum limit
+     *
+     * @param fileSize - File size in bytes
+     * @param maxSizeMB - Maximum file size in megabytes
+     * @returns Validation result
+     */
+    static validateFileSize(fileSize: number, maxSizeMB?: number): FileValidationResult;
+    /**
+     * Validates file format against allowed formats
+     *
+     * @param fileName - File name to check
+     * @param allowedFormats - Array of allowed file extensions
+     * @returns Validation result
+     */
+    static validateFileFormat(fileName: string, allowedFormats?: string[]): FileValidationResult;
+    /**
+     * Validates a media asset
+     *
+     * @param asset - Media asset to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    static validateAsset(asset: MediaAsset, options?: FileValidationOptions): FileValidationResult;
+    /**
+     * Validates multiple media assets
+     *
+     * @param assets - Array of media assets to validate
+     * @param options - Validation options
+     * @returns First validation error found, or { valid: true } if all pass
+     */
+    static validateAssets(assets: MediaAsset[], options?: FileValidationOptions): FileValidationResult;
+    /**
+     * Formats file size for display
+     *
+     * @param fileSize - File size in bytes
+     * @returns Formatted file size string (e.g., "1.5 MB")
+     */
+    static formatFileSize(fileSize: number): string;
+}

package/dist/media/domain/utils/MediaUtils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Media Utilities
+ * Utility functions for media operations
+ */
+import { ImageFormat, MediaType } from "../entities/Media";
+/**
+ * Image MIME type mappings
+ */
+export declare const IMAGE_MIME_TYPES: {
+    readonly png: "image/png";
+    readonly jpeg: "image/jpeg";
+    readonly webp: "image/webp";
+};
+/**
+ * Media utility class
+ */
+export declare class MediaUtils {
+    static isImage(uri: string): boolean;
+    static isVideo(uri: string): boolean;
+    static getImageMimeType(format: ImageFormat): string;
+    static calculateAspectRatio(width: number, height: number): number;
+    static getScaledDimensions(originalWidth: number, originalHeight: number, maxWidth: number, maxHeight: number): {
+        width: number;
+        height: number;
+    };
+    static isValidDimensions(width: number, height: number): boolean;
+    static parseMediaType(mimeType: string): MediaType;
+}

package/dist/media/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @umituz/react-native-media - Public API
+ *
+ * Media picking capabilities for React Native apps
+ *
+ * Usage:
+ *   import {
+ *     useMedia,
+ *     MediaPickerService,
+ *     type MediaAsset,
+ *     type MediaPickerResult,
+ *   } from '@umituz/react-native-media';
+ */
+export { MediaType, ImageFormat as MediaImageFormat, MediaQuality, MediaLibraryPermission, MediaValidationError, MEDIA_CONSTANTS, } from "./domain/entities/Media";
+export { IMAGE_MIME_TYPES as MEDIA_IMAGE_MIME_TYPES, MediaUtils } from "./domain/utils/MediaUtils";
+export type { MediaAsset, MediaPickerResult, MediaPickerOptions, CameraOptions, ImageDimensions as MediaImageDimensions, ImageManipulationActions, ImageSaveOptions as MediaImageSaveOptions, } from "./domain/entities/Media";
+export { MediaPickerService } from "./infrastructure/services/MediaPickerService";
+export { MediaSaveService } from "./infrastructure/services/MediaSaveService";
+export type { SaveResult, SaveOptions } from "./infrastructure/services/MediaSaveService";
+export { useMedia } from "./presentation/hooks/useMedia";
+export { getMediaTypeFromUrl, isVideoUrl, isImageUrl, isAudioUrl, type UrlMediaType, } from "./infrastructure/utils/url-media-detector";
+export { getMediaTypeFromMime, isVideoMime, isImageMime, isAudioMime, type MimeMediaType, } from "./infrastructure/utils/mime-type-detector";
+export { extractMediaUrl, extractVideoUrl, extractImageUrl, type MediaUrlResult, } from "./infrastructure/utils/media-url-extractor";
+export { extractMediaTypes, calculateTotalSize, formatFileSize, } from "./infrastructure/utils/media-collection-utils";
+export { getMediaDuration, generateThumbnail, isBase64DataUrl, isRawBase64, toDataUrl, saveBase64ToFile, downloadMediaToFile, saveImageToGallery, saveVideoToGallery, type SaveToGalleryResult, } from "./infrastructure/utils/file-media-utils";

package/dist/media/infrastructure/services/MediaPickerService.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Media Domain - Media Picker Service
+ *
+ * Service for picking images/videos using expo-image-picker.
+ * Refactored to use strategy pattern to reduce code duplication.
+ *
+ * Before: 182 LOC with 4 similar methods
+ * After: ~120 LOC with 1 generic launcher + convenience wrappers - 34% reduction
+ */
+import type { MediaPickerOptions, MediaPickerResult, CameraOptions } from '../../domain/entities/Media';
+import type { PickerStrategy, LaunchOptions } from '../../domain/strategies/PickerStrategy';
+/**
+ * Media picker service for selecting images/videos
+ * Uses strategy pattern to support different picker types
+ */
+export declare class MediaPickerService {
+    /**
+     * Generic media picker launcher using strategy pattern
+     *
+     * @param strategy - Picker strategy to use
+     * @param options - Picker options
+     * @returns Picker result
+     *
+     * @example
+     * ```ts
+     * const strategy = new CameraPickerStrategy({ mediaType: 'images' });
+     * const result = await MediaPickerService.launchMediaPicker(strategy, {
+     *   quality: 0.8,
+     *   allowsEditing: true
+     * });
+     * ```
+     */
+    static launchMediaPicker(strategy: PickerStrategy, options?: LaunchOptions): Promise<MediaPickerResult>;
+    /**
+     * Launch camera for image capture
+     */
+    static launchCamera(options?: CameraOptions): Promise<MediaPickerResult>;
+    /**
+     * Launch camera for video capture
+     */
+    static launchCameraForVideo(options?: CameraOptions): Promise<MediaPickerResult>;
+    /**
+     * Pick from library with file size validation
+     */
+    static pickFromLibrary(options?: MediaPickerOptions): Promise<MediaPickerResult>;
+    /**
+     * Pick single image from library
+     */
+    static pickSingleImage(options?: Omit<MediaPickerOptions, 'allowsMultipleSelection'>): Promise<MediaPickerResult>;
+    /**
+     * Pick multiple images from library
+     */
+    static pickMultipleImages(options?: Omit<MediaPickerOptions, 'allowsMultipleSelection'>): Promise<MediaPickerResult>;
+    /**
+     * Pick video from library
+     */
+    static pickVideo(options?: Omit<MediaPickerOptions, 'mediaTypes'>): Promise<MediaPickerResult>;
+    /**
+     * Pick any media from library
+     */
+    static pickMedia(options?: MediaPickerOptions): Promise<MediaPickerResult>;
+}

package/dist/media/infrastructure/services/MediaSaveService.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Media Save Service
+ * Saves media to device storage using expo-file-system
+ */
+import { MediaLibraryPermission } from "../../domain/entities/Media";
+export interface SaveResult {
+    success: boolean;
+    path?: string;
+    error?: string;
+}
+export interface SaveOptions {
+    album?: string;
+}
+/**
+ * Service for saving media to gallery
+ */
+export declare class MediaSaveService {
+    /**
+     * Request media library write permission
+     */
+    static requestPermission(): Promise<MediaLibraryPermission>;
+    /**
+     * Get current permission status
+     */
+    static getPermissionStatus(): Promise<MediaLibraryPermission>;
+    /**
+     * Save image to gallery
+     */
+    static saveImage(uri: string, options?: SaveOptions): Promise<SaveResult>;
+    /**
+     * Save video to gallery
+     */
+    static saveVideo(uri: string, options?: SaveOptions): Promise<SaveResult>;
+    /**
+     * Save media (image or video) to storage
+     */
+    private static saveToStorage;
+}