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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "4.23.101",
+  "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,30 +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 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";

package/src/media/infrastructure/utils/PermissionManager.ts

@@ -5,7 +5,7 @@
  */
 
 import * as ImagePicker from "expo-image-picker";
-import { MediaLibraryPermission } from "../../domain/entities/MediaAttachments";
+import { MediaLibraryPermission } from "../../domain/entities/Media";
 import { mapPermissionStatus } from "./mediaPickerMappers";
 
 /**

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/infrastructure/utils/mediaPickerMappers.ts

@@ -9,7 +9,7 @@ import {
   MediaType,
   type MediaAsset,
   type MediaPickerResult,
-} from "../../domain/entities/MediaAttachments";
+} from "../../domain/entities/Media";
 
 /**
  * Map expo-image-picker permission status to MediaLibraryPermission

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

@@ -12,8 +12,8 @@ import type {
   MediaPickerOptions,
   MediaPickerResult,
   CameraOptions,
-} from "../../domain/entities/MediaAttachments";
-import { MediaLibraryPermission } from "../../domain/entities/MediaAttachments";
+} from "../../domain/entities/Media";
+import { MediaLibraryPermission } from "../../domain/entities/Media";
 
 /**
  * useMedia hook for complete media workflow

package/src/storage/infrastructure/repositories/BaseStorageOperations.ts

@@ -37,7 +37,7 @@ export class BaseStorageOperations {
         return failure(new StorageDeserializationError(key, parseError), defaultValue);
       }
     } catch (_error) {
-      return failure(new StorageReadError(key, error), defaultValue);
+      return failure(new StorageReadError(key, _error), defaultValue);
     }
   }
 
@@ -56,7 +56,7 @@ export class BaseStorageOperations {
       await AsyncStorage.setItem(key, serialized);
       return success(value);
     } catch (_error) {
-      return failure(new StorageWriteError(key, error));
+      return failure(new StorageWriteError(key, _error));
     }
   }
 
@@ -68,7 +68,7 @@ export class BaseStorageOperations {
       await AsyncStorage.removeItem(key);
       return success(undefined);
     } catch (_error) {
-      return failure(new StorageDeleteError(key, error));
+      return failure(new StorageDeleteError(key, _error));
     }
   }
 
@@ -92,7 +92,7 @@ export class BaseStorageOperations {
       await AsyncStorage.clear();
       return success(undefined);
     } catch (_error) {
-      return failure(new StorageDeleteError('ALL_KEYS', error));
+      return failure(new StorageDeleteError('ALL_KEYS', _error));
     }
   }
 }

package/src/media/domain/entities/MediaAttachments.ts

@@ -1,101 +0,0 @@
-/**
- * Media Attachments Types
- * Types for media attachments in flashcards and content
- */
-
-export type MediaAttachmentType = "image" | "audio" | "video";
-export type MediaPosition = "front" | "back" | "both";
-
-export interface MediaAttachment {
-  id: string;
-  type: MediaAttachmentType;
-  position: MediaPosition;
-  url: string;
-  localPath?: string;
-  filename: string;
-  fileSize: number;
-  mimeType: string;
-  duration?: number;
-  thumbnailUrl?: string;
-  caption?: string;
-  isDownloaded: boolean;
-  createdAt: string;
-}
-
-export interface MultimediaFlashcard {
-  id: string;
-  front: string;
-  back: string;
-  difficulty: "easy" | "medium" | "hard";
-  tags: string[];
-  createdAt?: string;
-  updatedAt?: string;
-  media: MediaAttachment[];
-  hasMedia: boolean;
-  mediaType: MediaAttachmentType[];
-  isDownloaded: boolean;
-  estimatedSize: number;
-}
-
-export interface MediaGenerationRequest {
-  type: "text_to_image" | "text_to_audio" | "image_search";
-  input: {
-    text?: string;
-    prompt?: string;
-    language?: string;
-    voice?: "male" | "female" | "neutral";
-    style?: "realistic" | "cartoon" | "artistic";
-  };
-  options: {
-    maxResults?: number;
-    quality?: "low" | "medium" | "high";
-    format?: "jpeg" | "png" | "mp3" | "wav";
-  };
-}
-
-export interface MediaGenerationResult {
-  success: boolean;
-  attachments: MediaAttachment[];
-  creditsUsed: number;
-  processingTime: number;
-  error?: string;
-  requestId: string;
-}
-
-export interface MediaUploadProgress {
-  fileId: string;
-  progress: number;
-  status: "uploading" | "processing" | "completed" | "error";
-  error?: string;
-  url?: string;
-}
-
-export interface MediaCompressionOptions {
-  quality: number;
-  maxWidth?: number;
-  maxHeight?: number;
-  maxFileSize?: number;
-  format?: "jpeg" | "png" | "webp";
-}
-
-export interface MediaFile {
-  name: string;
-  type: string;
-  size: number;
-  uri?: string;
-}
-
-export interface CreateMultimediaCardData {
-  front: string;
-  back: string;
-  difficulty?: "easy" | "medium" | "hard";
-  tags?: string[];
-  media?: MediaAttachment[];
-}
-
-export interface MediaValidation {
-  isValid: boolean;
-  errors: string[];
-  warnings: string[];
-  recommendations: string[];
-}

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

