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

package/package.json

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

@@ -106,7 +106,7 @@ export type {
   CreateMultimediaCardData,
 } from "./domain/entities/MediaAttachments";
 
-// Media Hooks
+// Media Attachment Hooks
 export { useMediaUpload } from "./presentation/hooks/useMediaUpload";
 export { useMediaGeneration } from "./presentation/hooks/useMediaGeneration";
 export { useMediaValidation } from "./presentation/hooks/useMediaValidation";
@@ -117,3 +117,6 @@ export type {
   UseMediaValidationResult,
   UseMultimediaFlashcardResult,
 } from "./presentation/hooks/multimedia.types";
+
+// Media Attachment Services
+export { MultimediaFlashcardService } from "./infrastructure/services/MultimediaFlashcardService";

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/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/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/MediaPickerService.ts

@@ -1,157 +0,0 @@
-/**
- * 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

@@ -1,97 +0,0 @@
-/**
- * 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/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: [],
-      };
-    }
-  }
-}