@umituz/react-native-ai-generation-content 1.90.2 → 1.90.3

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

@@ -2,298 +2,4 @@
  * Video Queue Generation Hook
  */
 
-import { useEffect, useRef, useCallback, useState } from "react";
-
-import { pollQueueStatus } from "./videoQueuePoller";
-import {
-  DEFAULT_POLL_INTERVAL_MS,
-  DEFAULT_MAX_POLL_TIME_MS,
-} from "../../../../../infrastructure/constants/polling.constants";
-import type { GenerationUrls } from "./generation-result.utils";
-import type {
-  UseVideoQueueGenerationProps,
-  UseVideoQueueGenerationReturn,
-} from "./use-video-queue-generation.types";
-
-export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): UseVideoQueueGenerationReturn {
-  const { userId, scenario, persistence, strategy, creditCost, deductCredits, onSuccess, onError } = props;
-
-  const creationIdRef = useRef<string | null>(null);
-  const requestIdRef = useRef<string | null>(null);
-  const modelRef = useRef<string | null>(null);
-  const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  const isGeneratingRef = useRef(false);
-  const isPollingRef = useRef(false);
-  const consecutiveErrorsRef = useRef(0);
-  const pollStartTimeRef = useRef<number | null>(null);
-  const [isGenerating, setIsGenerating] = useState(false);
-
-  const clearPolling = useCallback(() => {
-    if (pollingRef.current) {
-      clearInterval(pollingRef.current);
-      pollingRef.current = null;
-    }
-  }, []);
-
-  useEffect(() => {
-    return () => {
-      clearPolling();
-      isGeneratingRef.current = false;
-      isPollingRef.current = false;
-      consecutiveErrorsRef.current = 0;
-      pollStartTimeRef.current = null;
-      // NOTE: Do NOT null creationIdRef/requestIdRef/modelRef here.
-      // In-flight poll callbacks may still resolve after unmount and need
-      // these refs to properly save the completed generation to Firestore.
-      // They are cleaned up by resetRefs() after handleComplete/handleError.
-      setIsGenerating(false);
-    };
-  }, [clearPolling]);
-
-  const resetRefs = useCallback(() => {
-    clearPolling();
-    creationIdRef.current = null;
-    requestIdRef.current = null;
-    modelRef.current = null;
-    isGeneratingRef.current = false;
-    isPollingRef.current = false;
-    consecutiveErrorsRef.current = 0;
-    pollStartTimeRef.current = null;
-    setIsGenerating(false);
-  }, [clearPolling]);
-
-  const handleComplete = useCallback(
-    async (urls: GenerationUrls) => {
-      clearPolling();
-
-      const creationId = creationIdRef.current;
-      const uri = (urls.videoUrl || urls.imageUrl) ?? "";
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoQueue] ✅ handleComplete called", {
-          creationId,
-          userId,
-          hasVideoUrl: !!urls.videoUrl,
-          hasImageUrl: !!urls.imageUrl,
-          hasOnSuccess: !!onSuccess
-        });
-      }
-
-      if (!creationId || !userId || !uri || uri.trim() === "") {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[VideoQueue] ❌ Invalid completion data:", { creationId, userId, uri });
-        }
-        resetRefs();
-        onError?.("Invalid completion data - no valid URL received");
-        return;
-      }
-
-      let persistenceSucceeded = true;
-      if (creationId && userId) {
-        try {
-          await persistence.updateToCompleted(userId, creationId, {
-            uri,
-            imageUrl: urls.imageUrl,
-            videoUrl: urls.videoUrl,
-            thumbnailUrl: urls.thumbnailUrl,
-            generationStartedAt: pollStartTimeRef.current ?? undefined,
-          });
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[VideoQueue] ✅ Updated completion status in Firestore");
-          }
-        } catch (error) {
-          persistenceSucceeded = false;
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[VideoQueue] ❌ Failed to update completion status:", error);
-          }
-        }
-      }
-
-      resetRefs();
-
-      // Deduct credits after successful generation
-      if (deductCredits && creditCost) {
-        await deductCredits(creditCost).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[VideoQueue] deductCredits error:", err);
-          }
-        });
-      }
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoQueue] 🎯 Calling onSuccess callback now...", { persistenceSucceeded });
-      }
-      onSuccess?.(urls);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoQueue] ✅ onSuccess callback completed");
-      }
-    },
-    [userId, persistence, deductCredits, creditCost, onSuccess, onError, resetRefs, clearPolling],
-  );
-
-  const handleError = useCallback(
-    async (errorMsg: string) => {
-      clearPolling();
-      const creationId = creationIdRef.current;
-      if (creationId && userId) {
-        try {
-          await persistence.updateToFailed(userId, creationId, errorMsg);
-        } catch (error) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[VideoQueue] Failed to update error status:", error);
-          }
-        }
-      }
-      resetRefs();
-      onError?.(errorMsg);
-    },
-    [userId, persistence, onError, resetRefs, clearPolling],
-  );
-
-  // Use a ref to hold the latest handleComplete/handleError to avoid stale closures
-  // in the setInterval callback
-  const handleCompleteRef = useRef(handleComplete);
-  const handleErrorRef = useRef(handleError);
-  useEffect(() => { handleCompleteRef.current = handleComplete; }, [handleComplete]);
-  useEffect(() => { handleErrorRef.current = handleError; }, [handleError]);
-
-  const pollStatus = useCallback(async () => {
-    const requestId = requestIdRef.current;
-    const model = modelRef.current;
-    if (!requestId || !model) return;
-
-    // Check max poll time
-    if (pollStartTimeRef.current !== null) {
-      const elapsed = Date.now() - pollStartTimeRef.current;
-      if (elapsed >= DEFAULT_MAX_POLL_TIME_MS) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[VideoQueue] ⏰ Max poll time exceeded, aborting");
-        }
-        await handleErrorRef.current("Generation timed out. Please try again.");
-        return;
-      }
-    }
-
-    try {
-      await pollQueueStatus({
-        requestId,
-        model,
-        isPollingRef,
-        pollingRef,
-        consecutiveErrorsRef,
-        onComplete: handleCompleteRef.current,
-        onError: handleErrorRef.current,
-      });
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[VideoQueue] Unexpected poll error:", error);
-      }
-    }
-  }, []);
-
-  // Keep a stable ref to pollStatus for the setInterval closure
-  const pollStatusRef = useRef(pollStatus);
-  useEffect(() => { pollStatusRef.current = pollStatus; }, [pollStatus]);
-
-  const startGeneration = useCallback(
-    async (input: unknown, prompt: string) => {
-      if (!strategy.submitToQueue) {
-        onError?.("Queue submission not available");
-        return;
-      }
-      if (isGeneratingRef.current) return;
-
-      isGeneratingRef.current = true;
-      setIsGenerating(true);
-
-      let creationId: string | null = null;
-      if (userId && prompt) {
-        try {
-          const inputData = input as Record<string, unknown>;
-          const duration = typeof inputData?.duration === "number" ? inputData.duration : undefined;
-          const resolution = typeof inputData?.resolution === "string" ? inputData.resolution : undefined;
-          const aspectRatio = typeof inputData?.aspectRatio === "string" ? inputData.aspectRatio : undefined;
-
-          const result = await persistence.saveAsProcessing(userId, {
-            scenarioId: scenario.id,
-            scenarioTitle: scenario.title || scenario.id,
-            prompt,
-            duration,
-            resolution,
-            creditCost,
-            aspectRatio,
-            provider: "fal",
-            outputType: scenario.outputType,
-          });
-          creationId = result.creationId;
-          creationIdRef.current = creationId;
-          // Record the actual DB-level start time for accurate durationMs
-          pollStartTimeRef.current = result.startedAt.getTime();
-        } catch (error) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[VideoQueue] Failed to save processing creation:", error);
-          }
-        }
-      }
-
-      let queueResult;
-      try {
-        queueResult = await strategy.submitToQueue(input);
-      } catch (error) {
-        if (creationId && userId) {
-          try {
-            await persistence.updateToFailed(userId, creationId, error instanceof Error ? error.message : "Queue submission failed");
-          } catch (persistError) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.error("[VideoQueue] Failed to persist submission error:", persistError);
-            }
-          }
-        }
-        isGeneratingRef.current = false;
-        setIsGenerating(false);
-        onError?.(error instanceof Error ? error.message : "Queue submission failed");
-        return;
-      }
-
-      if (!queueResult.success || !queueResult.requestId || !queueResult.model) {
-        if (creationId && userId) {
-          try {
-            await persistence.updateToFailed(userId, creationId, queueResult.error || "Queue submission failed");
-          } catch (persistError) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.error("[VideoQueue] Failed to persist queue failure:", persistError);
-            }
-          }
-        }
-        isGeneratingRef.current = false;
-        setIsGenerating(false);
-        onError?.(queueResult.error || "Queue submission failed");
-        return;
-      }
-
-      requestIdRef.current = queueResult.requestId;
-      modelRef.current = queueResult.model;
-
-      if (creationId && userId && queueResult.requestId && queueResult.model) {
-        try {
-          await persistence.updateRequestId(userId, creationId, queueResult.requestId, queueResult.model);
-        } catch (error) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[VideoQueue] Failed to update request ID:", error);
-          }
-        }
-      }
-
-      // Start polling: use DB-level startedAt if available, otherwise fallback to now
-      if (pollStartTimeRef.current === null) {
-        pollStartTimeRef.current = Date.now();
-      }
-      pollingRef.current = setInterval(() => void pollStatusRef.current(), DEFAULT_POLL_INTERVAL_MS);
-      void pollStatusRef.current();
-    },
-    [userId, scenario, persistence, strategy, creditCost, onError],
-  );
-
-  return { isGenerating, startGeneration };
-}
+export { useVideoQueueGeneration } from "./video-queue";

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

