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

package/src/media/presentation/hooks/card-multimedia.types.README.md

@@ -1,177 +0,0 @@
-# Card Multimedia Hook Types
-
-## Purpose
-TypeScript return type interfaces for card-specific multimedia hooks in the presentation layer.
-
-## File Location
-`src/presentation/hooks/card-multimedia.types.ts`
-
-## Strategy
-- Define contracts for card multimedia hook implementations
-- Ensure type safety across card media operations
-- Provide consistent return types for upload, generation, and validation
-- Support card-specific media operations (including image search)
-- Enable proper error handling and loading states
-- Maintain separation between card and general multimedia types
-
-## Forbidden
-- **DO NOT** import implementation details or hooks in type files
-- **DO NOT** mix CardMediaAttachment and MediaAttachment types
-- **DO NOT** add business logic to type definitions
-- **DO NOT** use `any` type for function parameters or returns
-- **DO NOT** create circular dependencies with domain types
-- **DO NOT** export implementation-specific types
-- **DO NOT** modify these types without updating all hook implementations
-
-## Rules
-1. All hook returns must include loading state, error state, and operation function
-2. Async operations must return Promise with appropriate type
-3. Error states must be string | null (not Error objects)
-4. Progress/results must be null when not active
-5. Boolean states must clearly indicate operation in progress
-6. All interfaces must be exported and public
-7. Type names must follow Use*Result pattern
-8. Functions must accept domain types, not external types
-9. Optional parameters must be clearly marked
-10. Return types must match hook implementations exactly
-
-## AI Agent Guidelines
-
-When working with card multimedia hook types:
-
-1. **Type Imports**: Always import types from this file for card multimedia hooks
-2. **Hook Implementation**: Implement hooks that return these exact interfaces
-3. **Card vs General**: Use Card* types for card-specific operations, Media* for general
-4. **Error Handling**: Always check error state before using results
-5. **Loading States**: Respect loading states to prevent race conditions
-6. **Progress Tracking**: Use progress objects for upload operations
-7. **Type Safety**: Use these types for all card multimedia hook return values
-8. **Testing**: Mock these interfaces when testing card media operations
-
-### Hook Return Type Structure
-
-All card multimedia hook returns follow this consistent pattern:
-
-**Core Components**:
-- **operationFunction**: An async function that accepts parameters and returns a Promise with the result type
-- **isOperationInProgress**: A boolean flag indicating whether the operation is currently running
-- **operationResult**: The result object or null when no operation is active
-- **error**: A string containing error messages or null when no error exists
-
-### UseCardMediaUploadResult
-
-**Purpose**: Card media upload operations with compression options
-
-**Key Features**:
-- Upload function accepts file and compression options
-- Tracks upload progress
-- Returns CardMediaAttachment
-- Handles upload errors
-
-**Usage Pattern**:
-1. Check `isUploading` before calling
-2. Call `uploadMedia()` with file and optional compression
-3. Monitor `uploadProgress` during upload
-4. Check `error` state on completion
-5. Use returned CardMediaAttachment on success
-
-### UseCardMediaGenerationResult
-
-**Purpose**: Card media generation (AI-based generation, image search)
-
-**Key Features**:
-- Generation function accepts request parameters
-- Tracks generation status
-- Returns CardMediaGenerationResult
-- Supports multiple generation methods
-
-**Usage Pattern**:
-1. Prepare CardMediaGenerationRequest
-2. Check `isGenerating` before calling
-3. Call `generateMedia()` with request
-4. Access `generationResult` when complete
-5. Handle `error` if generation fails
-
-### UseCardMediaValidationResult
-
-**Purpose**: Card media validation before upload or processing
-
-**Key Features**:
-- Validation function accepts file
-- Tracks validation status
-- Returns CardMediaValidation result
-- Provides detailed validation errors
-
-**Usage Pattern**:
-1. Check `isValidating` before calling
-2. Call `validateMedia()` with file
-3. Access `validation` result for validity check
-4. Use `validation.errors` array for error details
-5. Check `error` state for validation failures
-
-### UseCardMultimediaFlashcardResult
-
-**Purpose**: Card flashcard CRUD operations
-
-**Key Features**:
-- Create card with multimedia
-- Update card media
-- Delete specific media attachment
-- Tracks processing state
-- Returns CardMultimediaFlashcard
-
-**Usage Pattern**:
-1. Create: Call `createCardMultimedia()` with card data
-2. Update: Call `updateCardMedia()` with cardId and media array
-3. Delete: Call `deleteCardMedia()` with attachmentId
-4. Check `isProcessing` before operations
-5. Handle `error` state for failures
-
-### Card vs General Multimedia Types
-
-| Operation | Card Types | General Types | Key Difference |
-|-----------|-----------|---------------|----------------|
-| Upload | CardMediaAttachment | MediaAttachment | Card-specific metadata |
-| Generation | CardMediaGenerationRequest | MediaGenerationRequest | Cards include image search |
-| Validation | CardMediaValidation | MediaValidation | Card-specific rules |
-| Flashcard | CardMultimediaFlashcard | MultimediaFlashcard | Different entity types |
-
-### Type Guards and Validation
-
-1. **Upload Hook**: Check for `uploadMedia` function and `isUploading` boolean
-2. **Generation Hook**: Check for `generateMedia` function and `isGenerating` boolean
-3. **Validation Hook**: Check for `validateMedia` function and `isValidating` boolean
-4. **Flashcard Hook**: Check for all three CRUD functions and `isProcessing` boolean
-
-### Error Handling Patterns
-
-1. Always check if `error !== null` before using results
-2. Errors are strings, not Error objects
-3. Clear error before starting new operation
-4. Show user-friendly error messages
-5. Handle null states for progress/results
-
-### Async Operation Patterns
-
-1. **Before Call**: Check loading state to prevent concurrent calls
-2. **During Call**: Show loading indicator based on boolean state
-3. **After Call**: Check error state, then use result
-4. **Error Case**: Display error, reset loading state
-5. **Success Case**: Use result, clear error
-
-### Related Domain Types
-
-These interfaces use domain types:
-- CardMediaAttachment
-- CardMediaGenerationRequest
-- CardMediaGenerationResult
-- CardMediaCompressionOptions
-- CardMediaValidation
-- CardMediaUploadProgress
-- CardMultimediaFlashcard
-
-## Dependencies
-
-- Domain layer types (Card* entities)
-- Presentation layer hooks
-- No external dependencies

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

