@umituz/react-native-ai-generation-content 1.61.64 → 1.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.61.64",
+  "version": "1.62.0",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/face-detection/README.md

@@ -1,314 +1,29 @@
-# Face Detection Domain
+# Face Detection & Preservation
 
-Face detection and analysis system for AI features.
+AI-powered face detection and preservation for image generation tasks.
 
-## 📍 Import Path
+## Features
 
-```typescript
-import {
-  detectFaces,
-  analyzeFace,
-  compareFaces,
-  cropFace,
-  checkFaceQuality,
-  findMatchingFace
-} from '@umituz/react-native-ai-generation-content';
-```
-
-**Location**: `src/domains/face-detection/`
-
-## 🎯 Domain Purpose
-
-Comprehensive face detection and analysis capabilities for AI features. Detect faces in images, analyze facial features and attributes, support multiple faces, extract facial measurements and landmarks, and enable face matching for various AI generation features.
-
----
-
-## 📋 Usage Strategy
-
-### When to Use This Domain
-
-✅ **Use Cases:**
-- Preparing images for face swap
-- Validating photos for AI features
-- Detecting multiple faces in group photos
-- Quality checking before processing
-- Face matching and verification
-
-❌ **When NOT to Use:**
-- Real-time video processing (use specialized tools)
-- Surveillance or tracking (ethical concerns)
-- Biometric authentication (use security libraries)
-- Age verification for legal purposes
-
-### Implementation Strategy
-
-1. **Detect faces** before AI generation
-2. **Validate quality** of detected faces
-3. **Handle multiple faces** appropriately
-4. **Extract landmarks** for processing
-5. **Compare faces** when needed
-6. **Crop faces** for focused processing
-7. **Provide feedback** on detection results
-
----
-
-## ⚠️ Critical Rules (MUST FOLLOW)
-
-### 1. Detection Requirements
-- **MUST** detect faces before processing
-- **MUST** handle no-face scenarios
-- **MUST** support multiple faces
-- **MUST** return confidence scores
-- **MUST** provide bounding boxes
-
-### 2. Quality Validation
-- **MUST** check face quality before use
-- **MUST** provide quality feedback
-- **MUST** handle poor quality gracefully
-- **MUST** guide users to better photos
-- **MUST** validate clarity and visibility
-
-### 3. Multiple Face Handling
-- **MUST** detect all faces in image
-- **MUST** allow face selection
-- **MUST** provide face indexing
-- **MUST** handle face ordering
-- **MUST** support group photos
-
-### 4. Performance
-- **MUST** optimize detection speed
-- **MUST** cache detection results
-- **MUST** handle large images
-- **MUST NOT** block main thread
-- **MUST** implement efficient algorithms
-
-### 5. User Experience
-- **MUST** provide clear feedback
-- **MUST** explain detection failures
-- **MUST** guide users to better photos
-- **MUST** show detected faces
-- **MUST** allow face selection
-
----
-
-## 🚫 Prohibitions (MUST AVOID)
-
-### Strictly Forbidden
-
-❌ **NEVER** do the following:
-
-1. **No Skipping Detection**
-   - Always detect before processing
-   - Never assume face presence
-   - Validate detection results
-
-2. **No Poor Quality Processing**
-   - Always check quality first
-   - Never process poor quality faces
-   - Guide users to better photos
-
-3. **No Missing Feedback**
-   - Always explain detection results
-   - Never silently fail
-   - Provide actionable guidance
-
-4. **No Privacy Violations**
-   - Never store faces without consent
-   - Always handle data properly
-   - Comply with regulations
-
-5. **No Biased Detection**
-   - Ensure fair detection across demographics
-   - Test for bias regularly
-   - Use diverse training data
-
-6. **No Missing Context**
-   - Always explain what was detected
-   - Show face locations
-   - Provide confidence scores
-
-7. **No Blocking UI**
-   - Never block on detection
-   - Show progress indicators
-   - Allow cancellation
-
----
-
-## 🤖 AI Agent Directions
-
-### For AI Code Generation Tools
+- ✅ **AI-based Face Detection** - Detect faces in images using AI vision models
+- ✅ **Face Preservation Modes** - Multiple preservation strategies (strict, balanced, minimal)
+- ✅ **Provider-Agnostic** - Works with any AI vision provider
+- ✅ **Image Generation Integration** - Easy integration with image-to-video, image-to-image, etc.
+- ✅ **React Hooks** - Ready-to-use hooks for React Native
 