@@ -6,7 +6,7 @@
 import { useEffect, useReducer, useMemo, useRef } from "react";
 import { createWizardStrategy } from "../../infrastructure/strategies";
 import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
-import { useVideoQueueGeneration } from "./useVideoQueueGeneration";
+import { useVideoQueueGeneration } from "./video-queue-index";
 import { usePhotoBlockingGeneration } from "./usePhotoBlockingGeneration";
 import { generationReducer, INITIAL_STATE } from "./generationStateMachine";
 import { executeWizardGeneration } from "./generationExecutor";

package/src/domains/generation/wizard/presentation/hooks/video-queue/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Video Queue Generation Hook
+ */
+
+import { useEffect } from "react";
+import type { GenerationUrls } from "../generation-result.utils";
+import type {
+  UseVideoQueueGenerationProps,
+  UseVideoQueueGenerationReturn,
+} from "../use-video-queue-generation.types";
+import {
+  createClearPolling,
+  createResetRefs,
+} from "./use-video-queue-utils";
+import { useVideoQueueGenerationRefs, useVideoQueueGenerationState } from "./useVideoQueueGenerationRefs";
+import { useCompletionHandler, useErrorHandler } from "./useVideoQueueGenerationCallbacks";
+import { usePollStatus, useCallbackRefs } from "./useVideoQueueGenerationPolling";
+import { useStartGeneration } from "./useVideoQueueGenerationStart";
+
+export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): UseVideoQueueGenerationReturn {
+  const refs = useVideoQueueGenerationRefs();
+  const state = useVideoQueueGenerationState();
+
+  const clearPolling = (() => {
+    const { pollingRef } = refs;
+    return () => {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current);
+        pollingRef.current = null;
+      }
+    };
+  })();
+
+  useEffect(() => {
+    return () => {
+      clearPolling();
+      refs.isGeneratingRef.current = false;
+      refs.isPollingRef.current = false;
+      refs.consecutiveErrorsRef.current = 0;
+      refs.pollStartTimeRef.current = null;
+      // NOTE: Do NOT null creationIdRef/requestIdRef/modelRef here.
+      // In-flight poll callbacks may still resolve after unmount and need
+      // these refs to properly save the completed generation to Firestore.
+      // They are cleaned up by resetRefs() after handleComplete/handleError.
+      state.setIsGenerating(false);
+    };
+  }, [clearPolling, refs, state]);
+
+  const resetRefs = (() => {
+    const {
+      creationIdRef,
+      requestIdRef,
+      modelRef,
+      isGeneratingRef,
+      isPollingRef,
+      consecutiveErrorsRef,
+      pollStartTimeRef,
+    } = refs;
+    const { setIsGenerating } = state;
+
+    return () => {
+      creationIdRef.current = null;
+      requestIdRef.current = null;
+      modelRef.current = null;
+      isGeneratingRef.current = false;
+      isPollingRef.current = false;
+      consecutiveErrorsRef.current = 0;
+      pollStartTimeRef.current = null;
+      setIsGenerating(false);
+    };
+  })();
+
+  const handleComplete = useCompletionHandler(props, refs, state, clearPolling, resetRefs);
+  const handleError = useErrorHandler(props, refs, clearPolling, resetRefs);
+  const pollStatus = usePollStatus(refs);
+  const startGeneration = useStartGeneration(props, refs, state, clearPolling);
+
+  // Sync callback refs
+  useCallbackRefs(handleComplete, handleError, pollStatus, refs);
+
+  return { isGenerating: state.isGenerating, startGeneration };
+}

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationCallbacks.ts