@@ -1,53 +0,0 @@
-/**
- * Card Multimedia Flashcard Hook Types
- * Type definitions for card multimedia hooks
- */
-
-import type {
-  CardMediaAttachment,
-  CardMediaFile,
-  CardMediaGenerationRequest,
-  CardMediaGenerationResult,
-  CardMediaCompressionOptions,
-  CardMediaValidation,
-  CardMediaUploadProgress,
-  CardMultimediaFlashcard,
-  CreateCardMultimediaData,
-} from "../../domain/entities/CardMultimedia.types";
-
-export interface UseCardMediaUploadResult {
-  uploadMedia: (
-    file: CardMediaFile,
-    options?: CardMediaCompressionOptions,
-  ) => Promise<CardMediaAttachment>;
-  isUploading: boolean;
-  uploadProgress: CardMediaUploadProgress | null;
-  error: string | null;
-}
-
-export interface UseCardMediaGenerationResult {
-  generateMedia: (
-    request: CardMediaGenerationRequest,
-  ) => Promise<CardMediaGenerationResult>;
-  isGenerating: boolean;
-  generationResult: CardMediaGenerationResult | null;
-  error: string | null;
-}
-
-export interface UseCardMediaValidationResult {
-  validateMedia: (file: CardMediaFile) => Promise<CardMediaValidation>;
-  isValidating: boolean;
-  validation: CardMediaValidation | null;
-  error: string | null;
-}
-
-export interface UseCardMultimediaFlashcardResult {
-  createCardMultimedia: (cardData: CreateCardMultimediaData) => Promise<CardMultimediaFlashcard>;
-  updateCardMedia: (
-    cardId: string,
-    media: CardMediaAttachment[],
-  ) => Promise<CardMultimediaFlashcard>;
-  deleteCardMedia: (attachmentId: string) => Promise<void>;
-  isProcessing: boolean;
-  error: string | null;
-}

package/src/media/presentation/hooks/multimedia.types.README.md