-#### Prompt Template for AI Agents
-
-```
-You are implementing face detection using @umituz/react-native-ai-generation-content.
-
-REQUIREMENTS:
-1. Import face detection functions
-2. Detect faces before AI generation
-3. Validate face quality
-4. Handle multiple faces
-5. Extract landmarks for processing
-6. Provide clear user feedback
-7. Handle no-face scenarios
-8. Optimize for performance
-
-CRITICAL RULES:
-- MUST detect before processing
-- MUST validate face quality
-- MUST handle multiple faces
-- MUST provide clear feedback
-- MUST guide users to better photos
-- MUST handle no-face scenarios
-
-DETECTION FUNCTIONS:
-- detectFaces: Detect all faces in image
-- analyzeFace: Analyze facial features
-- compareFaces: Compare two faces
-- cropFace: Crop face from image
-- checkFaceQuality: Validate face quality
-- findMatchingFace: Find face in group photo
-
-FACE DATA:
-- boundingBox: Face location and size
-- confidence: Detection confidence (0-1)
-- landmarks: Facial feature points
-- gender: Detected gender
-- age: Estimated age range
-- emotions: Emotion probabilities
-
-QUALITY METRICS:
-- brightness: Image brightness
-- sharpness: Face clarity
-- overall: 'good' | 'fair' | 'poor'
-
-STRICTLY FORBIDDEN:
-- No skipping detection
-- No poor quality processing
-- No missing feedback
-- No privacy violations
-- No biased detection
-- No missing context
-- No blocking UI
-
-QUALITY CHECKLIST:
-- [ ] Face detection implemented
-- [ ] Quality validation added
-- [ ] Multiple faces handled
-- [ ] Clear feedback provided
-- [ ] No-face scenarios handled
-- [ ] Performance optimized
-- [ ] Privacy protected
-- [ ] Bias tested
-- [ ] User guidance provided
-- [ ] Error handling complete
-```
-
----
-
-## 🛠️ Configuration Strategy
-
-### Detection Result
+## Quick Example
 
 ```typescript
-interface FaceDetectionResult {
-  faces: DetectedFace[];
-  imageWidth: number;
-  imageHeight: number;
-  processingTime: number;
-}
+import { prepareImageGenerationWithFacePreservation } from "@umituz/react-native-ai-generation-content/domains/face-detection";
 
-interface DetectedFace {
-  id: string;
-  boundingBox: BoundingBox;
-  confidence: number;
-  landmarks?: FacialLandmarks;
-}
-```
-
-### Face Analysis
+// Enhance your generation prompts with face preservation
+const generation = prepareImageGenerationWithFacePreservation({
+  prompt: "Transform into cartoon style",
+  faceDetectionResult: faceResult,
+  preservationMode: "balanced",
+});
 
-```typescript
-interface FaceAnalysis {
-  gender: 'male' | 'female' | 'unknown';
-  age: {
-    min: number;
-    max: number;
-    estimated: number;
-  };
-  emotions: {
-    happy: number;
-    sad: number;
-    angry: number;
-    surprised: number;
-    neutral: number;
-  };
-  dominantEmotion: string;
-  landmarks: FacialLandmarks;
-  faceQuality: {
-    brightness: number;
-    sharpness: number;
-    overall: 'good' | 'fair' | 'poor';
-  };
-}
+// Use enhanced prompt
+await generateVideo({ prompt: generation.enhancedPrompt });
 ```
 