@@ -0,0 +1,120 @@
+/**
+ * Video Queue Generation Hook - Completion and Error Handlers
+ */
+
+import { useCallback } from "react";
+import type { GenerationUrls } from "../../generation-result.utils";
+import type {
+  UseVideoQueueGenerationProps,
+} from "../use-video-queue-generation.types";
+import {
+  logCompletion,
+  logError,
+  validateCompletionData,
+} from "./use-video-queue-utils";
+import type { VideoQueueRefs, VideoQueueState } from "./useVideoQueueGenerationRefs";
+
+/**
+ * Create completion handler callback
+ */
+export function useCompletionHandler(
+  props: UseVideoQueueGenerationProps,
+  refs: VideoQueueRefs,
+  state: VideoQueueState,
+  clearPolling: () => void,
+  resetRefs: () => void,
+) {
+  const { userId, persistence, strategy, creditCost, deductCredits, onSuccess, onError } = props;
+  const { setIsGenerating } = state;
+
+  return useCallback(
+    async (urls: GenerationUrls) => {
+      clearPolling();
+
+      const creationId = refs.creationIdRef.current;
+      const uri = (urls.videoUrl || urls.imageUrl) ?? "";
+
+      logCompletion(creationId, userId, urls, !!onSuccess);
+
+      if (!validateCompletionData(creationId, userId, uri)) {
+        logError("Invalid completion data:", { creationId, userId, uri });
+        resetRefs();
+        onError?.("Invalid completion data - no valid URL received");
+        return;
+      }
+
+      let persistenceSucceeded = true;
+      if (creationId && userId) {
+        try {
+          await persistence.updateToCompleted(userId, creationId, {
+            uri,
+            imageUrl: urls.imageUrl,
+            videoUrl: urls.videoUrl,
+            thumbnailUrl: urls.thumbnailUrl,
+            generationStartedAt: refs.pollStartTimeRef.current ?? undefined,
+          });
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[VideoQueue] ✅ Updated completion status in Firestore");
+          }
+        } catch (error) {
+          persistenceSucceeded = false;
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] ❌ Failed to update completion status:", error);
+          }
+        }
+      }
+
+      resetRefs();
+
+      // Deduct credits after successful generation
+      if (deductCredits && creditCost) {
+        await deductCredits(creditCost).catch((err) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] deductCredits error:", err);
+          }
+        });
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoQueue] 🎯 Calling onSuccess callback now...", { persistenceSucceeded });
+      }
+      onSuccess?.(urls);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoQueue] ✅ onSuccess callback completed");
+      }
+    },
+    [userId, persistence, deductCredits, creditCost, onSuccess, onError, resetRefs, clearPolling, refs],
+  );
+}
+
+/**
+ * Create error handler callback
+ */
+export function useErrorHandler(
+  props: UseVideoQueueGenerationProps,
+  refs: VideoQueueRefs,
+  clearPolling: () => void,
+  resetRefs: () => void,
+) {
+  const { userId, persistence, onError } = props;
+
+  return useCallback(
+    async (errorMsg: string) => {
+      clearPolling();
+      const creationId = refs.creationIdRef.current;
+      if (creationId && userId) {
+        try {
+          await persistence.updateToFailed(userId, creationId, errorMsg);
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] Failed to update error status:", error);
+          }
+        }
+      }
+      resetRefs();
+      onError?.(errorMsg);
+    },
+    [userId, persistence, onError, resetRefs, clearPolling, refs],
+  );
+}

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationPolling.ts