@@ -1,201 +0,0 @@
-# Multimedia Hook Types
-
-## Purpose
-TypeScript return type interfaces for general multimedia hooks in the presentation layer.
-
-## File Location
-`src/presentation/hooks/multimedia.types.ts`
-
-## Strategy
-- Define contracts for general multimedia hook implementations
-- Ensure type safety across media operations
-- Provide consistent return types for upload, generation, and validation
-- Support general-purpose media operations
-- Enable proper error handling and loading states
-- Maintain separation from card-specific multimedia types
-
-## Forbidden
-- **DO NOT** import implementation details or hooks in type files
-- **DO NOT** mix MediaAttachment and CardMediaAttachment types
-- **DO NOT** add business logic to type definitions
-- **DO NOT** use `any` type for function parameters or returns
-- **DO NOT** create circular dependencies with domain types
-- **DO NOT** export implementation-specific types
-- **DO NOT** modify these types without updating all hook implementations
-
-## Rules
-1. All hook returns must include loading state, error state, and operation function
-2. Async operations must return Promise with appropriate type
-3. Error states must be string | null (not Error objects)
-4. Progress/results must be null when not active
-5. Boolean states must clearly indicate operation in progress
-6. All interfaces must be exported and public
-7. Type names must follow Use*Result pattern
-8. Functions must accept domain types, not external types
-9. Optional parameters must be clearly marked
-10. Return types must match hook implementations exactly
-
-## AI Agent Guidelines
-
-When working with multimedia hook types:
-
-1. **Type Imports**: Always import types from this file for general multimedia hooks
-2. **Hook Implementation**: Implement hooks that return these exact interfaces
-3. **General vs Card**: Use Media* types for general operations, Card* for card-specific
-4. **Error Handling**: Always check error state before using results
-5. **Loading States**: Respect loading states to prevent race conditions
-6. **Progress Tracking**: Use progress objects for upload operations
-7. **Type Safety**: Use these types for all general multimedia hook return values
-8. **Testing**: Mock these interfaces when testing media operations
-
-### Hook Return Type Structure
-
-All multimedia hook returns follow this consistent pattern:
-
-**Core Components**:
-- **operationFunction**: An async function that accepts parameters and returns a Promise with the result type
-- **isOperationInProgress**: A boolean flag indicating whether the operation is currently running
-- **operationResult**: The result object or null when no operation is active
-- **error**: A string containing error messages or null when no error exists
-
-### UseMediaUploadResult
-
-**Purpose**: General media upload operations with compression options
-
-**Key Features**:
-- Upload function accepts file and compression options
-- Tracks upload progress
-- Returns MediaAttachment
-- Handles upload errors
-
-**Usage Pattern**:
-1. Check `isUploading` before calling
-2. Call `uploadMedia()` with file and optional compression
-3. Monitor `uploadProgress` during upload
-4. Check `error` state on completion
-5. Use returned MediaAttachment on success
-
-### UseMediaGenerationResult
-
-**Purpose**: General media generation (AI-based generation without image search)
-
-**Key Features**:
-- Generation function accepts request parameters
-- Tracks generation status
-- Returns MediaGenerationResult
-- Supports core generation methods
-
-**Usage Pattern**:
-1. Prepare MediaGenerationRequest
-2. Check `isGenerating` before calling
-3. Call `generateMedia()` with request
-4. Access `generationResult` when complete
-5. Handle `error` if generation fails
-
-### UseMediaValidationResult
-
-**Purpose**: General media validation before upload or processing
-
-**Key Features**:
-- Validation function accepts file
-- Tracks validation status
-- Returns MediaValidation result
-- Provides detailed validation errors
-
-**Usage Pattern**:
-1. Check `isValidating` before calling
-2. Call `validateMedia()` with file
-3. Access `validation` result for validity check
-4. Use `validation.errors` array for error details
-5. Check `error` state for validation failures
-
-### UseMultimediaFlashcardResult
-
-**Purpose**: General flashcard CRUD operations
-
-**Key Features**:
-- Create flashcard with multimedia
-- Update flashcard media
-- Delete specific media attachment
-- Tracks processing state
-- Returns MultimediaFlashcard
-
-**Usage Pattern**:
-1. Create: Call `createMultimediaCard()` with card data
-2. Update: Call `updateMedia()` with cardId and media array
-3. Delete: Call `deleteMedia()` with attachmentId
-4. Check `isProcessing` before operations
-5. Handle `error` state for failures
-
-### General vs Card Multimedia Types
-
-| Operation | General Types | Card Types | Key Difference |
-|-----------|--------------|------------|----------------|
-| Upload | MediaAttachment | CardMediaAttachment | Different entity structures |
-| Generation | MediaGenerationRequest | CardMediaGenerationRequest | Cards include image search |
-| Validation | MediaValidation | CardMediaValidation | Different validation rules |
-| Flashcard | MultimediaFlashcard | CardMultimediaFlashcard | Different entity types |
-| Features | Core operations | Core + image search | Card has extended features |
-
-### When to Use Which Types
-
-**Use Media* Types (General)**:
-- Generic media handling
-- Non-card-specific operations
-- Reusable media components
-- General-purpose flashcards
-
-**Use Card* Types (Card-Specific)**:
-- Card-specific operations
-- Image search functionality
-- Card entity management
-- Card-specific validation rules
-
-### Type Guards and Validation
-
-1. **Upload Hook**: Check for `uploadMedia` function and `isUploading` boolean
-2. **Generation Hook**: Check for `generateMedia` function and `isGenerating` boolean
-3. **Validation Hook**: Check for `validateMedia` function and `isValidating` boolean
-4. **Flashcard Hook**: Check for all three CRUD functions and `isProcessing` boolean
-
-### Error Handling Patterns
-
-1. Always check if `error !== null` before using results
-2. Errors are strings, not Error objects
-3. Clear error before starting new operation
-4. Show user-friendly error messages
-5. Handle null states for progress/results
-
-### Async Operation Patterns
-
-1. **Before Call**: Check loading state to prevent concurrent calls
-2. **During Call**: Show loading indicator based on boolean state
-3. **After Call**: Check error state, then use result
-4. **Error Case**: Display error, reset loading state
-5. **Success Case**: Use result, clear error
-
-### Composable Hooks Pattern
-
-Combine multiple hook types for complex workflows:
-
-1. **Validate Then Upload**: Use validation result before calling upload
-2. **Generate Then Upload**: Chain generation and upload operations
-3. **Upload Then Create Card**: Use upload result to create flashcard
-4. **Parallel Operations**: Use multiple hooks independently
-
-### Related Domain Types
-
-These interfaces use domain types:
-- MediaAttachment
-- MediaGenerationRequest
-- MediaGenerationResult
-- MediaCompressionOptions
-- MediaValidation
-- MediaUploadProgress
-- MultimediaFlashcard
-
-## Dependencies
-
-- Domain layer types (Media* entities)
-- Presentation layer hooks
-- No external dependencies

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/MultimediaFlashcardTypes";
-
-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/useCardMediaGeneration.ts

