@umituz/react-native-ai-generation-content 1.17.143 → 1.17.145

package/package.json

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

package/src/domains/creations/presentation/hooks/index.ts

@@ -6,6 +6,6 @@ export { useCreations } from "./useCreations";
 export { useDeleteCreation } from "./useDeleteCreation";
 export { useCreationsFilter } from "./useCreationsFilter";
 export { useAdvancedFilter } from "./useAdvancedFilter";
-export { useStatusFilter } from "./useStatusFilter";
-export { useMediaFilter } from "./useMediaFilter";
+export { useFilter, useStatusFilter, useMediaFilter } from "./useFilter";
+export type { UseFilterProps, UseFilterReturn } from "./useFilter";
 export { useGalleryFilters } from "./useGalleryFilters";

package/src/domains/creations/presentation/hooks/{useMediaFilter.ts → useFilter.ts}

@@ -1,19 +1,20 @@
 /**
- * useMediaFilter Hook
- * Handles media type filtering (image, video, voice)
- * SOLID: Single Responsibility - Only handles media filter state
+ * useFilter Hook
+ * Generic filter state management for any filter type
+ * SOLID: Single Responsibility - Only handles filter state
+ * DRY: Replaces duplicate useMediaFilter and useStatusFilter
  */
 
 import { useState, useCallback, useMemo } from "react";
 import type { FilterOption } from "../../domain/types/creation-filter";
 
