@umituz/react-native-ai-generation-content 1.17.142 → 1.17.144

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.142",
+  "version": "1.17.144",
   "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,16 +104,18 @@ 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);
-        }
+        // Map provider status to progress using centralized mapper
+        const progress = getProgressFromJobStatus(status.status);
+        onProgress?.(progress);
       },
       timeoutMs: 300000, // 5 minutes timeout for video generation
     });
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ImageToVideoExecutor] Subscribe resolved, result keys:", result ? Object.keys(result as object) : "null");
+    }
+
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
       console.log("[ImageToVideoExecutor] provider.subscribe() completed");

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/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";

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

@@ -0,0 +1,124 @@
+/**
+ * useDualImageVideoFeature Hook
+ * Base hook for video features that take two images (ai-hug, ai-kiss, etc.)
+ * DRY: Consolidates common logic from useAIHugFeature and useAIKissFeature
+ */
+
+import { useState, useCallback } from "react";
+import { executeVideoFeature } from "../../../../../infrastructure/services";
+import type {
+  DualImageVideoFeatureState,
+  UseDualImageVideoFeatureProps,
+  UseDualImageVideoFeatureReturn,
+} from "../../domain/types/dual-image-video.types";
+
+const initialState: DualImageVideoFeatureState = {
+  sourceImageUri: null,
+  targetImageUri: null,
+  processedVideoUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useDualImageVideoFeature(
+  props: UseDualImageVideoFeatureProps,
+): UseDualImageVideoFeatureReturn {
+  const { featureType, config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
+  const [state, setState] = useState<DualImageVideoFeatureState>(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(
+      featureType,
+      { 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, featureType, 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,
+  };
+}

package/src/features/shared/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared Features
+ * Common infrastructure for multiple feature types
+ */
+
+export * from "./dual-image-video";

package/src/infrastructure/utils/progress-calculator.util.ts

@@ -1,6 +1,7 @@
 /**
  * Progress Calculator Utility
  * Calculates progress based on generation stage
+ * Maps provider status to generation progress
  */
 
 import type { GenerationStatus } from "../../domain/entities";
@@ -8,6 +9,7 @@ import {
   DEFAULT_PROGRESS_STAGES,
   type ProgressStageConfig,
 } from "../../domain/entities";
+import type { AIJobStatusType } from "../../domain/interfaces/ai-provider.interface";
 
 export interface ProgressOptions {
   status: GenerationStatus;
@@ -95,3 +97,32 @@ export function createProgressTracker(stages?: ProgressStageConfig[]) {
     },
   };
 }
+
+/**
+ * Maps provider job status to generation status
+ * Provider: IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED
+ * Generation: idle, preparing, submitting, generating, polling, finalizing, completed, failed
+ */
+export function mapJobStatusToGenerationStatus(
+  jobStatus: AIJobStatusType
+): GenerationStatus {
+  const statusMap: Record<AIJobStatusType, GenerationStatus> = {
+    IN_QUEUE: "submitting",
+    IN_PROGRESS: "generating",
+    COMPLETED: "completed",
+    FAILED: "failed",
+  };
+  return statusMap[jobStatus] ?? "generating";
+}
+
+/**
+ * Calculate progress from provider job status
+ * Uses default progress stages for consistent progress reporting
+ */
+export function getProgressFromJobStatus(
+  jobStatus: AIJobStatusType,
+  stages: ProgressStageConfig[] = DEFAULT_PROGRESS_STAGES
+): number {
+  const generationStatus = mapJobStatusToGenerationStatus(jobStatus);
+  return getProgressForStatus({ status: generationStatus, stages });
+}

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

@@ -1,54 +0,0 @@
-/**
- * useStatusFilter Hook
- * Handles status filtering (completed, pending, processing, failed)
- * SOLID: Single Responsibility - Only handles status filter state
- */
-
-import { useState, useCallback, useMemo } from "react";
-import type { FilterOption } from "../../domain/types/creation-filter";
-
-interface UseStatusFilterProps {
-  readonly options: FilterOption[];
-  readonly t: (key: string) => string;
-  readonly defaultId?: string;
-}
-
-interface UseStatusFilterReturn {
-  readonly selectedId: string;
-  readonly filterOptions: FilterOption[];
-  readonly hasActiveFilter: boolean;
-  readonly selectFilter: (id: string) => void;
-  readonly clearFilter: () => void;
-}
-
-export function useStatusFilter({
-  options,
-  t,
-  defaultId = "all"
-}: UseStatusFilterProps): UseStatusFilterReturn {
-  const [selectedId, setSelectedId] = useState(defaultId);
-
-  const filterOptions = useMemo(() =>
-    options.map(opt => ({
-      ...opt,
-      label: opt.labelKey ? t(opt.labelKey) : opt.label
-    })),
-    [options, t]
-  );
-
-  const selectFilter = useCallback((id: string) => {
-    setSelectedId(id);
-  }, []);
-
-  const clearFilter = useCallback(() => {
-    setSelectedId(defaultId);
-  }, [defaultId]);
-
-  return {
-    selectedId,
-    filterOptions,
-    hasActiveFilter: selectedId !== defaultId,
-    selectFilter,
-    clearFilter
-  };
-}