@@ -1,20 +0,0 @@
-/**
- * Card Media Generation Hook
- * Hook for generating card media with AI
- * Now a thin wrapper around useGenericMediaGeneration
- *
- * Note: CardMedia types are aliases of Media types for backward compatibility
- */
-
-import { useGenericMediaGeneration } from "../../infrastructure/hooks/useGenericMediaGeneration";
-import type { UseCardMediaGenerationResult } from "./card-multimedia.types";
-import type {
-  MediaAttachment as CardMediaAttachment,
-  MediaGenerationRequest as CardMediaGenerationRequest,
-} from "../../domain/entities/MultimediaFlashcardTypes";
-
-export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
-  return useGenericMediaGeneration<CardMediaAttachment, CardMediaGenerationRequest>(
-    (baseAttachment) => baseAttachment as CardMediaAttachment
-  );
-};

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

@@ -1,84 +0,0 @@
-/**
- * Card Media Upload Hook
- * Hook for uploading card 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 { UseCardMediaUploadResult } from "./card-multimedia.types";
-import type {
-  MediaAttachment as CardMediaAttachment,
-  MediaCompressionOptions as CardMediaCompressionOptions,
-  MediaFile as CardMediaFile,
-  MediaUploadProgress as CardMediaUploadProgress,
-} from "../../domain/entities/MultimediaFlashcardTypes";
-
-export const useCardMediaUpload = (): UseCardMediaUploadResult => {
-  const [isUploading, setIsUploading] = useState(false);
-  const [uploadProgress, setUploadProgress] =
-    useState<CardMediaUploadProgress | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const uploadMedia = useCallback(
-    async (file: CardMediaFile, _options?: CardMediaCompressionOptions) => {
-      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, 50));
-          setUploadProgress((prev) => (prev ? { ...prev, progress: i } : null));
-        }
-
-        const attachment: CardMediaAttachment = {
-          id: `card_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/useCardMediaValidation.ts

@@ -1,104 +0,0 @@
-/**
- * Card Media Validation Hook
- * Hook for validating card media files
- */
-
-import { useState, useCallback } from "react";
-import { formatFileSize } from "../../infrastructure/utils/media-collection-utils";
-import type { UseCardMediaValidationResult } from "./card-multimedia.types";
-import type {
-  MediaValidation as CardMediaValidation,
-  MediaFile as CardMediaFile,
-} from "../../domain/entities/MultimediaFlashcardTypes";
-
-export const useCardMediaValidation = (): UseCardMediaValidationResult => {
-  const [isValidating, setIsValidating] = useState(false);
-  const [validation, setValidation] =
-    useState<CardMediaValidation | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const validateMedia = useCallback(
-    async (file: CardMediaFile): Promise<CardMediaValidation> => {
-      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}`);
-        }
-
-        // Media-specific validations
-        if (file.type.startsWith("image/")) {
-          if (file.size > 5 * 1024 * 1024) {
-            // 5MB for images
-            warnings.push("Very large image may cause performance issues");
-            recommendations.push("Consider resizing image to under 5MB");
-          }
-        }
-
-        const result: CardMediaValidation = {
-          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,
-  };
-};