@umituz/react-native-ai-generation-content 1.17.21 → 1.17.23

package/src/features/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -1,20 +1,28 @@
 /**
- * Text-to-Video Feature Hook
- * Provider-agnostic hook for text-to-video generation
+ * useTextToVideoFeature Hook
+ * Single Responsibility: Orchestrate text-to-video generation with callbacks
  */
 
-import { useState, useCallback } from "react";
+import { useState, useCallback, useMemo } from "react";
 import { executeTextToVideo } from "../../infrastructure/services";
 import type {
   TextToVideoFeatureState,
-  TextToVideoFeatureConfig,
+  TextToVideoConfig,
+  TextToVideoCallbacks,
   TextToVideoResult,
   TextToVideoOptions,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
 } from "../../domain/types";
 
+declare const __DEV__: boolean;
+
 export interface UseTextToVideoFeatureProps {
-  config: TextToVideoFeatureConfig;
+  config: TextToVideoConfig;
+  callbacks: TextToVideoCallbacks;
   userId: string;
+  buildInput: TextToVideoInputBuilder;
+  extractResult?: TextToVideoResultExtractor;
 }
 
 export interface UseTextToVideoFeatureReturn {
@@ -23,9 +31,10 @@ export interface UseTextToVideoFeatureReturn {
   generate: (options?: TextToVideoOptions) => Promise<TextToVideoResult>;
   reset: () => void;
   isReady: boolean;
+  canGenerate: boolean;
 }
 
-const initialState: TextToVideoFeatureState = {
+const INITIAL_STATE: TextToVideoFeatureState = {
   prompt: "",
   videoUrl: null,
   thumbnailUrl: null,
@@ -37,25 +46,61 @@ const initialState: TextToVideoFeatureState = {
 export function useTextToVideoFeature(
   props: UseTextToVideoFeatureProps,
 ): UseTextToVideoFeatureReturn {
-  const { config, userId } = props;
-  const [state, setState] = useState<TextToVideoFeatureState>(initialState);
+  const { config, callbacks, userId, buildInput, extractResult } = props;
+  const [state, setState] = useState<TextToVideoFeatureState>(INITIAL_STATE);
 
   const setPrompt = useCallback(
     (prompt: string) => {
       setState((prev) => ({ ...prev, prompt, error: null }));
-      config.onPromptChange?.(prompt);
+      callbacks.onPromptChange?.(prompt);
     },
-    [config],
+    [callbacks],
   );
 
   const generate = useCallback(
     async (options?: TextToVideoOptions): Promise<TextToVideoResult> => {
-      if (!state.prompt) {
+      if (!state.prompt.trim()) {
         const error = "Prompt is required";
         setState((prev) => ({ ...prev, error }));
+        callbacks.onError?.(error);
         return { success: false, error };
       }
 
+      if (callbacks.onAuthCheck && !callbacks.onAuthCheck()) {
+        return { success: false, error: "Authentication required" };
+      }
+
+      if (callbacks.onCreditCheck && !callbacks.onCreditCheck(config.creditCost)) {
+        callbacks.onShowPaywall?.(config.creditCost);
+        return { success: false, error: "Insufficient credits" };
+      }
+
+      if (callbacks.onModeration) {
+        const moderationResult = await callbacks.onModeration(state.prompt);
+        if (!moderationResult.isAllowed && moderationResult.warnings.length > 0) {
+          return new Promise((resolve) => {
+            callbacks.onShowModerationWarning?.(
+              moderationResult.warnings,
+              () => {
+                setState((prev) => ({ ...prev, isProcessing: false }));
+                resolve({ success: false, error: "Content policy violation" });
+              },
+              async () => {
+                const result = await executeGeneration(options);
+                resolve(result);
+              },
+            );
+          });
+        }
+      }
+
+      return executeGeneration(options);
+    },
+    [state.prompt, callbacks, config.creditCost, buildInput, extractResult, userId],
+  );
+
+  const executeGeneration = useCallback(
+    async (options?: TextToVideoOptions): Promise<TextToVideoResult> => {
       setState((prev) => ({
         ...prev,
         isProcessing: true,
@@ -63,16 +108,20 @@ export function useTextToVideoFeature(
         error: null,
       }));
 
-      config.onProcessingStart?.();
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[TextToVideoFeature] Starting generation");
+      }
 
       const result = await executeTextToVideo(
         { prompt: state.prompt, userId, options },
         {
           model: config.model,
-          buildInput: config.buildInput,
-          extractResult: config.extractResult,
+          buildInput,
+          extractResult,
           onProgress: (progress) => {
             setState((prev) => ({ ...prev, progress }));
+            callbacks.onProgress?.(progress);
           },
         },
       );
@@ -85,6 +134,7 @@ export function useTextToVideoFeature(
           isProcessing: false,
           progress: 100,
         }));
+        callbacks.onGenerate?.(result);
       } else {
         const error = result.error || "Generation failed";
         setState((prev) => ({
@@ -92,20 +142,27 @@ export function useTextToVideoFeature(
           isProcessing: false,
           error,
         }));
-        config.onError?.(error);
+        callbacks.onError?.(error);
       }
 
-      config.onProcessingComplete?.(result);
       return result;
     },
-    [state.prompt, userId, config],
+    [state.prompt, userId, config.model, buildInput, extractResult, callbacks],
   );
 
   const reset = useCallback(() => {
-    setState(initialState);
+    setState(INITIAL_STATE);
   }, []);
 
-  const isReady = state.prompt.length > 0 && !state.isProcessing;
+  const isReady = useMemo(
+    () => state.prompt.trim().length > 0 && !state.isProcessing,
+    [state.prompt, state.isProcessing],
+  );
+
+  const canGenerate = useMemo(
+    () => isReady && !state.error,
+    [isReady, state.error],
+  );
 
-  return { state, setPrompt, generate, reset, isReady };
+  return { state, setPrompt, generate, reset, isReady, canGenerate };
 }

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

@@ -0,0 +1,134 @@
+/**
+ * useTextToVideoForm Hook
+ * Single Responsibility: Manage text-to-video form state
+ */
+
+import { useState, useCallback } from "react";
+import type {
+  TextToVideoFormState,
+  FrameData,
+} from "../../domain/types";
+import { INITIAL_FORM_STATE } from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+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: (index: number) => void;
+  handleFrameDelete: (index: number) => void;
+  selectExamplePrompt: (prompt: string) => void;
+  reset: () => void;
+}
+
+export function useTextToVideoForm(
+  props: UseTextToVideoFormProps = {},
+): UseTextToVideoFormReturn {
+  const { initialValues, onPromptChange, onStyleChange, onTabChange } = props;
+
+  const [state, setState] = useState<TextToVideoFormState>({
+    ...INITIAL_FORM_STATE,
+    ...initialValues,
+  });
+
+  const [frames, setFrames] = useState<FrameData[]>([]);
+
+  const setPrompt = useCallback(
+    (prompt: string) => {
+      setState((prev) => ({ ...prev, prompt }));
+      onPromptChange?.(prompt);
+    },
+    [onPromptChange],
+  );
+
+  const setStyle = useCallback(
+    (style: string) => {
+      setState((prev) => ({ ...prev, style }));
+      onStyleChange?.(style);
+    },
+    [onStyleChange],
+  );
+
+  const setAspectRatio = useCallback((aspectRatio: string) => {
+    setState((prev) => ({ ...prev, aspectRatio }));
+  }, []);
+
+  const setDuration = useCallback((duration: number) => {
+    setState((prev) => ({ ...prev, duration }));
+  }, []);
+
+  const setActiveTab = useCallback(
+    (activeTab: string) => {
+      setState((prev) => ({ ...prev, activeTab }));
+      onTabChange?.(activeTab);
+    },
+    [onTabChange],
+  );
+
+  const setSoundEnabled = useCallback((soundEnabled: boolean) => {
+    setState((prev) => ({ ...prev, soundEnabled }));
+  }, []);
+
+  const setProfessionalMode = useCallback((professionalMode: boolean) => {
+    setState((prev) => ({ ...prev, professionalMode }));
+  }, []);
+
+  const handleFrameChange = useCallback((index: number) => {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextToVideoForm] Frame change requested:", index);
+    }
+  }, []);
+
+  const handleFrameDelete = useCallback(
+    (index: number) => {
+      const newFrames = frames.filter((f) => f.order !== index);
+      setFrames(newFrames);
+    },
+    [frames],
+  );
+
+  const selectExamplePrompt = useCallback(
+    (prompt: string) => {
+      setPrompt(prompt);
+    },
+    [setPrompt],
+  );
+
+  const reset = useCallback(() => {
+    setState({ ...INITIAL_FORM_STATE, ...initialValues });
+    setFrames([]);
+  }, [initialValues]);
+
+  return {
+    state,
+    frames,
+    setPrompt,
+    setStyle,
+    setAspectRatio,
+    setDuration,
+    setActiveTab,
+    setSoundEnabled,
+    setProfessionalMode,
+    setFrames,
+    handleFrameChange,
+    handleFrameDelete,
+    selectExamplePrompt,
+    reset,
+  };
+}

