@umituz/react-native-design-system 4.23.102 → 4.23.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "4.23.102",
+  "version": "4.23.103",
   "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID, image, timezone, offline, onboarding, and loading utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/media/index.ts

@@ -1,16 +1,14 @@
 /**
- * @umituz/react-native-media - Enhanced Public API
+ * @umituz/react-native-media - Public API
  *
  * Media picking capabilities for React Native apps
- * Includes multimedia flashcard support
  *
  * Usage:
  *   import {
  *     useMedia,
- *     useMultimediaFlashcard,
- *     MultimediaFlashcardService,
- *     type MediaAttachment,
- *     type MultimediaFlashcard,
+ *     MediaPickerService,
+ *     type MediaAsset,
+ *     type MediaPickerResult,
  *   } from '@umituz/react-native-media';
  */
 
@@ -90,33 +88,3 @@ export {
   saveVideoToGallery,
   type SaveToGalleryResult,
 } from "./infrastructure/utils/file-media-utils";
-
-// Media Attachment Types (Clean, no aliases)
-export type {
-  MediaAttachmentType,
-  MediaPosition,
-  MediaAttachment,
-  MultimediaFlashcard,
-  MediaGenerationRequest,
-  MediaGenerationResult,
-  MediaUploadProgress,
-  MediaCompressionOptions,
-  MediaValidation,
-  MediaFile,
-  CreateMultimediaCardData,
-} from "./domain/entities/MediaAttachments";
-
-// Media Attachment Hooks
-export { useMediaUpload } from "./presentation/hooks/useMediaUpload";
-export { useMediaGeneration } from "./presentation/hooks/useMediaGeneration";
-export { useMediaValidation } from "./presentation/hooks/useMediaValidation";
-export { useMultimediaFlashcard } from "./presentation/hooks/useMultimediaFlashcard";
-export type {
-  UseMediaUploadResult,
-  UseMediaGenerationResult,
-  UseMediaValidationResult,
-  UseMultimediaFlashcardResult,
-} from "./presentation/hooks/multimedia.types";
-
-// Media Attachment Services
-export { MultimediaFlashcardService } from "./infrastructure/services/MultimediaFlashcardService";

package/src/media/infrastructure/services/MediaPickerService.ts

@@ -0,0 +1,157 @@
+/**
+ * Media Domain - Media Picker Service
+ *
+ * Service for picking images/videos using expo-image-picker.
+ * Handles camera, gallery, and media library permissions.
+ */
+
+import * as ImagePicker from "expo-image-picker";
+import type {
+  MediaPickerOptions,
+  MediaPickerResult,
+  CameraOptions,
+} from "../../domain/entities/Media";
+import {
+  MediaType,
+  MediaValidationError,
+  MEDIA_CONSTANTS,
+} from "../../domain/entities/Media";
+import {
+  mapMediaType,
+  mapPickerResult,
+} from "../utils/mediaPickerMappers";
+import { PermissionManager } from "../utils/PermissionManager";
+import { FileValidator } from "../../domain/utils/FileValidator";
+
+/**
+ * Media picker service for selecting images/videos
+ */
+export class MediaPickerService {
+  static async launchCamera(
+    options?: CameraOptions
+  ): Promise<MediaPickerResult> {
+    try {
+      const permission = await PermissionManager.requestCameraPermission();
+      if (!PermissionManager.isPermissionGranted(permission)) {
+        return { canceled: true };
+      }
+
+      const result = await ImagePicker.launchCameraAsync({
+        mediaTypes: ["images"],
+        allowsEditing: options?.allowsEditing ?? false,
+        aspect: options?.aspect,
+        quality: options?.quality ?? MEDIA_CONSTANTS.DEFAULT_QUALITY,
+        base64: options?.base64 ?? false,
+      });
+
+      return mapPickerResult(result);
+    } catch {
+      return { canceled: true };
+    }
+  }
+
+  static async launchCameraForVideo(
+    options?: CameraOptions
+  ): Promise<MediaPickerResult> {
+    try {
+      const permission = await PermissionManager.requestCameraPermission();
+      if (!PermissionManager.isPermissionGranted(permission)) {
+        return { canceled: true };
+      }
+
+      const result = await ImagePicker.launchCameraAsync({
+        mediaTypes: ["videos"],
+        allowsEditing: options?.allowsEditing ?? false,
+        quality: options?.quality ?? MEDIA_CONSTANTS.DEFAULT_QUALITY,
+        videoMaxDuration: options?.videoMaxDuration,
+      });
+
+      return mapPickerResult(result);
+    } catch {
+      return { canceled: true };
+    }
+  }
+
+  static async pickImage(
+    options?: MediaPickerOptions
+  ): Promise<MediaPickerResult> {
+    try {
+      const permission = await PermissionManager.requestMediaLibraryPermission();
+      if (!PermissionManager.isPermissionGranted(permission)) {
+        return {
+          canceled: true,
+          error: MediaValidationError.PERMISSION_DENIED,
+          errorMessage: "Permission to access media library was denied",
+        };
+      }
+
+      const result = await ImagePicker.launchImageLibraryAsync({
+        mediaTypes: mapMediaType(options?.mediaTypes),
+        allowsEditing: options?.allowsEditing ?? false,
+        allowsMultipleSelection: options?.allowsMultipleSelection ?? false,
+        aspect: options?.aspect,
+        quality: options?.quality ?? MEDIA_CONSTANTS.DEFAULT_QUALITY,
+        selectionLimit:
+          options?.selectionLimit ?? MEDIA_CONSTANTS.DEFAULT_SELECTION_LIMIT,
+        base64: options?.base64 ?? false,
+      });
+
+      const mappedResult = mapPickerResult(result);
+
+      // Validate file size if not canceled and has assets
+      if (!mappedResult.canceled && mappedResult.assets && mappedResult.assets.length > 0) {
+        const validation = FileValidator.validateAssets(mappedResult.assets, {
+          maxFileSizeMB: options?.maxFileSizeMB,
+        });
+
+        if (!validation.valid) {
+          return {
+            canceled: true,
+            error: validation.error,
+            errorMessage: validation.errorMessage,
+          };
+        }
+      }
+
+      return mappedResult;
+    } catch {
+      return { canceled: true };
+    }
+  }
+
+  static async pickSingleImage(
+    options?: Omit<MediaPickerOptions, "allowsMultipleSelection">
+  ): Promise<MediaPickerResult> {
+    return MediaPickerService.pickImage({
+      ...options,
+      allowsMultipleSelection: false,
+    });
+  }
+
+  static async pickMultipleImages(
+    options?: Omit<MediaPickerOptions, "allowsMultipleSelection">
+  ): Promise<MediaPickerResult> {
+    return MediaPickerService.pickImage({
+      ...options,
+      allowsMultipleSelection: true,
+    });
+  }
+
+  static async pickVideo(
+    options?: Omit<MediaPickerOptions, "mediaTypes">
+  ): Promise<MediaPickerResult> {
+    return MediaPickerService.pickImage({
+      ...options,
+      mediaTypes: MediaType.VIDEO,
+    });
+  }
+
+  static async pickMedia(
+    options?: MediaPickerOptions
+  ): Promise<MediaPickerResult> {
+    return MediaPickerService.pickImage({
+      ...options,
+      mediaTypes: MediaType.ALL,
+    });
+  }
+}

