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

package/src/domains/generation/wizard/presentation/hooks/useWizardFlowHandlers.ts

@@ -1,32 +1,9 @@
-/**
- * Wizard Flow Handlers Hook
- * Extracts callback handlers from WizardFlowContent
- */
-
 import { useCallback } from "react";
 import { AlertType, AlertMode, useAlert } from "@umituz/react-native-design-system";
 import { StepType, type StepDefinition } from "../../../../../domain/entities/flow-config.types";
 import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 import type { Creation } from "../../../../creations/domain/entities/Creation";
-
-declare const __DEV__: boolean;
-
-/**
- * Type guard to check if result is a valid Creation object
- */
-function isCreation(result: unknown): result is Creation {
-  if (!result || typeof result !== "object") {
-    return false;
-  }
-  const creation = result as Partial<Creation>;
-  return (
-    typeof creation.id === "string" &&
-    typeof creation.uri === "string" &&
-    typeof creation.type === "string" &&
-    creation.createdAt instanceof Date &&
-    typeof creation.isShared === "boolean"
-  );
-}
+import { isCreation } from "./typeGuards";
 
 export interface UseWizardFlowHandlersProps {
   readonly currentStepIndex: number;
@@ -77,21 +54,8 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleGenerationComplete = useCallback(
     (result: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Generation completed");
-      }
       setResult(result);
-
-      // Use type guard to safely check if result is a Creation
-      if (isCreation(result)) {
-        setCurrentCreation(result);
-      } else {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[WizardFlowHandlers] Result is not a valid Creation object:", result);
-        }
-        setCurrentCreation(null);
-      }
-
+      setCurrentCreation(isCreation(result) ? result : null);
       onGenerationComplete?.(result);
       if (!skipResultStep) nextStep();
     },
@@ -100,43 +64,17 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleGenerationError = useCallback(
     (errorMessage: string) => {
-      // Ensure we have a meaningful error message
       const safeErrorMessage = errorMessage?.trim() || "error.generation.unknown";
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Generation error:", {
-          original: errorMessage,
-          safe: safeErrorMessage,
-        });
-      }
-      // Translate error key if it looks like a translation key
-      const displayMessage = safeErrorMessage.startsWith("error.")
-        ? t(safeErrorMessage)
-        : safeErrorMessage;
-      // Show error alert to user
-      alert.show(
-        AlertType.ERROR,
-        AlertMode.MODAL,
-        t("common.error"),
-        displayMessage,
-      );
-      // Notify parent component
+      const displayMessage = safeErrorMessage.startsWith("error.") ? t(safeErrorMessage) : safeErrorMessage;
+      alert.show(AlertType.ERROR, AlertMode.MODAL, t("common.error"), displayMessage);
       onGenerationError?.(safeErrorMessage);
-      // Close the wizard
       onBack?.();
     },
     [alert, t, onGenerationError, onBack],
   );
 
   const handleDismissGenerating = useCallback(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardFlowHandlers] Dismissing - generation continues");
-    }
-    alert.show(
-      AlertType.INFO,
-      AlertMode.TOAST,
-      t("generator.backgroundTitle"),
-      t("generator.backgroundMessage"),
-    );
+    alert.show(AlertType.INFO, AlertMode.TOAST, t("generator.backgroundTitle"), t("generator.backgroundMessage"));
     onBack?.();
   }, [alert, t, onBack]);
 
@@ -147,18 +85,7 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleNextStep = useCallback(() => {
     const nextStepDef = flowSteps[currentStepIndex + 1];
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardFlowHandlers] handleNextStep", {
-        currentStepIndex,
-        nextStepType: nextStepDef?.type,
-        isGenerating: nextStepDef?.type === StepType.GENERATING,
-        hasOnGenerationStart: !!onGenerationStart,
-      });
-    }
     if (nextStepDef?.type === StepType.GENERATING && onGenerationStart) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Calling onGenerationStart callback");
-      }
       onGenerationStart(customData, nextStep);
       return;
     }
@@ -179,12 +106,7 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
       const success = await repository.rate(userId, currentCreation.id, rating, description);
       if (success) {
         setHasRated(true);
-        alert.show(
-          AlertType.SUCCESS,
-          AlertMode.TOAST,
-          t("result.rateSuccessTitle"),
-          t("result.rateSuccessMessage"),
-        );
+        alert.show(AlertType.SUCCESS, AlertMode.TOAST, t("result.rateSuccessTitle"), t("result.rateSuccessMessage"));
       }
       setShowRatingPicker(false);
     },

package/src/domains/generation/wizard/presentation/hooks/useWizardGeneration.ts