-interface UseMediaFilterProps {
+export interface UseFilterProps {
   readonly options: FilterOption[];
   readonly t: (key: string) => string;
   readonly defaultId?: string;
 }
 
-interface UseMediaFilterReturn {
+export interface UseFilterReturn {
   readonly selectedId: string;
   readonly filterOptions: FilterOption[];
   readonly hasActiveFilter: boolean;
@@ -21,11 +22,11 @@ interface UseMediaFilterReturn {
   readonly clearFilter: () => void;
 }
 
-export function useMediaFilter({
+export function useFilter({
   options,
   t,
   defaultId = "all"
-}: UseMediaFilterProps): UseMediaFilterReturn {
+}: UseFilterProps): UseFilterReturn {
   const [selectedId, setSelectedId] = useState(defaultId);
 
   const filterOptions = useMemo(() =>
@@ -52,3 +53,7 @@ export function useMediaFilter({
     clearFilter
   };
 }
+
+// Backward compatibility aliases
+export const useMediaFilter = useFilter;
+export const useStatusFilter = useFilter;

package/src/domains/creations/presentation/hooks/useGalleryFilters.ts

@@ -7,8 +7,7 @@
 import { useState, useCallback } from "react";
 import type { Creation } from "../../domain/entities/Creation";
 import type { FilterOption } from "../../domain/types/creation-filter";
-import { useStatusFilter } from "./useStatusFilter";
-import { useMediaFilter } from "./useMediaFilter";
+import { useFilter } from "./useFilter";
 import { useCreationsFilter } from "./useCreationsFilter";
 
 interface UseGalleryFiltersProps {
@@ -24,8 +23,8 @@ interface UseGalleryFiltersReturn {
   readonly activeFiltersCount: number;
   readonly statusFilterVisible: boolean;
   readonly mediaFilterVisible: boolean;
-  readonly statusFilter: ReturnType<typeof useStatusFilter>;
-  readonly mediaFilter: ReturnType<typeof useMediaFilter>;
+  readonly statusFilter: ReturnType<typeof useFilter>;
+  readonly mediaFilter: ReturnType<typeof useFilter>;
   readonly openStatusFilter: () => void;
   readonly closeStatusFilter: () => void;
   readonly openMediaFilter: () => void;
@@ -42,8 +41,8 @@ export function useGalleryFilters({
   const [statusFilterVisible, setStatusFilterVisible] = useState(false);
   const [mediaFilterVisible, setMediaFilterVisible] = useState(false);
 
-  const statusFilter = useStatusFilter({ options: statusOptions, t });
-  const mediaFilter = useMediaFilter({ options: mediaOptions, t });
+  const statusFilter = useFilter({ options: statusOptions, t });
+  const mediaFilter = useFilter({ options: mediaOptions, t });
 
   const { filtered, isFiltered, activeFiltersCount } = useCreationsFilter({
     creations,

package/src/features/ai-hug/presentation/hooks/useAIHugFeature.ts

@@ -1,13 +1,13 @@
 /**
  * useAIHugFeature Hook
- * Manages AI hug video generation state and actions
+ * Thin wrapper around useDualImageVideoFeature for ai-hug feature
+ * DRY: Uses shared base hook for common logic
  */
 
-import { useState, useCallback } from "react";
-import { executeVideoFeature } from "../../../../infrastructure/services";
+import { useDualImageVideoFeature } from "../../../shared/dual-image-video";
 import type {
-  AIHugFeatureState,
   AIHugFeatureConfig,
+  AIHugFeatureState,
 } from "../../domain/types";
 
 export interface UseAIHugFeatureProps {
@@ -25,113 +25,9 @@ export interface UseAIHugFeatureReturn extends AIHugFeatureState {
   reset: () => void;
 }
 
-const initialState: AIHugFeatureState = {
-  sourceImageUri: null,
-  targetImageUri: null,
-  processedVideoUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-export function useAIHugFeature(
-  props: UseAIHugFeatureProps,
-): UseAIHugFeatureReturn {
-  const { config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
-  const [state, setState] = useState<AIHugFeatureState>(initialState);
-
-  const selectSourceImage = useCallback(async () => {
-    try {
-      const uri = await onSelectSourceImage();
-      if (uri) {
-        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
-        config.onSourceImageSelect?.(uri);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [onSelectSourceImage, config]);
-
-  const selectTargetImage = useCallback(async () => {
-    try {
-      const uri = await onSelectTargetImage();
-      if (uri) {
-        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
-        config.onTargetImageSelect?.(uri);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [onSelectTargetImage, config]);
-
-  const handleProgress = useCallback((progress: number) => {
-    setState((prev) => ({ ...prev, progress }));
-  }, []);
-
-  const process = useCallback(async () => {
-    if (!state.sourceImageUri || !state.targetImageUri) return;
-
-    setState((prev) => ({
-      ...prev,
-      isProcessing: true,
-      progress: 0,
-      error: null,
-    }));
-
-    config.onProcessingStart?.();
-
-    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
-    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
-
-    const result = await executeVideoFeature(
-      "ai-hug",
-      { sourceImageBase64, targetImageBase64 },
-      { extractResult: config.extractResult, onProgress: handleProgress },
-    );
-
-    if (result.success && result.videoUrl) {
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        processedVideoUrl: result.videoUrl!,
-        progress: 100,
-      }));
-      config.onProcessingComplete?.({ success: true, videoUrl: result.videoUrl });
-    } else {
-      const errorMessage = result.error || "Processing failed";
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: errorMessage,
-        progress: 0,
-      }));
-      config.onError?.(errorMessage);
-    }
-  }, [state.sourceImageUri, state.targetImageUri, config, handleProgress]);
-
-  const save = useCallback(async () => {
-    if (!state.processedVideoUrl) return;
-
-    try {
-      await onSaveVideo(state.processedVideoUrl);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [state.processedVideoUrl, onSaveVideo]);
-
-  const reset = useCallback(() => {
-    setState(initialState);
-  }, []);
-
-  return {
-    ...state,
-    selectSourceImage,
-    selectTargetImage,
-    process,
-    save,
-    reset,
-  };
+export function useAIHugFeature(props: UseAIHugFeatureProps): UseAIHugFeatureReturn {
+  return useDualImageVideoFeature({
+    featureType: "ai-hug",
+    ...props,
+  });
 }

package/src/features/ai-kiss/presentation/hooks/useAIKissFeature.ts

@@ -1,13 +1,13 @@
 /**
  * useAIKissFeature Hook
- * Manages AI kiss video generation state and actions
+ * Thin wrapper around useDualImageVideoFeature for ai-kiss feature
+ * DRY: Uses shared base hook for common logic
  */
 
-import { useState, useCallback } from "react";
-import { executeVideoFeature } from "../../../../infrastructure/services";
+import { useDualImageVideoFeature } from "../../../shared/dual-image-video";
 import type {
-  AIKissFeatureState,
   AIKissFeatureConfig,
+  AIKissFeatureState,
 } from "../../domain/types";
 
 export interface UseAIKissFeatureProps {
@@ -25,113 +25,9 @@ export interface UseAIKissFeatureReturn extends AIKissFeatureState {
   reset: () => void;
 }
 
-const initialState: AIKissFeatureState = {
-  sourceImageUri: null,
-  targetImageUri: null,
-  processedVideoUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-export function useAIKissFeature(
-  props: UseAIKissFeatureProps,
-): UseAIKissFeatureReturn {
-  const { config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
-  const [state, setState] = useState<AIKissFeatureState>(initialState);
-
-  const selectSourceImage = useCallback(async () => {
-    try {
-      const uri = await onSelectSourceImage();
-      if (uri) {
-        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
-        config.onSourceImageSelect?.(uri);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [onSelectSourceImage, config]);
-
-  const selectTargetImage = useCallback(async () => {
-    try {
-      const uri = await onSelectTargetImage();
-      if (uri) {
-        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
-        config.onTargetImageSelect?.(uri);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [onSelectTargetImage, config]);
-
-  const handleProgress = useCallback((progress: number) => {
-    setState((prev) => ({ ...prev, progress }));
-  }, []);
-
-  const process = useCallback(async () => {
-    if (!state.sourceImageUri || !state.targetImageUri) return;
-
-    setState((prev) => ({
-      ...prev,
-      isProcessing: true,
-      progress: 0,
-      error: null,
-    }));
-
-    config.onProcessingStart?.();
-
-    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
-    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
-
-    const result = await executeVideoFeature(
-      "ai-kiss",
-      { sourceImageBase64, targetImageBase64 },
-      { extractResult: config.extractResult, onProgress: handleProgress },
-    );
-
-    if (result.success && result.videoUrl) {
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        processedVideoUrl: result.videoUrl!,
-        progress: 100,
-      }));
-      config.onProcessingComplete?.({ success: true, videoUrl: result.videoUrl });
-    } else {
-      const errorMessage = result.error || "Processing failed";
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: errorMessage,
-        progress: 0,
-      }));
-      config.onError?.(errorMessage);
-    }
-  }, [state.sourceImageUri, state.targetImageUri, config, handleProgress]);
-
-  const save = useCallback(async () => {
-    if (!state.processedVideoUrl) return;
-
-    try {
-      await onSaveVideo(state.processedVideoUrl);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
-    }
-  }, [state.processedVideoUrl, onSaveVideo]);
-
-  const reset = useCallback(() => {
-    setState(initialState);
-  }, []);
-
-  return {
-    ...state,
-    selectSourceImage,
-    selectTargetImage,
-    process,
-    save,
-    reset,
-  };
+export function useAIKissFeature(props: UseAIKissFeatureProps): UseAIKissFeatureReturn {
+  return useDualImageVideoFeature({
+    featureType: "ai-kiss",
+    ...props,
+  });
 }

package/src/features/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -1,10 +1,11 @@
 /**
  * Image-to-Video Executor
  * Provider-agnostic image-to-video execution using active AI provider
- * Matches text-to-video pattern for consistency
+ * Uses progress mapper for consistent progress reporting
  */
 
 import { providerRegistry } from "../../../../infrastructure/services";
+import { getProgressFromJobStatus } from "../../../../infrastructure/utils";
 import type {
   ImageToVideoRequest,
   ImageToVideoResult,
@@ -103,14 +104,9 @@ export async function executeImageToVideo(
           // eslint-disable-next-line no-console
           console.log("[ImageToVideoExecutor] Queue status:", status.status, "position:", status.queuePosition);
         }
-        // Map queue status to progress
-        if (status.status === "IN_QUEUE") {
-          onProgress?.(10);
-        } else if (status.status === "IN_PROGRESS") {
-          onProgress?.(50);
-        } else if (status.status === "COMPLETED") {
-          onProgress?.(90);
-        }
+        // Map provider status to progress using centralized mapper
+        const progress = getProgressFromJobStatus(status.status);
+        onProgress?.(progress);
       },
       timeoutMs: 300000, // 5 minutes timeout for video generation
     });

package/src/features/image-to-video/presentation/hooks/useImageToVideoForm.ts

@@ -63,27 +63,32 @@ export function useImageToVideoForm(
 
   const handleSelectImages = useCallback(async () => {
     if (__DEV__) {
+      // eslint-disable-next-line no-console
       console.log("[useImageToVideoForm] handleSelectImages called");
     }
     if (callbacks.onSelectImages) {
       try {
         const images = await callbacks.onSelectImages();
         if (__DEV__) {
+          // eslint-disable-next-line no-console
           console.log("[useImageToVideoForm] Images selected:", images.length);
         }
         if (images.length > 0) {
           actions.addImages(images);
           if (__DEV__) {
+            // eslint-disable-next-line no-console
             console.log("[useImageToVideoForm] Images added to state");
           }
         }
       } catch (error) {
         if (__DEV__) {
+          // eslint-disable-next-line no-console
           console.error("[useImageToVideoForm] Error selecting images:", error);
         }
       }
     } else {
       if (__DEV__) {
+        // eslint-disable-next-line no-console
         console.warn("[useImageToVideoForm] No onSelectImages callback provided");
       }
     }

package/src/features/replace-background/index.ts

@@ -1,31 +1,9 @@
 /**
  * Replace Background Feature
- * AI-powered background replacement and removal feature for React Native
+ * AI-powered background replacement feature for React Native
  */
 
-// Domain Types - Legacy
-export type {
-  BackgroundProcessRequest,
-  BackgroundProcessResult,
-  BackgroundFeatureState,
-  SamplePrompt,
-  StudioMode,
-  StudioModeConfig,
-  ComparisonState,
-  ImagePickerProps,
-  PromptInputProps,
-  GenerateButtonProps,
-  ResultDisplayProps,
-  ErrorDisplayProps,
-  FeatureHeaderProps,
-  ModeSelectorProps,
-  ComparisonSliderProps,
-  ProcessRequestParams,
-  BackgroundFeatureConfig,
-  UseBackgroundFeatureConfig,
-} from "./domain/entities";
-
-// Domain Types - Provider-Agnostic
+// Domain Types
 export type {
   ReplaceBackgroundMode,
   ReplaceBackgroundOptions,
@@ -37,36 +15,13 @@ export type {
   ReplaceBackgroundResultExtractor,
 } from "./domain/types";
 
-// Constants
-export { DEFAULT_SAMPLE_PROMPTS } from "./infrastructure/constants";
-
 // Presentation Components
-export {
-  BackgroundFeature,
-  ReplaceBackgroundFeature,
-  ImagePicker,
-  PromptInput,
-  GenerateButton,
-  ResultDisplay,
-  ErrorDisplay,
-  FeatureHeader,
-  ComparisonSlider,
-  ModeSelector,
-} from "./presentation/components";
-
-export type {
-  BackgroundFeatureProps,
-  ReplaceBackgroundFeatureProps,
-} from "./presentation/components";
+export { ReplaceBackgroundFeature } from "./presentation/components";
+export type { ReplaceBackgroundFeatureProps } from "./presentation/components";
 
 // Presentation Hooks
-export {
-  useBackgroundFeature,
-  useReplaceBackgroundFeature,
-} from "./presentation/hooks";
-
+export { useReplaceBackgroundFeature } from "./presentation/hooks";
 export type {
-  UseBackgroundFeatureReturn,
   UseReplaceBackgroundFeatureProps,
   UseReplaceBackgroundFeatureReturn,
 } from "./presentation/hooks";

package/src/features/replace-background/presentation/components/index.ts

@@ -2,17 +2,5 @@
  * Presentation Components Export
  */
 
-export { BackgroundFeature } from "./BackgroundFeature";
-export type { BackgroundFeatureProps } from "./BackgroundFeature";
-
 export { ReplaceBackgroundFeature } from "./ReplaceBackgroundFeature";
 export type { ReplaceBackgroundFeatureProps } from "./ReplaceBackgroundFeature";
-
-export { ImagePicker } from "./ImagePicker";
-export { PromptInput } from "./PromptInput";
-export { GenerateButton } from "./GenerateButton";
-export { ResultDisplay } from "./ResultDisplay";
-export { ErrorDisplay } from "./ErrorDisplay";
-export { FeatureHeader } from "./FeatureHeader";
-export { ComparisonSlider } from "./ComparisonSlider";
-export { ModeSelector } from "./ModeSelector";

package/src/features/replace-background/presentation/hooks/index.ts

@@ -2,9 +2,6 @@
  * Presentation Hooks Export
  */
 
-export { useBackgroundFeature } from "./useBackgroundFeature";
-export type { UseBackgroundFeatureReturn } from "./useBackgroundFeature";
-
 export { useReplaceBackgroundFeature } from "./useReplaceBackgroundFeature";
 export type {
   UseReplaceBackgroundFeatureProps,

package/src/features/shared/dual-image-video/domain/types/dual-image-video.types.ts

@@ -0,0 +1,67 @@
+/**
+ * Dual Image Video Feature Types
+ * Shared types for video features that take two images (ai-hug, ai-kiss, etc.)
+ * DRY: Consolidates common types from ai-hug and ai-kiss features
+ */
+
+import type { VideoFeatureType } from "../../../../../domain/interfaces/ai-provider.interface";
+
+export interface DualImageVideoFeatureState {
+  sourceImageUri: string | null;
+  targetImageUri: string | null;
+  processedVideoUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface DualImageVideoResult {
+  success: boolean;
+  videoUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export type DualImageVideoResultExtractor = (result: unknown) => string | undefined;
+
+export interface DualImageVideoFeatureConfig {
+  creditCost?: number;
+  extractResult?: DualImageVideoResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onSourceImageSelect?: (uri: string) => void;
+  onTargetImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: DualImageVideoResult) => void;
+  onError?: (error: string) => void;
+}
+
+export interface DualImageVideoTranslations {
+  sourceUploadTitle: string;
+  sourceUploadSubtitle: string;
+  targetUploadTitle: string;
+  targetUploadSubtitle: string;
+  uploadChange: string;
+  uploadAnalyzing: string;
+  description: string;
+  processingText: string;
+  processButtonText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export interface UseDualImageVideoFeatureProps {
+  featureType: VideoFeatureType;
+  config: DualImageVideoFeatureConfig;
+  onSelectSourceImage: () => Promise<string | null>;
+  onSelectTargetImage: () => Promise<string | null>;
+  onSaveVideo: (videoUrl: string) => Promise<void>;
+}
+
+export interface UseDualImageVideoFeatureReturn extends DualImageVideoFeatureState {
+  selectSourceImage: () => Promise<void>;
+  selectTargetImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}

package/src/features/shared/dual-image-video/domain/types/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Dual Image Video Domain Types
+ */
+
+export type {
+  DualImageVideoFeatureState,
+  DualImageVideoResult,
+  DualImageVideoResultExtractor,
+  DualImageVideoFeatureConfig,
+  DualImageVideoTranslations,
+  UseDualImageVideoFeatureProps,
+  UseDualImageVideoFeatureReturn,
+} from "./dual-image-video.types";

package/src/features/shared/dual-image-video/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Dual Image Video Feature (Shared)
+ * Base infrastructure for video features using two source images
+ */
+
+export type {
+  DualImageVideoFeatureState,
+  DualImageVideoResult,
+  DualImageVideoResultExtractor,
+  DualImageVideoFeatureConfig,
+  DualImageVideoTranslations,
+  UseDualImageVideoFeatureProps,
+  UseDualImageVideoFeatureReturn,
+} from "./domain/types";
+
+export { useDualImageVideoFeature } from "./presentation/hooks";

package/src/features/shared/dual-image-video/presentation/hooks/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Dual Image Video Presentation Hooks
+ */
+
+export { useDualImageVideoFeature } from "./useDualImageVideoFeature";