package/src/media/infrastructure/services/MediaSaveService.ts

@@ -0,0 +1,97 @@
+/**
+ * Media Save Service
+ * Saves media to device storage using expo-file-system
+ */
+
+import * as FileSystem from "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 class MediaSaveService {
+  /**
+   * Request media library write permission
+   */
+  static async requestPermission(): Promise<MediaLibraryPermission> {
+    return MediaLibraryPermission.GRANTED;
+  }
+
+  /**
+   * Get current permission status
+   */
+  static async getPermissionStatus(): Promise<MediaLibraryPermission> {
+    return MediaLibraryPermission.GRANTED;
+  }
+
+  /**
+   * Save image to gallery
+   */
+  static async saveImage(
+    uri: string,
+    options?: SaveOptions,
+  ): Promise<SaveResult> {
+    return MediaSaveService.saveToStorage(uri, "image", options);
+  }
+
+  /**
+   * Save video to gallery
+   */
+  static async saveVideo(
+    uri: string,
+    options?: SaveOptions,
+  ): Promise<SaveResult> {
+    return MediaSaveService.saveToStorage(uri, "video", options);
+  }
+
+  /**
+   * Save media (image or video) to storage
+   */
+  private static async saveToStorage(
+    uri: string,
+    mediaType: "image" | "video",
+    _options?: SaveOptions,
+  ): Promise<SaveResult> {
+    try {
+      const timestamp = Date.now();
+      const extension = mediaType === "image" ? "jpg" : "mp4";
+      const filename = `${mediaType}_${timestamp}.${extension}`;
+
+      const directory = (FileSystem as { documentDirectory?: string | null }).documentDirectory;
+      if (!directory) {
+        return {
+          success: false,
+          error: "Document directory not available",
+        };
+      }
+
+      const destination = `${directory}${filename}`;
+
+      await FileSystem.copyAsync({
+        from: uri,
+        to: destination,
+      });
+
+      return {
+        success: true,
+        path: destination,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        success: false,
+        error: `Failed to save media: ${message}`,
+      };
+    }
+  }
+}

package/src/media/infrastructure/utils/media-collection-utils.ts

@@ -1,14 +1,28 @@
-import type { MediaAttachment } from "../../domain/entities/MediaAttachments";
-
-// CardMediaAttachment is an alias of MediaAttachment
-type CardMediaAttachment = MediaAttachment;
+/**
+ * Media Collection Utilities
+ * Generic utilities for working with media collections
+ */
 
 type MediaType = "image" | "audio" | "video";
 
 const FILE_SIZE_UNITS = ["Bytes", "KB", "MB", "GB"] as const;
 