@@ -1,75 +1,16 @@
 /**
- * useWizardGeneration Hook
- * Orchestrates wizard-based generation by delegating to appropriate mode:
- * - Video: Queue-based generation with background support
- * - Photo: Blocking execution for quick results
- *
- * Architecture: State machine pattern with useReducer
- * States: IDLE → PREPARING → GENERATING → COMPLETED/ERROR → IDLE
+ * Wizard Generation Hook
+ * Orchestrates wizard-based generation (Video: queue, Photo: blocking)
  */
 
 import { useEffect, useReducer, useMemo, useRef } from "react";
-import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
+import { createWizardStrategy } from "../../infrastructure/strategies";
 import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import { useVideoQueueGeneration } from "./useVideoQueueGeneration";
 import { usePhotoBlockingGeneration } from "./usePhotoBlockingGeneration";
-import type {
-  UseWizardGenerationProps,
-  UseWizardGenerationReturn,
-} from "./wizard-generation.types";
-
-declare const __DEV__: boolean;
-
-/**
- * Generation orchestration states
- */
-type GenerationStatus =
-  | "IDLE"        // Not started
-  | "PREPARING"   // Building input
-  | "GENERATING"  // Generation in progress
-  | "ERROR"       // Failed (prevents retry)
-  | "COMPLETED";  // Success
-
-/**
- * State machine state
- */
-interface GenerationState {
-  status: GenerationStatus;
-  error?: string;
-}
-
-/**
- * State machine actions
- */
-type GenerationAction =
-  | { type: "START_PREPARATION" }
-  | { type: "START_GENERATION" }
-  | { type: "COMPLETE" }
-  | { type: "ERROR"; error: string }
-  | { type: "RESET" };
-
-/**
- * State machine reducer
- */
-const generationReducer = (
-  state: GenerationState,
-  action: GenerationAction,
-): GenerationState => {
-  switch (action.type) {
-    case "START_PREPARATION":
-      return { status: "PREPARING" };
-    case "START_GENERATION":
-      return { status: "GENERATING" };
-    case "COMPLETE":
-      return { status: "COMPLETED" };
-    case "ERROR":
-      return { status: "ERROR", error: action.error };
-    case "RESET":
-      return { status: "IDLE" };
-    default:
-      return state;
-  }
-};
+import { generationReducer, INITIAL_STATE } from "./generationStateMachine";
+import { executeWizardGeneration } from "./generationExecutor";
+import type { UseWizardGenerationProps, UseWizardGenerationReturn } from "./wizard-generation.types";
 
 export type {
   WizardOutputType,
@@ -78,9 +19,7 @@ export type {
   UseWizardGenerationReturn,
 } from "./wizard-generation.types";
 
-export const useWizardGeneration = (
-  props: UseWizardGenerationProps,
-): UseWizardGenerationReturn => {
+export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardGenerationReturn => {
   const {
     scenario,
     wizardData,
@@ -93,10 +32,7 @@ export const useWizardGeneration = (
     onCreditsExhausted,
   } = props;
 
-  // State machine: replaces multiple useRef flags
-  const [state, dispatch] = useReducer(generationReducer, { status: "IDLE" });
-
-  // Mounted ref to prevent state updates after unmount
+  const [state, dispatch] = useReducer(generationReducer, INITIAL_STATE);
   const isMountedRef = useRef(true);
 
   useEffect(() => {
@@ -107,14 +43,9 @@ export const useWizardGeneration = (
   }, []);
 
   const persistence = useMemo(() => createCreationPersistence(), []);
-  const strategy = useMemo(
-    () => createWizardStrategy({ scenario, creditCost }),
-    [scenario, creditCost],
-  );
-
+  const strategy = useMemo(() => createWizardStrategy({ scenario, creditCost }), [scenario, creditCost]);
   const isVideoMode = scenario.outputType === "video" && !!strategy.submitToQueue;
 
-  // Video generation hook (queue-based)
   const videoGeneration = useVideoQueueGeneration({
     userId,
     scenario,
@@ -124,7 +55,6 @@ export const useWizardGeneration = (
     onError,
   });
 
-  // Photo generation hook (blocking)
   const photoGeneration = usePhotoBlockingGeneration({
     userId,
     scenario,
@@ -136,67 +66,25 @@ export const useWizardGeneration = (
     onCreditsExhausted,
   });
 
-  // Main effect: trigger generation when step becomes active
   useEffect(() => {
     const isAlreadyGenerating = videoGeneration.isGenerating || photoGeneration.isGenerating;
 
-    // Start generation: Simple single condition using state machine
     if (isGeneratingStep && state.status === "IDLE" && !isAlreadyGenerating) {
       dispatch({ type: "START_PREPARATION" });
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardGeneration] State: PREPARING");
-      }
-
-      buildWizardInput(wizardData, scenario)
-        .then(async (input) => {
-          // Check if component is still mounted
-          if (!isMountedRef.current) return;
-
-          if (!input) {
-            dispatch({ type: "ERROR", error: "Failed to build generation input" });
-            onError?.("Failed to build generation input");
-            return;
-          }
-
-          dispatch({ type: "START_GENERATION" });
-
-          const typedInput = input as { prompt?: string };
-
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[WizardGeneration] State: GENERATING");
-            console.log("[WizardGeneration] Mode:", isVideoMode ? "VIDEO_QUEUE" : "PHOTO_BLOCKING");
-          }
-
-          if (isVideoMode) {
-            await videoGeneration.startGeneration(input, typedInput.prompt || "");
-          } else {
-            await photoGeneration.startGeneration(input, typedInput.prompt || "");
-          }
-
-          // Check again before final state update
-          if (isMountedRef.current) {
-            dispatch({ type: "COMPLETE" });
-          }
-        })
-        .catch((error) => {
-          // Check if component is still mounted before error handling
-          if (!isMountedRef.current) return;
-
-          const errorMsg = error?.message || "error.generation.unknown";
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[WizardGeneration] Build input error:", errorMsg, error);
-          }
-          dispatch({ type: "ERROR", error: errorMsg });
-          onError?.(errorMsg);
-        });
+      executeWizardGeneration({
+        wizardData,
+        scenario,
+        isVideoMode,
+        isMountedRef,
+        dispatch,
+        onError,
+        videoGenerationFn: videoGeneration.startGeneration,
+        photoGenerationFn: photoGeneration.startGeneration,
+      });
     }
 
-    // Reset state when leaving generating step
     if (!isGeneratingStep && state.status !== "IDLE") {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardGeneration] State: RESET");
-      }
       dispatch({ type: "RESET" });
     }
   }, [

package/src/domains/generation/wizard/presentation/hooks/videoQueuePoller.ts

@@ -0,0 +1,59 @@
+import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
+import { extractResultUrl, type FalResult, type GenerationUrls } from "./generation-result.utils";
+import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+
+declare const __DEV__: boolean;
+
+interface PollParams {
+  requestId: string;
+  model: string;
+  isPollingRef: React.MutableRefObject<boolean>;
+  pollingRef: React.MutableRefObject<ReturnType<typeof setInterval> | null>;
+  onComplete: (urls: GenerationUrls) => Promise<void>;
+  onError: (error: string) => Promise<void>;
+}
+
+export const pollQueueStatus = async (params: PollParams): Promise<void> => {
+  const { requestId, model, isPollingRef, pollingRef, onComplete, onError } = params;
+
+  if (isPollingRef.current) return;
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider) return;
+
+  isPollingRef.current = true;
+  try {
+    const status = await provider.getJobStatus(model, requestId);
+    if (__DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
+
+    if (status.status === QUEUE_STATUS.COMPLETED || status.status === QUEUE_STATUS.FAILED) {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current);
+        pollingRef.current = null;
+      }
+
+      if (status.status === QUEUE_STATUS.COMPLETED) {
+        try {
+          const result = await provider.getJobResult<FalResult>(model, requestId);
+          await onComplete(extractResultUrl(result));
+        } catch (resultErr) {
+          const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
+          if (__DEV__) console.error("[VideoQueueGeneration] Result error:", errorMessage);
+          await onError(errorMessage);
+        }
+      } else {
+        await onError("Generation failed");
+      }
+    }
+  } catch (err) {
+    if (pollingRef.current) {
+      clearInterval(pollingRef.current);
+      pollingRef.current = null;
+    }
+    const errorMessage = err instanceof Error ? err.message : "Generation failed";
+    if (__DEV__) console.error("[VideoQueueGeneration] Poll error:", errorMessage);
+    await onError(errorMessage);
+  } finally {
+    isPollingRef.current = false;
+  }
+};

package/src/domains/image-to-video/presentation/hooks/imageToVideoStrategy.ts

@@ -0,0 +1,77 @@
+import { executeImageToVideo } from "../../infrastructure/services";
+import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
+import type {
+  ImageToVideoConfig,
+  ImageToVideoCallbacks,
+  ImageToVideoResult,
+  ImageToVideoOptions,
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+} from "../../domain/types";
+
+interface VideoGenerationInput {
+  imageUrl: string;
+  prompt: string;
+  options?: ImageToVideoOptions;
+  creationId: string;
+}
+
+interface CreateStrategyParams {
+  config: ImageToVideoConfig;
+  callbacks: ImageToVideoCallbacks;
+  buildInput: ImageToVideoInputBuilder;
+  extractResult?: ImageToVideoResultExtractor;
+  userId: string;
+  currentPrompt: string;
+  creationIdRef: React.MutableRefObject<string>;
+  updateState: (videoUrl: string | null, thumbnailUrl: string | null) => void;
+}
+
+export const createImageToVideoStrategy = (
+  params: CreateStrategyParams,
+): GenerationStrategy<VideoGenerationInput, ImageToVideoResult> => {
+  const { config, callbacks, buildInput, extractResult, userId, currentPrompt, creationIdRef, updateState } = params;
+
+  return {
+    execute: async (input) => {
+      creationIdRef.current = input.creationId;
+
+      callbacks.onGenerationStart?.({
+        creationId: input.creationId,
+        type: "image-to-video",
+        imageUrl: input.imageUrl,
+        prompt: input.prompt,
+        metadata: input.options as Record<string, unknown> | undefined,
+      }).catch(() => {});
+
+      const result = await executeImageToVideo(
+        { imageUrl: input.imageUrl, prompt: input.prompt, userId, options: input.options },
+        { model: config.model, buildInput, extractResult },
+      );
+
+      if (!result.success || !result.videoUrl) {
+        throw new Error(result.error || "Generation failed");
+      }
+
+      updateState(result.videoUrl ?? null, result.thumbnailUrl ?? null);
+
+      return {
+        success: true,
+        videoUrl: result.videoUrl,
+        thumbnailUrl: result.thumbnailUrl,
+      };
+    },
+    getCreditCost: () => config.creditCost,
+    save: async (result) => {
+      if (result.success && result.videoUrl && creationIdRef.current) {
+        await callbacks.onCreationSave?.({
+          creationId: creationIdRef.current,
+          type: "image-to-video",
+          videoUrl: result.videoUrl,
+          thumbnailUrl: result.thumbnailUrl,
+          prompt: currentPrompt,
+        });
+      }
+    },
+  };
+};

package/src/domains/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -0,0 +1,102 @@
+import { useState, useCallback, useMemo, useRef } from "react";
+import { useGenerationOrchestrator } from "../../../../presentation/hooks/generation";
+import { createImageToVideoStrategy } from "./imageToVideoStrategy";
+import type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+  INITIAL_STATE,
+  DEFAULT_ALERT_MESSAGES,
+} from "./image-to-video-feature.types";
+
+export type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+} from "./image-to-video-feature.types";
+
+export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
+  const { config, callbacks, userId } = props;
+  const [state, setState] = useState(INITIAL_STATE);
+  const creationIdRef = useRef("");
+
+  const updateState = useCallback((videoUrl: string | null, thumbnailUrl: string | null) => {
+    setState((prev) => ({ ...prev, videoUrl, thumbnailUrl }));
+  }, []);
+
+  const strategy = useMemo(
+    () =>
+      createImageToVideoStrategy({
+        config,
+        callbacks,
+        buildInput: config.buildInput,
+        extractResult: config.extractResult,
+        userId,
+        currentPrompt: state.motionPrompt || "",
+        creationIdRef,
+        updateState,
+      }),
+    [config, callbacks, userId, state.motionPrompt, updateState],
+  );
+
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost ?? 0),
+    onSuccess: (result) => {
+      config.onProcessingComplete?.();
+      callbacks.onGenerate?.(result);
+    },
+    onError: (err) => {
+      config.onProcessingError?.(err.message);
+      callbacks.onError?.(err.message);
+    },
+  });
+
+  const setImageUri = useCallback((imageUri: string) => {
+    setState((prev) => ({ ...prev, imageUri, error: null }));
+  }, []);
+
+  const setMotionPrompt = useCallback((motionPrompt: string) => {
+    setState((prev) => ({ ...prev, motionPrompt, error: null }));
+  }, []);
+
+  const generate = useCallback(
+    async (params?: any) => {
+      const imageUri = params?.imageUri || state.imageUri;
+      if (!imageUri) {
+        const error = "Image is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+
+      try {
+        const result = await orchestrator.generate({
+          imageUrl: imageUri,
+          prompt: state.motionPrompt || "",
+          options: params,
+          creationId: `image-to-video-${Date.now()}`,
+        });
+        setState((prev) => ({ ...prev, isProcessing: false }));
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Generation failed";
+        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
+        return { success: false, error: message };
+      }
+    },
+    [state.imageUri, state.motionPrompt, orchestrator],
+  );
+
+  const reset = useCallback(() => setState(INITIAL_STATE), []);
+
+  return {
+    state,
+    setImageUri,
+    setMotionPrompt,
+    generate,
+    reset,
+    isReady: !orchestrator.isGenerating && !state.isProcessing,
+    canGenerate: !orchestrator.isGenerating && !state.isProcessing && !!state.imageUri,
+  };
+}