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

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

@@ -1,96 +0,0 @@
-/**
- * Multimedia Flashcard Service
- * Media attachments for flashcards - Main entry point
- */
-
-import type {
-  MediaAttachment,
-  MediaFile,
-  MediaGenerationRequest,
-  MediaGenerationResult,
-  MediaCompressionOptions,
-  MediaValidation,
-} from "../../domain/entities/MediaAttachments";
-import { MediaUploadService } from "./MediaUploadService";
-import { MediaGenerationService } from "./MediaGenerationService";
-import { MediaValidationService } from "./MediaValidationService";
-import { MediaOptimizerService } from "./MediaOptimizerService";
-
-export class MultimediaFlashcardService {
-  private static instance: MultimediaFlashcardService;
-  private uploadService: MediaUploadService;
-  private generationService: MediaGenerationService;
-  private validationService: MediaValidationService;
-  private optimizerService: MediaOptimizerService;
-
-  private constructor() {
-    this.uploadService = new MediaUploadService();
-    this.generationService = new MediaGenerationService();
-    this.validationService = new MediaValidationService();
-    this.optimizerService = new MediaOptimizerService();
-  }
-
-  static getInstance(): MultimediaFlashcardService {
-    if (!MultimediaFlashcardService.instance) {
-      MultimediaFlashcardService.instance = new MultimediaFlashcardService();
-    }
-    return MultimediaFlashcardService.instance;
-  }
-
-  /**
-   * Upload media file with optional compression
-   */
-  async uploadMedia(
-    file: MediaFile,
-    options?: MediaCompressionOptions,
-  ): Promise<MediaAttachment> {
-    return this.uploadService.uploadMedia(file, options);
-  }
-
-  /**
-   * Generate media from AI (text-to-image, text-to-audio, etc.)
-   */
-  async generateMedia(
-    request: MediaGenerationRequest,
-  ): Promise<MediaGenerationResult> {
-    return this.generationService.generateMedia(request);
-  }
-
-  /**
-   * Validate media file before upload
-   */
-  async validateMedia(file: MediaFile): Promise<MediaValidation> {
-    return this.validationService.validateMedia(file);
-  }
-
-  /**
-   * Optimize media file
-   */
-  async optimizeMedia(
-    attachment: MediaAttachment,
-    options: MediaCompressionOptions,
-  ): Promise<MediaAttachment> {
-    return this.optimizerService.optimizeMedia(attachment, options);
-  }
-
-  /**
-   * Delete media attachment
-   */
-  async deleteMedia(attachmentId: string): Promise<void> {
-    return this.optimizerService.deleteMedia(attachmentId);
-  }
-
-  /**
-   * Get media URL
-   */
-  async getMediaUrl(attachmentId: string): Promise<string> {
-    return this.uploadService.getMediaUrl(attachmentId);
-  }
-
-  /**
-   * Download media to local storage
-   */
-  async downloadMedia(attachmentId: string): Promise<string> {
-    return this.uploadService.downloadMedia(attachmentId);
-  }
-}

package/src/media/presentation/hooks/multimedia.types.ts

@@ -1,53 +0,0 @@
-/**
- * Multimedia Flashcard Hook Types
- * Type definitions for multimedia hooks
- */
-
-import type {
-  MediaAttachment,
-  MediaFile,
-  MediaGenerationRequest,
-  MediaGenerationResult,
-  MediaCompressionOptions,
-  MediaValidation,
-  MediaUploadProgress,
-  MultimediaFlashcard,
-  CreateMultimediaCardData,
-} from "../../domain/entities/MediaAttachments";
-
-export interface UseMediaUploadResult {
-  uploadMedia: (
-    file: MediaFile,
-    options?: MediaCompressionOptions,
-  ) => Promise<MediaAttachment>;
-  isUploading: boolean;
-  uploadProgress: MediaUploadProgress | null;
-  error: string | null;
-}
-
-export interface UseMediaGenerationResult {
-  generateMedia: (
-    request: MediaGenerationRequest,
-  ) => Promise<MediaGenerationResult>;
-  isGenerating: boolean;
-  generationResult: MediaGenerationResult | null;
-  error: string | null;
-}
-
-export interface UseMediaValidationResult {
-  validateMedia: (file: MediaFile) => Promise<MediaValidation>;
-  isValidating: boolean;
-  validation: MediaValidation | null;
-  error: string | null;
-}
-
-export interface UseMultimediaFlashcardResult {
-  createMultimediaCard: (cardData: CreateMultimediaCardData) => Promise<MultimediaFlashcard>;
-  updateMedia: (
-    cardId: string,
-    media: MediaAttachment[],
-  ) => Promise<MultimediaFlashcard>;
-  deleteMedia: (attachmentId: string) => Promise<void>;
-  isProcessing: boolean;
-  error: string | null;
-}

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

