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

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

@@ -0,0 +1,119 @@
+/**
+ * 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, creditCost, deductCredits, onSuccess, onError } = props;
+
+  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,75 @@
+/**
+ * Video Queue Generation Hook - Polling Logic
+ */
+
+import { useCallback, useEffect } from "react";
+import { pollQueueStatus } from "../videoQueuePoller";
+import {
+  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 };
+}

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

@@ -0,0 +1,123 @@
+/**
+ * Video Queue Generation Hook - Start Generation Logic
+ */
+
+import { useCallback } from "react";
+import {
+  DEFAULT_POLL_INTERVAL_MS,
+} from "../../../../../../infrastructure/constants/polling.constants";
+import { extractInputMetadata } from "./use-video-queue-utils";
+import type {
+  UseVideoQueueGenerationProps,
+} from "../use-video-queue-generation.types";
+import type { VideoQueueRefs, VideoQueueState } from "./useVideoQueueGenerationRefs";
+
+/**
+ * Create start generation callback
+ */
+export function useStartGeneration(
+  props: UseVideoQueueGenerationProps,
+  refs: VideoQueueRefs,
+  state: VideoQueueState,
+  _clearPolling: () => void,
+): (input: unknown, prompt: string) => Promise<void> {
+  const { userId, scenario, persistence, strategy, creditCost, onError } = props;
+  const { setIsGenerating } = state;
+  const { creationIdRef, requestIdRef, modelRef, pollStartTimeRef, isGeneratingRef, pollingRef, pollStatusRef } = refs;
+
+  return 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 { duration, resolution, aspectRatio } = extractInputMetadata(input);
+
+          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, setIsGenerating, creationIdRef, requestIdRef, modelRef, pollStartTimeRef, isGeneratingRef, pollingRef, pollStatusRef],
+  );
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Video Queue Generation Hook
+ */
+
+export { useVideoQueueGeneration } from "./useVideoQueueGeneration";
+export type {
+  UseVideoQueueGenerationProps,
+  UseVideoQueueGenerationReturn,
+} from "./use-video-queue-generation.types";

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

@@ -1,17 +1,24 @@
 /**
  * Image-to-Video State Types
+ * Refactored to use shared kernel types
  */
 