@@ -1,80 +0,0 @@
-/**
- * Media Generation Service
- * Handles AI media generation (text-to-image, text-to-audio)
- */
-
-import type {
-  MediaAttachment,
-  MediaGenerationRequest,
-  MediaGenerationResult,
-  MediaType,
-  MediaPosition,
-} from "../../domain/entities/MediaAttachments";
-
-export class MediaGenerationService {
-  /**
-   * Generate media from AI (text-to-image, text-to-audio, etc.)
-   */
-  async generateMedia(
-    request: MediaGenerationRequest,
-  ): Promise<MediaGenerationResult> {
-    try {
-      const startTime = Date.now();
-
-      // Simulate AI generation
-      await new Promise((resolve) => setTimeout(resolve, 3000));
-
-      const attachments: MediaAttachment[] = [];
-
-      switch (request.type) {
-        case "text_to_image":
-          for (let i = 0; i < (request.options.maxResults || 1); i++) {
-            attachments.push({
-              id: `ai_img_${Date.now()}_${i}`,
-              type: "image" as MediaType,
-              position: "both" as MediaPosition,
-              url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
-              filename: `ai_generated_${i}.jpg`,
-              fileSize: 150000,
-              mimeType: "image/jpeg",
-              isDownloaded: false,
-              createdAt: new Date().toISOString(),
-            });
-          }
-          break;
-
-        case "text_to_audio":
-          attachments.push({
-            id: `ai_audio_${Date.now()}`,
-            type: "audio" as MediaType,
-            position: "back" as MediaPosition,
-            url: `https://example.com/audio_${Date.now()}.mp3`,
-            filename: `ai_generated_${Date.now()}.mp3`,
-            fileSize: 80000,
-            mimeType: "audio/mp3",
-            duration: 10,
-            isDownloaded: false,
-            createdAt: new Date().toISOString(),
-          });
-          break;
-      }
-
-      return {
-        success: true,
-        attachments,
-        creditsUsed: request.type === "text_to_image" ? 5 : 3,
-        processingTime: Date.now() - startTime,
-        requestId: `req_${Date.now()}`,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        attachments: [],
-        creditsUsed: 0,
-        processingTime: 0,
-        error: error instanceof Error ? error.message : "Unknown error",
-        requestId: "",
-      };
-    }
-  }
-}

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

@@ -1,32 +0,0 @@
-/**
- * Media Optimizer Service
- * Handles media optimization and deletion
- */
-
-import type {
-  MediaAttachment,
-  MediaCompressionOptions,
-} from "../../domain/entities/MediaAttachments";
-
-export class MediaOptimizerService {
-  /**
-   * Optimize media file
-   */
-  async optimizeMedia(
-    attachment: MediaAttachment,
-    options: MediaCompressionOptions,
-  ): Promise<MediaAttachment> {
-    return {
-      ...attachment,
-      fileSize: Math.floor(attachment.fileSize * options.quality),
-      url: `${attachment.url}?optimized=true`,
-    };
-  }
-
-  /**
-   * Delete media attachment
-   */
-  async deleteMedia(_attachmentId: string): Promise<void> {
-    // Mock implementation
-  }
-}

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