@@ -0,0 +1,76 @@
+/**
+ * Video Queue Generation Hook - Polling Logic
+ */
+
+import { useCallback, useEffect } from "react";
+import { pollQueueStatus } from "../videoQueuePoller";
+import {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_MAX_POLL_TIME_MS,
+} from "../../../../../infrastructure/constants/polling.constants";
+import type { VideoQueueRefs } from "./useVideoQueueGenerationRefs";
+
+/**
+ * Create poll status callback
+ */
+export function usePollStatus(
+  refs: VideoQueueRefs,
+): () => Promise<void> {
+  const { requestIdRef, modelRef, isPollingRef, pollingRef, consecutiveErrorsRef, pollStartTimeRef, handleCompleteRef, handleErrorRef } = refs;
+
+  return useCallback(async () => {
+    const requestId = requestIdRef.current;
+    const model = modelRef.current;
+    if (!requestId || !model) return;
+
+    // Check max poll time
+    if (pollStartTimeRef.current !== null) {
+      const elapsed = Date.now() - pollStartTimeRef.current;
+      if (elapsed >= DEFAULT_MAX_POLL_TIME_MS) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[VideoQueue] ⏰ Max poll time exceeded, aborting");
+        }
+        await handleErrorRef.current("Generation timed out. Please try again.");
+        return;
+      }
+    }
+
+    try {
+      await pollQueueStatus({
+        requestId,
+        model,
+        isPollingRef,
+        pollingRef,
+        consecutiveErrorsRef,
+        onComplete: handleCompleteRef.current,
+        onError: handleErrorRef.current,
+      });
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[VideoQueue] Unexpected poll error:", error);
+      }
+    }
+  }, [requestIdRef, modelRef, isPollingRef, pollingRef, consecutiveErrorsRef, pollStartTimeRef, handleCompleteRef, handleErrorRef]);
+}
+
+/**
+ * Hook to sync callback refs
+ */
+export function useCallbackRefs(
+  handleComplete: (urls: import("../../generation-result.utils").GenerationUrls) => Promise<void>,
+  handleError: (errorMsg: string) => Promise<void>,
+  pollStatus: () => Promise<void>,
+  refs: VideoQueueRefs,
+) {
+  useEffect(() => {
+    refs.handleCompleteRef.current = handleComplete;
+  }, [handleComplete, refs]);
+
+  useEffect(() => {
+    refs.handleErrorRef.current = handleError;
+  }, [handleError, refs]);
+
+  useEffect(() => {
+    refs.pollStatusRef.current = pollStatus;
+  }, [pollStatus, refs]);
+}

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationRefs.ts