+/**
+ * Interface for media items with type property
+ */
+interface MediaWithType {
+  type: MediaType;
+}
+
+/**
+ * Interface for media items with file size
+ */
+interface MediaWithSize {
+  fileSize: number;
+}
+
 export function extractMediaTypes(
-  media: readonly (CardMediaAttachment | MediaAttachment)[]
+  media: readonly MediaWithType[]
 ): MediaType[] {
   const types = new Set<MediaType>();
   media.forEach((m) => types.add(m.type));
@@ -16,7 +30,7 @@ export function extractMediaTypes(
 }
 
 export function calculateTotalSize(
-  media: readonly (CardMediaAttachment | MediaAttachment)[]
+  media: readonly MediaWithSize[]
 ): number {
   return media.reduce((total, m) => total + m.fileSize, 0);
 }

package/src/media/presentation/hooks/useMedia.ts

@@ -0,0 +1,190 @@
+/**
+ * Media Domain - useMedia Hook
+ *
+ * React hook for media picking operations (images, videos).
+ * Provides camera, gallery picking functionality.
+ */
+
+import { useState, useCallback } from "react";
+import { MediaPickerService } from "../../infrastructure/services/MediaPickerService";
+import { PermissionManager } from "../../infrastructure/utils/PermissionManager";
+import type {
+  MediaPickerOptions,
+  MediaPickerResult,
+  CameraOptions,
+} from "../../domain/entities/Media";
+import { MediaLibraryPermission } from "../../domain/entities/Media";
+
+/**
+ * useMedia hook for complete media workflow
+ *
+ * USAGE:
+ * ```typescript
+ * const {
+ *   pickImage,
+ *   pickMultipleImages,
+ *   launchCamera,
+ *   isLoading,
+ *   error,
+ * } = useMedia();
+ *
+ * const handlePickImage = async () => {
+ *   const result = await pickImage({ allowsEditing: true });
+ *   if (!result.canceled && result.assets) {
+ *   }
+ * };
+ * ```
+ */
+export const useMedia = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const pickImage = useCallback(
+    async (options?: MediaPickerOptions): Promise<MediaPickerResult> => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await MediaPickerService.pickSingleImage(options);
+        // Set error from validation result if present
+        if (result.errorMessage) {
+          setError(result.errorMessage);
+        }
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to pick image";
+        setError(errorMessage);
+        return { canceled: true };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  const pickMultipleImages = useCallback(
+    async (options?: MediaPickerOptions): Promise<MediaPickerResult> => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await MediaPickerService.pickMultipleImages(options);
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to pick images";
+        setError(errorMessage);
+        return { canceled: true };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  const pickVideo = useCallback(
+    async (options?: MediaPickerOptions): Promise<MediaPickerResult> => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await MediaPickerService.pickVideo(options);
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to pick video";
+        setError(errorMessage);
+        return { canceled: true };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  const launchCamera = useCallback(
+    async (options?: CameraOptions): Promise<MediaPickerResult> => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await MediaPickerService.launchCamera(options);
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to launch camera";
+        setError(errorMessage);
+        return { canceled: true };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  const launchCameraForVideo = useCallback(
+    async (options?: CameraOptions): Promise<MediaPickerResult> => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await MediaPickerService.launchCameraForVideo(options);
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to record video";
+        setError(errorMessage);
+        return { canceled: true };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  const requestCameraPermission =
+    useCallback(async (): Promise<MediaLibraryPermission> => {
+      try {
+        return await PermissionManager.requestCameraPermission();
+      } catch {
+        return MediaLibraryPermission.DENIED;
+      }
+    }, []);
+
+  const requestMediaLibraryPermission =
+    useCallback(async (): Promise<MediaLibraryPermission> => {
+      try {
+        return await PermissionManager.requestMediaLibraryPermission();
+      } catch {
+        return MediaLibraryPermission.DENIED;
+      }
+    }, []);
+
+  const getCameraPermissionStatus =
+    useCallback(async (): Promise<MediaLibraryPermission> => {
+      try {
+        return await PermissionManager.getCameraPermissionStatus();
+      } catch {
+        return MediaLibraryPermission.DENIED;
+      }
+    }, []);
+
+  const getMediaLibraryPermissionStatus =
+    useCallback(async (): Promise<MediaLibraryPermission> => {
+      try {
+        return await PermissionManager.getMediaLibraryPermissionStatus();
+      } catch {
+        return MediaLibraryPermission.DENIED;
+      }
+    }, []);
+
+  return {
+    pickImage,
+    pickMultipleImages,
+    pickVideo,
+    launchCamera,
+    launchCameraForVideo,
+    requestCameraPermission,
+    requestMediaLibraryPermission,
+    getCameraPermissionStatus,
+    getMediaLibraryPermissionStatus,
+    isLoading,
+    error,
+  };
+};