-export interface ImageToVideoFeatureState {
+import type { BaseFeatureState } from '../../../../shared-kernel/base-types';
+
+/**
+ * Image-to-video feature state
+ * Extends base feature state with image-specific fields
+ */
+export interface ImageToVideoFeatureState extends BaseFeatureState {
   imageUri: string | null;
   motionPrompt: string;
   videoUrl: string | null;
   thumbnailUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
 }
 
+/**
+ * Image-to-video translations
+ */
 export interface ImageToVideoTranslations {
   uploadTitle: string;
   uploadSubtitle: string;

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

@@ -8,18 +8,17 @@ export {
 export interface PromptSuggestion {
   readonly id: string;
   readonly translationKey: string;
-  readonly fallbackText: string;
 }
 
 /** Default text-to-image example prompts */
 export const DEFAULT_TEXT_TO_IMAGE_PROMPTS: readonly PromptSuggestion[] = [
-  { id: "1", translationKey: "prompts.text2image.fantasy", fallbackText: "A mystical forest with glowing mushrooms" },
-  { id: "2", translationKey: "prompts.text2image.portrait", fallbackText: "Professional portrait with studio lighting" },
-  { id: "3", translationKey: "prompts.text2image.landscape", fallbackText: "Sunset over mountains with lake reflection" },
+  { id: "1", translationKey: "prompts.text2image.fantasy" },
+  { id: "2", translationKey: "prompts.text2image.portrait" },
+  { id: "3", translationKey: "prompts.text2image.landscape" },
 ];
 
 /** Default text-to-voice example prompts */
 export const DEFAULT_TEXT_TO_VOICE_PROMPTS: readonly PromptSuggestion[] = [
-  { id: "1", translationKey: "prompts.text2voice.greeting", fallbackText: "Hello, welcome to our application" },
-  { id: "2", translationKey: "prompts.text2voice.story", fallbackText: "Once upon a time in a land far away" },
+  { id: "1", translationKey: "prompts.text2voice.greeting" },
+  { id: "2", translationKey: "prompts.text2voice.story" },
 ];

package/src/domains/text-to-image/domain/types/text-to-image.types.ts

@@ -1,58 +1,79 @@
 /**
  * Text-to-Image Feature Types
- * Request, Result, Config types for text-to-image generation
+ * Refactored to use shared kernel types
  */
 
-export interface TextToImageOptions {
-  aspectRatio?: "16:9" | "9:16" | "1:1";
-  size?: "512x512" | "768x768" | "1024x1024" | "1024x1792" | "1792x1024";
+import type {
+  BaseGenerationOptions,
+  BaseGenerationResult,
+  BaseRequestMeta,
+  BaseFeatureState,
+  BaseGenerationCallbacks,
+} from '../../../../shared-kernel/base-types';
+
+/**
+ * Text-to-image specific options
+ * Extends base options with image-specific fields
+ */
+export interface TextToImageOptions extends BaseGenerationOptions {
+  /** Image size dimensions */
+  size?: '512x512' | '768x768' | '1024x1024' | '1024x1792' | '1792x1024';
+  /** Number of images to generate */
   numImages?: number;
-  guidanceScale?: number;
-  seed?: number;
 }
 
+/**
+ * Text-to-image request
+ * Uses base metadata from shared kernel
+ */
 export interface TextToImageRequest {
   prompt: string;
-  userId: string;
   negativePrompt?: string;
   options?: TextToImageOptions;
+  meta: BaseRequestMeta;
 }
 
-export interface TextToImageResult {
-  success: boolean;
+/**
+ * Text-to-image result
+ * Extends base result with image-specific output
+ */
+export interface TextToImageResult extends BaseGenerationResult<string | string[]> {
   imageUrl?: string;
   imageUrls?: string[];
-  error?: string;
-  requestId?: string;
 }
 
-export interface TextToImageFeatureState {
+/**
+ * Text-to-image feature state
+ * Extends base feature state with prompt field
+ */
+export interface TextToImageFeatureState extends BaseFeatureState<string | string[]> {
   prompt: string;
-  imageUrl: string | null;
-  imageUrls: string[];
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
 }
 
-
+/**
+ * Input builder type
+ */
 export type TextToImageInputBuilder = (
   prompt: string,
   options?: TextToImageOptions,
 ) => Record<string, unknown>;
 
+/**
+ * Result extractor type
+ */
 export type TextToImageResultExtractor = (
   result: unknown,
 ) => { imageUrl?: string; imageUrls?: string[] } | undefined;
 
+/**
+ * Text-to-image feature configuration
+ * Uses shared callbacks
+ */
 export interface TextToImageFeatureConfig {
   providerId?: string;
   creditCost?: number;
   model: string;
   buildInput: TextToImageInputBuilder;
   extractResult?: TextToImageResultExtractor;
-  onPromptChange?: (prompt: string) => void;
-  onProcessingStart?: () => void;
-  onProcessingComplete?: (result: TextToImageResult) => void;
-  onError?: (error: string) => void;
+  callbacks?: BaseGenerationCallbacks<string | string[]>;
 }

package/src/domains/text-to-video/domain/types/request.types.ts

@@ -1,36 +1,59 @@
 /**
  * Text-to-Video Request/Response Types
- * Single Responsibility: Define API request and response structures
+ * Refactored to use shared kernel types
  */
 
-export interface TextToVideoOptions {
+import type {
+  BaseGenerationOptions,
+  BaseGenerationResult,
+  BaseRequestMeta,
+} from '../../../../shared-kernel/base-types';
+
+/**
+ * Text-to-video specific options
+ * Extends base options with video-specific fields
+ */
+export interface TextToVideoOptions extends BaseGenerationOptions {
+  /** Video duration in seconds */
   duration?: number;
+  /** Frames per second */
   fps?: number;
-  guidanceScale?: number;
-  aspectRatio?: "16:9" | "9:16" | "1:1";
+  /** Video style preset */
   style?: string;
+  /** Negative prompt for content avoidance */
   negativePrompt?: string;
 }
 
+/**
+ * Text-to-video request
+ * Uses base metadata from shared kernel
+ */
 export interface TextToVideoRequest {
   prompt: string;
-  userId: string;
   options?: TextToVideoOptions;
+  meta: BaseRequestMeta;
 }
 
-export interface TextToVideoResult {
-  success: boolean;
+/**
+ * Text-to-video result
+ * Extends base result with video-specific output
+ */
+export interface TextToVideoResult extends BaseGenerationResult {
   videoUrl?: string;
   thumbnailUrl?: string;
-  error?: string;
-  requestId?: string;
 }
 
+/**
+ * Input builder type
+ */
 export type TextToVideoInputBuilder = (
   prompt: string,
   options?: TextToVideoOptions,
 ) => Record<string, unknown>;
 
+/**
+ * Result extractor type
+ */
 export type TextToVideoResultExtractor = (
   result: unknown,
 ) => { videoUrl?: string; thumbnailUrl?: string } | undefined;

package/src/domains/text-to-video/domain/types/state.types.ts

@@ -1,17 +1,24 @@
 /**
  * Text-to-Video Feature State Types
- * Single Responsibility: Define internal state structures
+ * Refactored to use shared kernel types
  */
 
-export interface TextToVideoFeatureState {
+import type { BaseFeatureState } from '../../../../shared-kernel/base-types';
+
+/**
+ * Text-to-video feature state
+ * Extends base feature state with video-specific fields
+ */
+export interface TextToVideoFeatureState extends BaseFeatureState {
   prompt: string;
   videoUrl: string | null;
   thumbnailUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
 }
 
+/**
+ * Text-to-video form state
+ * UI-specific state, separate from feature state
+ */
 export interface TextToVideoFormState {
   prompt: string;
   style: string;
@@ -22,32 +29,25 @@ export interface TextToVideoFormState {
   professionalMode: boolean;
 }
 
-export interface TextToVideoGenerationState {
-  isGenerating: boolean;
-  progress: number;
-  contentWarnings: string[];
-  error: string | null;
-}
-
+/**
+ * Frame data structure
+ */
 export interface FrameData {
   id: string;
   url: string;
   order: number;
 }
 
+/**
+ * Initial form state
+ */
 export const INITIAL_FORM_STATE: TextToVideoFormState = {
-  prompt: "",
-  style: "realistic",
-  aspectRatio: "16:9",
+  prompt: '',
+  style: 'realistic',
+  aspectRatio: '16:9',
   duration: 4,
-  activeTab: "text-to-video",
+  activeTab: 'text-to-video',
   soundEnabled: false,
   professionalMode: false,
 };
 
-export const INITIAL_GENERATION_STATE: TextToVideoGenerationState = {
-  isGenerating: false,
-  progress: 0,
-  contentWarnings: [],
-  error: null,
-};