@@ -0,0 +1,65 @@
+/**
+ * Video Queue Generation Hook - Refs and State Management
+ */
+
+import { useRef, useState } from "react";
+
+export interface VideoQueueRefs {
+  readonly creationIdRef: React.MutableRefObject<string | null>;
+  readonly requestIdRef: React.MutableRefObject<string | null>;
+  readonly modelRef: React.MutableRefObject<string | null>;
+  readonly pollingRef: React.MutableRefObject<ReturnType<typeof setInterval> | null>;
+  readonly isGeneratingRef: React.MutableRefObject<boolean>;
+  readonly isPollingRef: React.MutableRefObject<boolean>;
+  readonly consecutiveErrorsRef: React.MutableRefObject<number>;
+  readonly pollStartTimeRef: React.MutableRefObject<number | null>;
+  readonly handleCompleteRef: React.MutableRefObject<(urls: import("../generation-result.utils").GenerationUrls) => Promise<void>>;
+  readonly handleErrorRef: React.MutableRefObject<(errorMsg: string) => Promise<void>>;
+  readonly pollStatusRef: React.MutableRefObject<() => Promise<void>>;
+}
+
+export interface VideoQueueState {
+  readonly isGenerating: boolean;
+  readonly setIsGenerating: React.Dispatch<React.SetStateAction<boolean>>;
+}
+
+/**
+ * Initialize refs for video queue generation
+ */
+export function useVideoQueueGenerationRefs(): VideoQueueRefs {
+  const creationIdRef = useRef<string | null>(null);
+  const requestIdRef = useRef<string | null>(null);
+  const modelRef = useRef<string | null>(null);
+  const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const isGeneratingRef = useRef(false);
+  const isPollingRef = useRef(false);
+  const consecutiveErrorsRef = useRef(0);
+  const pollStartTimeRef = useRef<number | null>(null);
+
+  // Placeholders for callback refs - will be set by the hook
+  const handleCompleteRef = useRef<VideoQueueRefs["handleCompleteRef"]["current"]>(async () => {});
+  const handleErrorRef = useRef<VideoQueueRefs["handleErrorRef"]["current"]>(async () => {});
+  const pollStatusRef = useRef<VideoQueueRefs["pollStatusRef"]["current"]>(async () => {});
+
+  return {
+    creationIdRef,
+    requestIdRef,
+    modelRef,
+    pollingRef,
+    isGeneratingRef,
+    isPollingRef,
+    consecutiveErrorsRef,
+    pollStartTimeRef,
+    handleCompleteRef,
+    handleErrorRef,
+    pollStatusRef,
+  };
+}
+
+/**
+ * Initialize state for video queue generation
+ */
+export function useVideoQueueGenerationState(): VideoQueueState {
+  const [isGenerating, setIsGenerating] = useState(false);
+  return { isGenerating, setIsGenerating };
+}