@@ -1,102 +0,0 @@
-/**
- * Card Multimedia Flashcard Hooks
- * Main hook and exports for card multimedia functionality
- */
-
-import { useState, useCallback } from "react";
-import { calculateTotalSize, extractMediaTypes } from "../../infrastructure/utils/media-collection-utils";
-import type { UseCardMultimediaFlashcardResult } from "./card-multimedia.types";
-import type {
-  MediaAttachment as CardMediaAttachment,
-  MultimediaFlashcard as CardMultimediaFlashcard,
-  CreateMultimediaCardData as CreateCardMultimediaData,
-} from "../../domain/entities/MediaAttachments";
-
-// Export individual hooks
-export { useCardMediaUpload } from "./useCardMediaUpload";
-export { useCardMediaGeneration } from "./useCardMediaGeneration";
-export { useCardMediaValidation } from "./useCardMediaValidation";
-
-// Export types
-export type {
-  UseCardMediaUploadResult,
-  UseCardMediaGenerationResult,
-  UseCardMediaValidationResult,
-  UseCardMultimediaFlashcardResult,
-} from "./card-multimedia.types";
-
-/**
- * Main hook for card multimedia flashcard operations
- */
-export const useCardMultimediaFlashcard =
-  (): UseCardMultimediaFlashcardResult => {
-    const [isProcessing, setIsProcessing] = useState(false);
-    const [error, setError] = useState<string | null>(null);
-
-    const createCardMultimedia = useCallback(
-      async (cardData: CreateCardMultimediaData): Promise<CardMultimediaFlashcard> => {
-        try {
-          setIsProcessing(true);
-          setError(null);
-
-          // Simulate card creation
-          await new Promise((resolve) => setTimeout(resolve, 1000));
-
-          const card: CardMultimediaFlashcard = {
-            id: `card_multimedia_${Date.now()}`,
-            front: cardData.front || "",
-            back: cardData.back || "",
-            difficulty: cardData.difficulty || "medium",
-            tags: cardData.tags || [],
-            media: cardData.media || [],
-            hasMedia: (cardData.media || []).length > 0,
-            mediaType: extractMediaTypes(cardData.media || []),
-            isDownloaded: (cardData.media || []).every(
-              (m: CardMediaAttachment) => m.isDownloaded,
-            ),
-            estimatedSize: calculateTotalSize(cardData.media || []),
-            createdAt: new Date().toISOString(),
-          };
-
-          return card;
-        } catch (err) {
-          const errorMessage =
-            err instanceof Error ? err.message : "Card creation failed";
-          setError(errorMessage);
-          setIsProcessing(false);
-          throw err;
-        } finally {
-          setIsProcessing(false);
-        }
-      },
-      [],
-    );
-
-    const updateCardMedia = useCallback(
-      async (
-        _cardId: string,
-        _media: CardMediaAttachment[],
-      ): Promise<CardMultimediaFlashcard> => {
-        // Mock implementation
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        return {} as CardMultimediaFlashcard;
-      },
-      [],
-    );
-
-    const deleteCardMedia = useCallback(
-      async (_attachmentId: string): Promise<void> => {
-        // Mock implementation
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      },
-      [],
-    );
-
-    return {
-      createCardMultimedia,
-      updateCardMedia,
-      deleteCardMedia,
-      isProcessing,
-      error,
-    };
-  };

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

@@ -1,190 +0,0 @@
-/**
- * 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/MediaAttachments";
-import { MediaLibraryPermission } from "../../domain/entities/MediaAttachments";
-
-/**
- * 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,
-  };
-};

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

@@ -1,18 +0,0 @@
-/**
- * Media Generation Hook
- * Hook for generating media with AI
- * Now a thin wrapper around useGenericMediaGeneration
- */
-
-import { useGenericMediaGeneration } from "../../infrastructure/hooks/useGenericMediaGeneration";
-import type { UseMediaGenerationResult } from "./multimedia.types";
-import type {
-  MediaAttachment,
-  MediaGenerationRequest,
-} from "../../domain/entities/MediaAttachments";
-
-export const useMediaGeneration = (): UseMediaGenerationResult => {
-  return useGenericMediaGeneration<MediaAttachment, MediaGenerationRequest>(
-    (baseAttachment) => baseAttachment as MediaAttachment
-  );
-};

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

