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

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/types/text-to-image.types.ts

@@ -1,58 +1,80 @@
 /**
  * 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 {
+  AspectRatio,
+  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,60 @@
 /**
  * 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 {
+  AspectRatio,
+  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,6 +29,10 @@ export interface TextToVideoFormState {
   professionalMode: boolean;
 }
 
+/**
+ * Text-to-video generation state
+ * Legacy state for backward compatibility
+ */
 export interface TextToVideoGenerationState {
   isGenerating: boolean;
   progress: number;
@@ -29,22 +40,31 @@ export interface TextToVideoGenerationState {
   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,
 };
 
+/**
+ * Initial generation state
+ */
 export const INITIAL_GENERATION_STATE: TextToVideoGenerationState = {
   isGenerating: false,
   progress: 0,

package/src/domains/text-to-video/presentation/hooks/useTextToVideoForm.handlers.ts

@@ -0,0 +1,44 @@
+/**
+ * useTextToVideoForm Hook - Handlers
+ * Frame manipulation handlers for text-to-video form
+ */
+
+import type { FrameData } from "../../domain/types";
+
+export function createFrameChangeHandler(
+  setFrames: React.Dispatch<React.SetStateAction<FrameData[]>>,
+  framesLength: number,
+) {
+  return (fromIndex: number, toIndex: number) => {
+    if (fromIndex < 0 || fromIndex >= framesLength || toIndex < 0 || toIndex >= framesLength) {
+      if (__DEV__) {
+        console.warn("[TextToVideoForm] Invalid frame indices:", { fromIndex, toIndex, length: framesLength });
+      }
+      return;
+    }
+
+    if (fromIndex === toIndex) return;
+
+    setFrames((prevFrames) => {
+      const newFrames = [...prevFrames];
+      const [movedFrame] = newFrames.splice(fromIndex, 1);
+      newFrames.splice(toIndex, 0, movedFrame);
+      return newFrames;
+    });
+  };
+}
+
+export function createFrameDeleteHandler(
+  setFrames: React.Dispatch<React.SetStateAction<FrameData[]>>,
+  framesLength: number,
+) {
+  return (index: number) => {
+    if (index < 0 || index >= framesLength) {
+      if (__DEV__) {
+        console.warn("[TextToVideoForm] Invalid frame index:", index);
+      }
+      return;
+    }
+    setFrames((prevFrames) => prevFrames.filter((_, i) => i !== index));
+  };
+}

package/src/domains/text-to-video/presentation/hooks/useTextToVideoForm.ts

@@ -9,31 +9,8 @@ import type {
   FrameData,
 } from "../../domain/types";
 import { INITIAL_FORM_STATE } from "../../domain/types";
-
-
-export interface UseTextToVideoFormProps {
-  initialValues?: Partial<TextToVideoFormState>;
-  onPromptChange?: (prompt: string) => void;
-  onStyleChange?: (style: string) => void;
-  onTabChange?: (tab: string) => void;
-}
-
-export interface UseTextToVideoFormReturn {
-  state: TextToVideoFormState;
-  frames: FrameData[];
-  setPrompt: (prompt: string) => void;
-  setStyle: (style: string) => void;
-  setAspectRatio: (ratio: string) => void;
-  setDuration: (duration: number) => void;
-  setActiveTab: (tab: string) => void;
-  setSoundEnabled: (enabled: boolean) => void;
-  setProfessionalMode: (enabled: boolean) => void;
-  setFrames: (frames: FrameData[]) => void;
-  handleFrameChange: (fromIndex: number, toIndex: number) => void;
-  handleFrameDelete: (index: number) => void;
-  selectExamplePrompt: (prompt: string) => void;
-  reset: () => void;
-}
+import type { UseTextToVideoFormProps, UseTextToVideoFormReturn } from "./useTextToVideoForm.types";
+import { createFrameChangeHandler, createFrameDeleteHandler } from "./useTextToVideoForm.handlers";
 
 export function useTextToVideoForm(
   props: UseTextToVideoFormProps = {},
@@ -88,36 +65,12 @@ export function useTextToVideoForm(
   }, []);
 
   const handleFrameChange = useCallback(
-    (fromIndex: number, toIndex: number) => {
-      if (fromIndex < 0 || fromIndex >= frames.length || toIndex < 0 || toIndex >= frames.length) {
-        if (__DEV__) {
-          console.warn("[TextToVideoForm] Invalid frame indices:", { fromIndex, toIndex, length: frames.length });
-        }
-        return;
-      }
-
-      if (fromIndex === toIndex) return;
-
-      setFrames((prevFrames) => {
-        const newFrames = [...prevFrames];
-        const [movedFrame] = newFrames.splice(fromIndex, 1);
-        newFrames.splice(toIndex, 0, movedFrame);
-        return newFrames;
-      });
-    },
+    createFrameChangeHandler(setFrames, frames.length),
     [frames.length],
   );
 
   const handleFrameDelete = useCallback(
-    (index: number) => {
-      if (index < 0 || index >= frames.length) {
-        if (__DEV__) {
-          console.warn("[TextToVideoForm] Invalid frame index:", index);
-        }
-        return;
-      }
-      setFrames((prevFrames) => prevFrames.filter((_, i) => i !== index));
-    },
+    createFrameDeleteHandler(setFrames, frames.length),
     [frames.length],
   );
 
@@ -150,3 +103,4 @@ export function useTextToVideoForm(
     reset,
   };
 }
+

package/src/domains/text-to-video/presentation/hooks/useTextToVideoForm.types.ts

@@ -0,0 +1,33 @@
+/**
+ * useTextToVideoForm Hook - Types
+ * Type definitions for text-to-video form
+ */
+
+import type {
+  TextToVideoFormState,
+  FrameData,
+} from "../../domain/types";
+
+export interface UseTextToVideoFormProps {
+  initialValues?: Partial<TextToVideoFormState>;
+  onPromptChange?: (prompt: string) => void;
+  onStyleChange?: (style: string) => void;
+  onTabChange?: (tab: string) => void;
+}
+
+export interface UseTextToVideoFormReturn {
+  state: TextToVideoFormState;
+  frames: FrameData[];
+  setPrompt: (prompt: string) => void;
+  setStyle: (style: string) => void;
+  setAspectRatio: (ratio: string) => void;
+  setDuration: (duration: number) => void;
+  setActiveTab: (tab: string) => void;
+  setSoundEnabled: (enabled: boolean) => void;
+  setProfessionalMode: (enabled: boolean) => void;
+  setFrames: (frames: FrameData[]) => void;
+  handleFrameChange: (fromIndex: number, toIndex: number) => void;
+  handleFrameDelete: (index: number) => void;
+  selectExamplePrompt: (prompt: string) => void;
+  reset: () => void;
+}

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -10,9 +10,9 @@ import type {
   PollingConfig,
 } from "../../domain/entities";
 import { classifyError } from "../utils/error-classification";
-import { pollJob } from "../../domains/background/infrastructure/services/job-poller.service";
+import { pollJob } from "../../domains/background/infrastructure/services/job-poller-index";
 import { ProviderValidator } from "./provider-validator";
-import { calculateDurationMs } from "../../shared/utils/calculations.util";
+import { calculateDurationMs } from "../../shared/utils/calculations";
 
 
 export interface OrchestratorConfig {

package/src/infrastructure/utils/couple-input-context.ts

@@ -0,0 +1,13 @@
+/**
+ * Couple Input Utilities - Context Management
+ */
+
+/**
+ * Prepends optional context (e.g. appearance analysis) to a base prompt.
+ */
+export function prependContext(
+  basePrompt: string,
+  context: string | undefined | null,
+): string {
+  return context ? `${context}\n\n${basePrompt}` : basePrompt;
+}

package/src/infrastructure/utils/couple-input-index.ts

@@ -0,0 +1,8 @@
+/**
+ * Couple Input Utilities - Index
+ */
+
+export { resolveCoupleInput } from "./couple-input-resolver";
+export { prependContext } from "./couple-input-context";
+export { refinePromptForCouple } from "./couple-input-refiner";
+export type { GenerationTargetLike } from "./couple-input-types";