----
-
-## 📊 Core Functions
-
-### Detection
-- `detectFaces()` - Find all faces
-- `analyzeFace()` - Analyze single face
-- `checkFaceQuality()` - Validate quality
-
-### Processing
-- `cropFace()` - Extract face
-- `findMatchingFace()` - Match in group
-- `compareFaces()` - Compare two faces
-
-### Components
-- `FaceDetectionOverlay` - Visual overlay
-- `FaceAnalysisDisplay` - Analysis results
-
----
-
-## 🎨 Best Practices
-
-### Image Quality
-- Use high-quality, well-lit photos
-- Ensure faces are clearly visible
-- Forward-facing photos work best
-- Avoid extreme angles
-
-### User Feedback
-- Explain why detection failed
-- Guide to better photos
-- Show what was detected
-- Provide confidence scores
-
-### Performance
-- Cache detection results
-- Optimize image sizes
-- Implement lazy loading
-- Background processing
-
----
-
-## 🐛 Common Pitfalls
-
-❌ **No face detected**: Guide user to better photo
-❌ **Poor quality**: Check quality first
-❌ **Multiple faces**: Allow face selection
-❌ **Slow detection**: Optimize, cache results
-
----
-
-## 📚 Related Features
-
-- [Face Swap](../../features/face-swap) - Swap faces between images
-
----
-
-**Last Updated**: 2025-01-08
-**Version**: 2.0.0 (Strategy-based Documentation)
+See [index.ts](./index.ts) for complete API.

package/src/domains/face-detection/domain/types/face-preservation.types.ts

@@ -0,0 +1,50 @@
+/**
+ * Face Preservation Types
+ * Enhanced face detection with preservation strategies
+ */
+
+export type FacePreservationMode = "strict" | "balanced" | "minimal" | "none";
+
+export interface FaceMetadata {
+  readonly hasFace: boolean;
+  readonly confidence: number;
+  readonly position?: {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  };
+  readonly features?: {
+    readonly eyes: boolean;
+    readonly nose: boolean;
+    readonly mouth: boolean;
+  };
+  readonly quality?: "high" | "medium" | "low";
+}
+
+export interface FacePreservationConfig {
+  readonly mode: FacePreservationMode;
+  readonly minConfidence: number;
+  readonly requireFullFace?: boolean;
+  readonly allowMultipleFaces?: boolean;
+}
+
+export interface FacePreservationPrompt {
+  readonly basePrompt: string;
+  readonly faceGuidance: string;
+  readonly preservationWeight: number;
+}
+
+export const DEFAULT_PRESERVATION_CONFIG: FacePreservationConfig = {
+  mode: "balanced",
+  minConfidence: 0.5,
+  requireFullFace: false,
+  allowMultipleFaces: true,
+};
+
+export const PRESERVATION_MODE_WEIGHTS: Record<FacePreservationMode, number> = {
+  strict: 1.0,
+  balanced: 0.7,
+  minimal: 0.4,
+  none: 0.0,
+};

package/src/domains/face-detection/index.ts

@@ -1,17 +1,33 @@
 /**
- * React Native AI Face Detection - Public API
+ * React Native AI Face Detection & Preservation - Public API
  *
- * AI-powered face detection for React Native apps
+ * AI-powered face detection and preservation for image generation
  */
 
+// Domain - Entities
 export type {
   FaceDetectionResult,
   FaceValidationState,
   FaceDetectionConfig,
 } from "./domain/entities/FaceDetection";
 
+// Domain - Face Preservation Types
+export type {
+  FacePreservationMode,
+  FaceMetadata,
+  FacePreservationConfig,
+  FacePreservationPrompt,
+} from "./domain/types/face-preservation.types";
+
+export {
+  DEFAULT_PRESERVATION_CONFIG,
+  PRESERVATION_MODE_WEIGHTS,
+} from "./domain/types/face-preservation.types";
+
+// Domain - Constants
 export { FACE_DETECTION_CONFIG, FACE_DETECTION_PROMPTS } from "./domain/constants/faceDetectionConstants";
 