@@ -1,60 +0,0 @@
-/**
- * Media Upload Service
- * Handles media upload, download, and URL operations
- */
-
-import type {
-  MediaAttachment,
-  MediaCompressionOptions,
-  MediaFile,
-} from "../../domain/entities/MediaAttachments";
-import { generateThumbnail, getMediaDuration } from "../utils/file-media-utils";
-import { getMediaTypeFromMime } from "../utils/mime-type-detector";
-
-export class MediaUploadService {
-  /**
-   * Upload media file with optional compression
-   */
-  async uploadMedia(
-    file: MediaFile,
-    _options?: MediaCompressionOptions,
-  ): Promise<MediaAttachment> {
-    try {
-      // Simulate upload process
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-
-      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(),
-      };
-
-      return attachment;
-    } catch (error) {
-      throw new Error(`Failed to upload media: ${error}`);
-    }
-  }
-
-  /**
-   * Get media URL
-   */
-  async getMediaUrl(attachmentId: string): Promise<string> {
-    return `https://storage.example.com/media/${attachmentId}`;
-  }
-
-  /**
-   * Download media to local storage
-   */
-  async downloadMedia(attachmentId: string): Promise<string> {
-    return `/local/storage/${attachmentId}`;
-  }
-}

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

@@ -1,61 +0,0 @@
-/**
- * Media Validation Service
- * Handles media file validation before upload
- */
-
-import { formatFileSize } from "../utils/media-collection-utils";
-import type { MediaValidation, MediaFile } from "../../domain/entities/MediaAttachments";
-
-export class MediaValidationService {
-  /**
-   * Validate media file before upload
-   */
-  async validateMedia(file: MediaFile): Promise<MediaValidation> {
-    try {
-      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) {
-        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}`);
-      }
-
-      return {
-        isValid: errors.length === 0,
-        errors,
-        warnings,
-        recommendations,
-      };
-    } catch (error) {
-      return {
-        isValid: false,
-        errors: [error instanceof Error ? error.message : "Validation failed"],
-        warnings: [],
-        recommendations: [],
-      };
-    }
-  }
-}

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/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,
-  };
-};

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

@@ -1,101 +0,0 @@
-/**
- * Multimedia Flashcard Hooks
- * Main hook and exports for multimedia functionality
- */
-
-import { useState, useCallback } from "react";
-import { calculateTotalSize, extractMediaTypes } from "../../infrastructure/utils/media-collection-utils";
-import type { UseMultimediaFlashcardResult } from "./multimedia.types";
-import type {
-  MediaAttachment,
-  MultimediaFlashcard,
-  CreateMultimediaCardData,
-} from "../../domain/entities/MediaAttachments";
-
-// Export individual hooks
-export { useMediaUpload } from "./useMediaUpload";
-export { useMediaGeneration } from "./useMediaGeneration";
-export { useMediaValidation } from "./useMediaValidation";
-
-// Export types
-export type {
-  UseMediaUploadResult,
-  UseMediaGenerationResult,
-  UseMediaValidationResult,
-  UseMultimediaFlashcardResult,
-} from "./multimedia.types";
-
-/**
- * Main hook for multimedia flashcard operations
- */
-export const useMultimediaFlashcard = (): UseMultimediaFlashcardResult => {
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const createMultimediaCard = useCallback(
-    async (cardData: CreateMultimediaCardData): Promise<MultimediaFlashcard> => {
-      try {
-        setIsProcessing(true);
-        setError(null);
-
-        // Simulate card creation
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-
-        const card: MultimediaFlashcard = {
-          id: `card_${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: MediaAttachment) => 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 updateMedia = useCallback(
-    async (
-      _cardId: string,
-      _media: MediaAttachment[],
-    ): Promise<MultimediaFlashcard> => {
-      // Mock implementation
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      return {} as MultimediaFlashcard;
-    },
-    [],
-  );
-
-  const deleteMedia = useCallback(
-    async (_attachmentId: string): Promise<void> => {
-      // Mock implementation
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    },
-    [],
-  );
-
-  return {
-    createMultimediaCard,
-    updateMedia,
-    deleteMedia,
-    isProcessing,
-    error,
-  };
-};