@@ -1,84 +0,0 @@
-/**
- * Media Upload Hook
- * Hook for uploading media files
- */
-
-import { useState, useCallback } from "react";
-import { generateThumbnail, getMediaDuration } from "../../infrastructure/utils/file-media-utils";
-import { getMediaTypeFromMime } from "../../infrastructure/utils/mime-type-detector";
-import type { UseMediaUploadResult } from "./multimedia.types";
-import type {
-  MediaAttachment,
-  MediaCompressionOptions,
-  MediaFile,
-  MediaUploadProgress,
-} from "../../domain/entities/MediaAttachments";
-
-export const useMediaUpload = (): UseMediaUploadResult => {
-  const [isUploading, setIsUploading] = useState(false);
-  const [uploadProgress, setUploadProgress] =
-    useState<MediaUploadProgress | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const uploadMedia = useCallback(
-    async (file: MediaFile, _options?: MediaCompressionOptions) => {
-      try {
-        setIsUploading(true);
-        setError(null);
-
-        // Simulate upload progress
-        setUploadProgress({
-          fileId: `upload_${Date.now()}`,
-          progress: 0,
-          status: "uploading",
-        });
-
-        // Simulate progress updates
-        for (let i = 1; i <= 100; i += 10) {
-          await new Promise((resolve) => setTimeout(resolve, 100));
-          setUploadProgress((prev) => (prev ? { ...prev, progress: i } : null));
-        }
-
-        const attachment: MediaAttachment = {
-          id: `media_${Date.now()}`,
-          type: getMediaTypeFromMime(file.type),
-          position: "both",
-          url: `https://storage.example.com/media/${Date.now()}_${file.name}`,
-          filename: file.name,
-          fileSize: file.size || 100000,
-          mimeType: file.type,
-          duration: await getMediaDuration(file),
-          thumbnailUrl: generateThumbnail(file),
-          caption: "",
-          isDownloaded: true,
-          createdAt: new Date().toISOString(),
-        };
-
-        setUploadProgress({
-          fileId: `upload_${Date.now()}`,
-          progress: 100,
-          status: "completed",
-          url: attachment.url,
-        });
-
-        return attachment;
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Upload failed";
-        setError(errorMessage);
-        setIsUploading(false);
-        throw err;
-      } finally {
-        setIsUploading(false);
-      }
-    },
-    [],
-  );
-
-  return {
-    uploadMedia,
-    isUploading,
-    uploadProgress,
-    error,
-  };
-};

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

@@ -1,93 +0,0 @@
-/**
- * Media Validation Hook
- * Hook for validating media files
- */
-
-import { useState, useCallback } from "react";
-import { formatFileSize } from "../../infrastructure/utils/media-collection-utils";
-import type { UseMediaValidationResult } from "./multimedia.types";
-import type { MediaValidation, MediaFile } from "../../domain/entities/MediaAttachments";
-
-export const useMediaValidation = (): UseMediaValidationResult => {
-  const [isValidating, setIsValidating] = useState(false);
-  const [validation, setValidation] = useState<MediaValidation | null>(
-    null,
-  );
-  const [error, setError] = useState<string | null>(null);
-
-  const validateMedia = useCallback(
-    async (file: MediaFile): Promise<MediaValidation> => {
-      try {
-        setIsValidating(true);
-        setError(null);
-
-        // Simulate validation
-        await new Promise((resolve) => setTimeout(resolve, 500));
-
-        const errors: string[] = [];
-        const warnings: string[] = [];
-        const recommendations: string[] = [];
-
-        // File size validation
-        const maxSize = 50 * 1024 * 1024; // 50MB
-        if (file.size > maxSize) {
-          errors.push(
-            `File size (${formatFileSize(file.size)}) exceeds maximum allowed size (${formatFileSize(maxSize)})`,
-          );
-        } else if (file.size > 10 * 1024 * 1024) {
-          // 10MB
-          warnings.push(`Large file size may impact performance`);
-          recommendations.push("Consider compressing file");
-        }
-
-        // File type validation
-        const supportedTypes = [
-          "image/jpeg",
-          "image/png",
-          "image/webp",
-          "audio/mp3",
-          "audio/wav",
-          "audio/m4a",
-          "video/mp4",
-          "video/mov",
-        ];
-
-        if (!supportedTypes.includes(file.type)) {
-          errors.push(`Unsupported file type: ${file.type}`);
-        }
-
-        const result: MediaValidation = {
-          isValid: errors.length === 0,
-          errors,
-          warnings,
-          recommendations,
-        };
-
-        setValidation(result);
-        return result;
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Validation failed";
-        setError(errorMessage);
-        setIsValidating(false);
-
-        return {
-          isValid: false,
-          errors: [errorMessage],
-          warnings: [],
-          recommendations: [],
-        };
-      } finally {
-        setIsValidating(false);
-      }
-    },
-    [],
-  );
-
-  return {
-    validateMedia,
-    isValidating,
-    validation,
-    error,
-  };
-};