package/src/features/text-to-video/presentation/index.ts

@@ -1 +1,7 @@
+/**
+ * Text-to-Video Presentation Layer
+ * Single Responsibility: Export all presentation components and hooks
+ */
+
 export * from "./hooks";
+export * from "./components";

package/src/features/text-to-video/domain/types/text-to-video.types.ts

@@ -1,65 +0,0 @@
-/**
- * Text-to-Video Feature Types
- * Request, Result, Config types for text-to-video generation
- */
-
-export interface TextToVideoOptions {
-  duration?: number;
-  fps?: number;
-  guidanceScale?: number;
-  aspectRatio?: "16:9" | "9:16" | "1:1";
-}
-
-export interface TextToVideoRequest {
-  prompt: string;
-  userId: string;
-  negativePrompt?: string;
-  options?: TextToVideoOptions;
-}
-
-export interface TextToVideoResult {
-  success: boolean;
-  videoUrl?: string;
-  thumbnailUrl?: string;
-  error?: string;
-  requestId?: string;
-}
-
-export interface TextToVideoFeatureState {
-  prompt: string;
-  videoUrl: string | null;
-  thumbnailUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
-}
-
-export interface TextToVideoTranslations {
-  promptPlaceholder: string;
-  generateButtonText: string;
-  processingText: string;
-  successText: string;
-  saveButtonText: string;
-  tryAnotherText: string;
-}
-
-export type TextToVideoInputBuilder = (
-  prompt: string,
-  options?: TextToVideoOptions,
-) => Record<string, unknown>;
-
-export type TextToVideoResultExtractor = (
-  result: unknown,
-) => { videoUrl?: string; thumbnailUrl?: string } | undefined;
-
-export interface TextToVideoFeatureConfig {
-  providerId?: string;
-  creditCost?: number;
-  model: string;
-  buildInput: TextToVideoInputBuilder;
-  extractResult?: TextToVideoResultExtractor;
-  onPromptChange?: (prompt: string) => void;
-  onProcessingStart?: () => void;
-  onProcessingComplete?: (result: TextToVideoResult) => void;
-  onError?: (error: string) => void;
-}