+// Infrastructure - Validators
 export {
   isValidFace,
   parseDetectionResponse,
@@ -19,9 +35,31 @@ export {
   createSuccessResult,
 } from "./infrastructure/validators/faceValidator";
 
+// Infrastructure - Analyzers
 export { analyzeImageForFace } from "./infrastructure/analyzers/faceAnalyzer";
+export type { AIAnalyzerFunction } from "./infrastructure/analyzers/faceAnalyzer";
+
+// Infrastructure - Face Preservation Builders
+export {
+  buildFacePreservationPrompt,
+  combineFacePreservationPrompt,
+  getFacePreservationWeight,
+} from "./infrastructure/builders/facePreservationPromptBuilder";
+export type { BuildPreservationPromptOptions } from "./infrastructure/builders/facePreservationPromptBuilder";
+
+// Infrastructure - Image Generation Integration
+export {
+  prepareImageGenerationWithFacePreservation,
+  shouldEnableFacePreservation,
+} from "./infrastructure/integration/imageGenerationIntegration";
+export type {
+  ImageGenerationWithFacePreservation,
+  PrepareImageGenerationOptions,
+} from "./infrastructure/integration/imageGenerationIntegration";
 
+// Presentation - Hooks
 export { useFaceDetection } from "./presentation/hooks/useFaceDetection";
 
+// Presentation - Components
 export { FaceValidationStatus } from "./presentation/components/FaceValidationStatus";
 export { FaceDetectionToggle } from "./presentation/components/FaceDetectionToggle";

package/src/domains/face-detection/infrastructure/builders/facePreservationPromptBuilder.ts

@@ -0,0 +1,66 @@
+/**
+ * Face Preservation Prompt Builder
+ * Builds prompts that preserve facial features in image generation
+ */
+
+import type {
+  FacePreservationMode,
+  FacePreservationPrompt,
+  FaceMetadata,
+} from "../../domain/types/face-preservation.types";
+import { PRESERVATION_MODE_WEIGHTS } from "../../domain/types/face-preservation.types";
+
+const PRESERVATION_PROMPTS: Record<FacePreservationMode, string> = {
+  strict: "Preserve the exact facial features, expressions, and details from the original image. Maintain face structure, skin tone, eyes, nose, and mouth precisely.",
+  balanced: "Keep the main facial features recognizable while allowing natural variations. Preserve overall face structure and key characteristics.",
+  minimal: "Maintain basic facial proportions and general appearance while allowing creative interpretation.",
+  none: "",
+};
+
+export interface BuildPreservationPromptOptions {
+  readonly mode: FacePreservationMode;
+  readonly basePrompt: string;
+  readonly faceMetadata?: FaceMetadata;
+  readonly customGuidance?: string;
+}
+
+export function buildFacePreservationPrompt(
+  options: BuildPreservationPromptOptions,
+): FacePreservationPrompt {
+  const { mode, basePrompt, faceMetadata, customGuidance } = options;
+
+  if (mode === "none" || !faceMetadata?.hasFace) {
+    return {
+      basePrompt,
+      faceGuidance: "",
+      preservationWeight: 0,
+    };
+  }
+
+  const faceGuidance = customGuidance || PRESERVATION_PROMPTS[mode];
+  const preservationWeight = PRESERVATION_MODE_WEIGHTS[mode];
+
+  const qualityNote = faceMetadata?.quality === "high"
+    ? " High quality facial details detected."
+    : "";
+
+  const enhancedGuidance = `${faceGuidance}${qualityNote}`;
+
+  return {
+    basePrompt,
+    faceGuidance: enhancedGuidance,
+    preservationWeight,
+  };
+}
+
+export function combineFacePreservationPrompt(prompt: FacePreservationPrompt): string {
+  if (!prompt.faceGuidance) {
+    return prompt.basePrompt;
+  }
+
+  return `${prompt.basePrompt}\n\nFace Preservation: ${prompt.faceGuidance}`;
+}
+
+export function getFacePreservationWeight(mode: FacePreservationMode): number {
+  return PRESERVATION_MODE_WEIGHTS[mode];
+}

package/src/domains/face-detection/infrastructure/integration/imageGenerationIntegration.ts

@@ -0,0 +1,85 @@
+/**
+ * Image Generation Integration
+ * Utilities for integrating face preservation with image generation flows
+ */
+
+import type { FaceDetectionResult } from "../../domain/entities/FaceDetection";
+import type {
+  FacePreservationMode,
+  FaceMetadata,
+  FacePreservationConfig,
+} from "../../domain/types/face-preservation.types";
+import {
+  buildFacePreservationPrompt,
+  combineFacePreservationPrompt,
+} from "../builders/facePreservationPromptBuilder";
+
+export interface ImageGenerationWithFacePreservation {
+  readonly originalPrompt: string;
+  readonly enhancedPrompt: string;
+  readonly preservationMode: FacePreservationMode;
+  readonly faceDetected: boolean;
+  readonly shouldPreserveFace: boolean;
+}
+
+export interface PrepareImageGenerationOptions {
+  readonly prompt: string;
+  readonly faceDetectionResult?: FaceDetectionResult;
+  readonly preservationMode?: FacePreservationMode;
+  readonly config?: Partial<FacePreservationConfig>;
+}
+
+export function prepareImageGenerationWithFacePreservation(
+  options: PrepareImageGenerationOptions,
+): ImageGenerationWithFacePreservation {
+  const {
+    prompt,
+    faceDetectionResult,
+    preservationMode = "balanced",
+    config,
+  } = options;
+
+  const faceDetected = faceDetectionResult?.hasFace ?? false;
+  const minConfidence = config?.minConfidence ?? 0.5;
+  const meetsConfidence = (faceDetectionResult?.confidence ?? 0) >= minConfidence;
+  const shouldPreserveFace = faceDetected && meetsConfidence && preservationMode !== "none";
+
+  if (!shouldPreserveFace) {
+    return {
+      originalPrompt: prompt,
+      enhancedPrompt: prompt,
+      preservationMode: "none",
+      faceDetected,
+      shouldPreserveFace: false,
+    };
+  }
+
+  const faceMetadata: FaceMetadata = {
+    hasFace: faceDetected,
+    confidence: faceDetectionResult?.confidence ?? 0,
+  };
+
+  const preservationPrompt = buildFacePreservationPrompt({
+    mode: preservationMode,
+    basePrompt: prompt,
+    faceMetadata,
+  });
+
+  const enhancedPrompt = combineFacePreservationPrompt(preservationPrompt);
+
+  return {
+    originalPrompt: prompt,
+    enhancedPrompt,
+    preservationMode,
+    faceDetected,
+    shouldPreserveFace: true,
+  };
+}
+
+export function shouldEnableFacePreservation(
+  faceDetectionResult?: FaceDetectionResult,
+  minConfidence: number = 0.5,
+): boolean {
+  if (!faceDetectionResult) return false;
+  return faceDetectionResult.hasFace && faceDetectionResult.confidence >= minConfidence;
+}

package/src/domains/image-to-video/domain/constants/index.ts

@@ -7,11 +7,6 @@ export {
   DEFAULT_ANIMATION_STYLE_ID,
 } from "./animation.constants";
 
-export {
-  DEFAULT_MUSIC_MOODS,
-  DEFAULT_MUSIC_MOOD_ID,
-} from "./music.constants";
-
 export {
   DEFAULT_DURATION_OPTIONS,
   DEFAULT_VIDEO_DURATION,

package/src/domains/image-to-video/domain/types/index.ts

@@ -1,9 +1,6 @@
 // Animation Types
 export type { AnimationStyle, AnimationStyleId } from "./animation.types";
 
-// Music Types
-export type { MusicMood, MusicMoodId } from "./music.types";
-
 // Duration Types
 export type { VideoDuration, DurationOption } from "./duration.types";
 

package/src/domains/image-to-video/index.ts

@@ -10,9 +10,6 @@
 // Animation Types
 export type { AnimationStyle, AnimationStyleId } from "./domain";
 
-// Music Types
-export type { MusicMood, MusicMoodId } from "./domain";
-
 // Duration Types
 export type { VideoDuration, DurationOption } from "./domain";
 
@@ -54,8 +51,6 @@ export type {
 export {
   DEFAULT_ANIMATION_STYLES as IMAGE_TO_VIDEO_ANIMATION_STYLES,
   DEFAULT_ANIMATION_STYLE_ID as IMAGE_TO_VIDEO_DEFAULT_ANIMATION,
-  DEFAULT_MUSIC_MOODS as IMAGE_TO_VIDEO_MUSIC_MOODS,
-  DEFAULT_MUSIC_MOOD_ID as IMAGE_TO_VIDEO_DEFAULT_MUSIC,
   DEFAULT_DURATION_OPTIONS as IMAGE_TO_VIDEO_DURATION_OPTIONS,
   DEFAULT_VIDEO_DURATION as IMAGE_TO_VIDEO_DEFAULT_DURATION,
   DEFAULT_FORM_VALUES as IMAGE_TO_VIDEO_FORM_DEFAULTS,
@@ -101,7 +96,6 @@ export type {
 export {
   ImageToVideoAnimationStyleSelector,
   ImageToVideoDurationSelector,
-  ImageToVideoMusicMoodSelector,
   ImageToVideoSelectionGrid,
   ImageToVideoGenerateButton,
 } from "./presentation";
@@ -109,7 +103,6 @@ export {
 export type {
   ImageToVideoAnimationStyleSelectorProps,
   ImageToVideoDurationSelectorProps,
-  ImageToVideoMusicMoodSelectorProps,
   ImageToVideoSelectionGridProps,
   ImageToVideoSelectionGridTranslations,
   ImageToVideoGenerateButtonProps,

package/src/domains/image-to-video/presentation/components/index.ts

@@ -10,10 +10,6 @@ export type { AnimationStyleSelectorProps as ImageToVideoAnimationStyleSelectorP
 export { DurationSelector as ImageToVideoDurationSelector } from "./DurationSelector";
 export type { DurationSelectorProps as ImageToVideoDurationSelectorProps } from "./DurationSelector";
 
-// Music Mood Selector
-export { MusicMoodSelector as ImageToVideoMusicMoodSelector } from "./MusicMoodSelector";
-export type { MusicMoodSelectorProps as ImageToVideoMusicMoodSelectorProps } from "./MusicMoodSelector";
-
 // Image Selection Grid
 export { ImageSelectionGrid as ImageToVideoSelectionGrid } from "./ImageSelectionGrid";
 export type {

package/src/exports/features.ts

@@ -55,7 +55,7 @@ export {
 
 // Image-to-Video Feature
 export type {
-  AnimationStyle, AnimationStyleId, MusicMood, MusicMoodId,
+  AnimationStyle, AnimationStyleId,
   VideoDuration, DurationOption as ImageToVideoDurationOption,
   ImageToVideoFormState, ImageToVideoFormActions, ImageToVideoFormDefaults,
   ImageToVideoCallbacks, ImageToVideoFormConfig, ImageToVideoTranslationsExtended,
@@ -68,18 +68,17 @@ export type {
   UseImageToVideoFormOptions, UseImageToVideoFormReturn,
   UseImageToVideoFeatureProps, UseImageToVideoFeatureReturn,
   ImageToVideoAnimationStyleSelectorProps, ImageToVideoDurationSelectorProps,
-  ImageToVideoMusicMoodSelectorProps, ImageToVideoSelectionGridProps,
+  ImageToVideoSelectionGridProps,
   ImageToVideoSelectionGridTranslations, ImageToVideoGenerateButtonProps,
 } from "../domains/image-to-video";
 export {
   IMAGE_TO_VIDEO_ANIMATION_STYLES, IMAGE_TO_VIDEO_DEFAULT_ANIMATION,
-  IMAGE_TO_VIDEO_MUSIC_MOODS, IMAGE_TO_VIDEO_DEFAULT_MUSIC,
   IMAGE_TO_VIDEO_DURATION_OPTIONS, IMAGE_TO_VIDEO_DEFAULT_DURATION,
   IMAGE_TO_VIDEO_FORM_DEFAULTS, IMAGE_TO_VIDEO_CONFIG,
   executeImageToVideo, hasImageToVideoSupport,
   useImageToVideoFormState, useImageToVideoGeneration, useImageToVideoForm, useImageToVideoFeature,
   ImageToVideoAnimationStyleSelector, ImageToVideoDurationSelector,
-  ImageToVideoMusicMoodSelector, ImageToVideoSelectionGrid, ImageToVideoGenerateButton,
+  ImageToVideoSelectionGrid, ImageToVideoGenerateButton,
 } from "../domains/image-to-video";
 
 // Wizard Flows

package/src/domains/image-to-video/domain/constants/music.constants.ts

@@ -1,53 +0,0 @@
-/**
- * Music Mood Constants
- * Default music moods for image-to-video
- */
-
-import type { MusicMood } from "../types";
-
-export const DEFAULT_MUSIC_MOODS: MusicMood[] = [
-  {
-    id: "none",
-    name: "No Music",
-    description: "Silent video",
-    icon: "volume-mute-outline",
-  },
-  {
-    id: "energetic",
-    name: "Energetic",
-    description: "Upbeat and dynamic",
-    icon: "flash-outline",
-  },
-  {
-    id: "calm",
-    name: "Calm",
-    description: "Peaceful and relaxing",
-    icon: "leaf-outline",
-  },
-  {
-    id: "happy",
-    name: "Happy",
-    description: "Cheerful and joyful",
-    icon: "happy-outline",
-  },
-  {
-    id: "emotional",
-    name: "Emotional",
-    description: "Touching and heartfelt",
-    icon: "heart-outline",
-  },
-  {
-    id: "rhythmic",
-    name: "Rhythmic",
-    description: "Beat-driven and groovy",
-    icon: "musical-notes-outline",
-  },
-  {
-    id: "custom",
-    name: "Custom",
-    description: "Upload your own audio",
-    icon: "cloud-upload-outline",
-  },
-];
-
-export const DEFAULT_MUSIC_MOOD_ID = "none";

package/src/domains/image-to-video/domain/types/music.types.ts

@@ -1,21 +0,0 @@
-/**
- * Music Types for Image-to-Video
- * Defines music mood options
- */
-
-export interface MusicMood {
-  id: string;
-  name: string;
-  description: string;
-  icon: string;
-}
-
-export type MusicMoodId =
-  | "none"
-  | "energetic"
-  | "calm"
-  | "happy"
-  | "emotional"
-  | "rhythmic"
-  | "custom"
-  | string;

package/src/domains/image-to-video/presentation/components/MusicMoodSelector.tsx

@@ -1,181 +0,0 @@
-/**
- * Music Mood Selector Component
- * Generic component for music mood selection
- */
-
-import React from "react";
-import { View, ScrollView, TouchableOpacity, StyleSheet } from "react-native";
-import {
-  AtomicText,
-  AtomicIcon,
-  useAppDesignTokens,
-} from "@umituz/react-native-design-system";
-import type { MusicMood, MusicMoodId } from "../../domain/types";
-
-export interface MusicMoodSelectorProps {
-  moods: MusicMood[];
-  selectedMood: MusicMoodId;
-  onMoodSelect: (moodId: MusicMoodId) => void;
-  label: string;
-  hasCustomAudio?: boolean;
-  customAudioLabel?: string;
-}
-
-export const MusicMoodSelector: React.FC<MusicMoodSelectorProps> = ({
-  moods,
-  selectedMood,
-  onMoodSelect,
-  label,
-  hasCustomAudio = false,
-  customAudioLabel,
-}) => {
-  const tokens = useAppDesignTokens();
-
-  return (
-    <View style={componentStyles.section}>
-      <AtomicText
-        type="bodyMedium"
-        style={[componentStyles.label, { color: tokens.colors.textPrimary }]}
-      >
-        {label}
-      </AtomicText>
-      <ScrollView
-        horizontal
-        showsHorizontalScrollIndicator={false}
-        style={componentStyles.scroll}
-      >
-        {moods.map((mood) => {
-          const isSelected = selectedMood === mood.id;
-          return (
-            <TouchableOpacity
-              key={mood.id}
-              style={[
-                componentStyles.card,
-                {
-                  backgroundColor: isSelected
-                    ? tokens.colors.primary
-                    : tokens.colors.surface,
-                  borderColor: isSelected
-                    ? tokens.colors.primary
-                    : tokens.colors.borderLight,
-                },
-              ]}
-              onPress={() => onMoodSelect(mood.id)}
-              activeOpacity={0.7}
-            >
-              <View
-                style={[
-                  componentStyles.iconContainer,
-                  {
-                    backgroundColor: isSelected
-                      ? tokens.colors.modalOverlay
-                      : tokens.colors.surface,
-                  },
-                ]}
-              >
-                <AtomicIcon
-                  name={mood.icon as never}
-                  size="lg"
-                  color={isSelected ? "onSurface" : "primary"}
-                />
-              </View>
-              <AtomicText
-                type="bodySmall"
-                style={[
-                  componentStyles.moodName,
-                  {
-                    color: isSelected
-                      ? tokens.colors.textInverse
-                      : tokens.colors.textPrimary,
-                  },
-                ]}
-              >
-                {mood.name}
-              </AtomicText>
-              <AtomicText
-                type="labelSmall"
-                style={[
-                  componentStyles.moodDescription,
-                  {
-                    color: isSelected
-                      ? tokens.colors.textInverse
-                      : tokens.colors.textSecondary,
-                    opacity: isSelected ? 0.9 : 0.7,
-                  },
-                ]}
-              >
-                {mood.description}
-              </AtomicText>
-            </TouchableOpacity>
-          );
-        })}
-      </ScrollView>
-      {selectedMood === "custom" && hasCustomAudio && customAudioLabel && (
-        <View
-          style={[
-            componentStyles.customBadge,
-            { backgroundColor: tokens.colors.surfaceVariant },
-          ]}
-        >
-          <AtomicIcon name="checkmark-circle-outline" size="sm" color="primary" />
-          <AtomicText
-            type="labelSmall"
-            style={[componentStyles.customBadgeText, { color: tokens.colors.primary }]}
-          >
-            {customAudioLabel}
-          </AtomicText>
-        </View>
-      )}
-    </View>
-  );
-};
-
-const componentStyles = StyleSheet.create({
-  section: {
-    padding: 16,
-    marginBottom: 8,
-  },
-  label: {
-    fontWeight: "600",
-    marginBottom: 12,
-  },
-  scroll: {
-    marginHorizontal: -16,
-    paddingHorizontal: 16,
-  },
-  card: {
-    width: 140,
-    padding: 16,
-    borderRadius: 16,
-    borderWidth: 2,
-    marginRight: 12,
-    alignItems: "center",
-  },
-  iconContainer: {
-    width: 56,
-    height: 56,
-    borderRadius: 28,
-    alignItems: "center",
-    justifyContent: "center",
-  },
-  moodName: {
-    fontWeight: "600",
-    marginTop: 8,
-    textAlign: "center",
-  },
-  moodDescription: {
-    marginTop: 4,
-    textAlign: "center",
-  },
-  customBadge: {
-    flexDirection: "row",
-    alignItems: "center",
-    padding: 12,
-    borderRadius: 12,
-    marginTop: 12,
-  },
-  customBadgeText: {
-    marginLeft: 8,
-    flex: 1,
-  },
-});