@umituz/react-native-ai-generation-content 1.26.2 → 1.26.4

package/src/features/image-to-video/presentation/hooks/useFormState.ts

@@ -1,116 +0,0 @@
-/**
- * Form State Hook for Image-to-Video
- * Manages form state with actions
- */
-
-import { useState, useCallback, useMemo } from "react";
-import type {
-  ImageToVideoFormState,
-  ImageToVideoFormActions,
-  ImageToVideoFormDefaults,
-  AnimationStyleId,
-  MusicMoodId,
-  VideoDuration,
-} from "../../domain/types";
-import {
-  DEFAULT_ANIMATION_STYLE_ID,
-  DEFAULT_MUSIC_MOOD_ID,
-  DEFAULT_VIDEO_DURATION,
-} from "../../domain/constants";
-
-export interface UseFormStateOptions {
-  defaults?: ImageToVideoFormDefaults;
-}
-
-export interface UseFormStateReturn {
-  state: ImageToVideoFormState;
-  actions: ImageToVideoFormActions;
-}
-
-function createInitialState(defaults?: ImageToVideoFormDefaults): ImageToVideoFormState {
-  return {
-    selectedImages: [],
-    animationStyle: defaults?.animationStyle ?? DEFAULT_ANIMATION_STYLE_ID,
-    duration: defaults?.duration ?? DEFAULT_VIDEO_DURATION,
-    musicMood: defaults?.musicMood ?? DEFAULT_MUSIC_MOOD_ID,
-    customAudioUri: null,
-    motionPrompt: "",
-  };
-}
-
-export function useFormState(options?: UseFormStateOptions): UseFormStateReturn {
-  const { defaults } = options ?? {};
-
-  const [state, setState] = useState<ImageToVideoFormState>(() =>
-    createInitialState(defaults)
-  );
-
-  const setSelectedImages = useCallback((images: string[]) => {
-    setState((prev) => ({ ...prev, selectedImages: images }));
-  }, []);
-
-  const addImages = useCallback((images: string[]) => {
-    setState((prev) => ({
-      ...prev,
-      selectedImages: [...prev.selectedImages, ...images],
-    }));
-  }, []);
-
-  const removeImage = useCallback((index: number) => {
-    setState((prev) => ({
-      ...prev,
-      selectedImages: prev.selectedImages.filter((_, i) => i !== index),
-    }));
-  }, []);
-
-  const setAnimationStyle = useCallback((style: AnimationStyleId) => {
-    setState((prev) => ({ ...prev, animationStyle: style }));
-  }, []);
-
-  const setDuration = useCallback((duration: VideoDuration) => {
-    setState((prev) => ({ ...prev, duration }));
-  }, []);
-
-  const setMusicMood = useCallback((mood: MusicMoodId) => {
-    setState((prev) => ({ ...prev, musicMood: mood }));
-  }, []);
-
-  const setCustomAudioUri = useCallback((uri: string | null) => {
-    setState((prev) => ({ ...prev, customAudioUri: uri }));
-  }, []);
-
-  const setMotionPrompt = useCallback((prompt: string) => {
-    setState((prev) => ({ ...prev, motionPrompt: prompt }));
-  }, []);
-
-  const reset = useCallback(() => {
-    setState(createInitialState(defaults));
-  }, [defaults]);
-
-  const actions = useMemo<ImageToVideoFormActions>(
-    () => ({
-      setSelectedImages,
-      addImages,
-      removeImage,
-      setAnimationStyle,
-      setDuration,
-      setMusicMood,
-      setCustomAudioUri,
-      setMotionPrompt,
-      reset,
-    }),
-    [
-      setSelectedImages,
-      addImages,
-      removeImage,
-      setAnimationStyle,
-      setDuration,
-      setMusicMood,
-      setCustomAudioUri,
-      setMotionPrompt,
-      reset,
-    ]
-  );
-
-  return { state, actions };
-}

package/src/features/image-to-video/presentation/hooks/useGeneration.ts

@@ -1,85 +0,0 @@
-/**
- * Generation Hook for Image-to-Video
- * Manages generation state and execution
- */
-
-import { useState, useCallback, useMemo } from "react";
-import type {
-  ImageToVideoFormState,
-  ImageToVideoGenerationState,
-  ImageToVideoCallbacks,
-} from "../../domain/types";
-
-export interface UseGenerationOptions {
-  formState: ImageToVideoFormState;
-  callbacks: ImageToVideoCallbacks;
-}
-
-export interface UseGenerationReturn {
-  generationState: ImageToVideoGenerationState;
-  handleGenerate: () => Promise<void>;
-  setProgress: (progress: number) => void;
-  setError: (error: string | null) => void;
-  isReady: boolean;
-}
-
-const INITIAL_GENERATION_STATE: ImageToVideoGenerationState = {
-  isGenerating: false,
-  progress: 0,
-  error: null,
-};
-
-export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
-  const { formState, callbacks } = options;
-
-  const [generationState, setGenerationState] = useState<ImageToVideoGenerationState>(
-    INITIAL_GENERATION_STATE
-  );
-
-  const setProgress = useCallback((progress: number) => {
-    setGenerationState((prev) => ({ ...prev, progress }));
-  }, []);
-
-  const setError = useCallback((error: string | null) => {
-    setGenerationState((prev) => ({ ...prev, error, isGenerating: false }));
-  }, []);
-
-  const handleGenerate = useCallback(async () => {
-    if (formState.selectedImages.length === 0) {
-      callbacks.onError?.("No images selected");
-      return;
-    }
-
-    setGenerationState({
-      isGenerating: true,
-      progress: 0,
-      error: null,
-    });
-
-    try {
-      await callbacks.onGenerate(formState);
-      setGenerationState((prev) => ({ ...prev, isGenerating: false, progress: 100 }));
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      setGenerationState({
-        isGenerating: false,
-        progress: 0,
-        error: errorMessage,
-      });
-      callbacks.onError?.(errorMessage);
-    }
-  }, [formState, callbacks]);
-
-  const isReady = useMemo(
-    () => formState.selectedImages.length > 0 && !generationState.isGenerating,
-    [formState.selectedImages.length, generationState.isGenerating]
-  );
-
-  return {
-    generationState,
-    handleGenerate,
-    setProgress,
-    setError,
-    isReady,
-  };
-}

package/src/features/image-to-video/presentation/hooks/useGenerationExecution.ts

@@ -1,143 +0,0 @@
-/**
- * useGenerationExecution Hook
- * Handles the core generation execution logic for image-to-video
- */
-
-import { useCallback } from "react";
-import { executeImageToVideo } from "../../infrastructure/services";
-import type {
-  ImageToVideoFeatureConfig,
-  ImageToVideoFeatureCallbacks,
-  ImageToVideoResult,
-  ImageToVideoGenerateParams,
-  ImageToVideoFeatureState,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-interface UseGenerationExecutionParams {
-  userId: string;
-  config: ImageToVideoFeatureConfig;
-  callbacks?: ImageToVideoFeatureCallbacks;
-  setState: React.Dispatch<React.SetStateAction<ImageToVideoFeatureState>>;
-}
-
-export function useGenerationExecution({
-  userId,
-  config,
-  callbacks,
-  setState,
-}: UseGenerationExecutionParams) {
-  return useCallback(
-    async (
-      imageUri: string,
-      motionPrompt: string,
-      options?: Omit<ImageToVideoGenerateParams, "imageUri" | "motionPrompt">,
-    ): Promise<ImageToVideoResult> => {
-      const creationId = `image-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-
-      setState((prev) => ({
-        ...prev,
-        imageUri,
-        isProcessing: true,
-        progress: 0,
-        error: null,
-      }));
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] Starting generation, creationId:", creationId);
-      }
-
-      config.onProcessingStart?.();
-
-      if (callbacks?.onGenerationStart) {
-        callbacks.onGenerationStart({
-          creationId,
-          type: "image-to-video",
-          imageUri,
-          metadata: options as Record<string, unknown> | undefined,
-        }).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[ImageToVideoFeature] onGenerationStart failed:", err);
-          }
-        });
-      }
-
-      try {
-        const imageBase64 = await config.prepareImage(imageUri);
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[ImageToVideoFeature] Image prepared, calling executeImageToVideo");
-        }
-
-        const result = await executeImageToVideo(
-          {
-            imageUri,
-            imageBase64,
-            userId,
-            motionPrompt: motionPrompt || undefined,
-            options,
-          },
-          {
-            model: config.model,
-            buildInput: config.buildInput,
-            extractResult: config.extractResult,
-            onProgress: (progress) => {
-              setState((prev) => ({ ...prev, progress }));
-              callbacks?.onProgress?.(progress);
-            },
-          },
-        );
-
-        if (result.success && result.videoUrl) {
-          setState((prev) => ({
-            ...prev,
-            videoUrl: result.videoUrl ?? null,
-            thumbnailUrl: result.thumbnailUrl ?? null,
-            isProcessing: false,
-            progress: 100,
-          }));
-
-          if (callbacks?.onCreditDeduct && config.creditCost) {
-            await callbacks.onCreditDeduct(config.creditCost);
-          }
-
-          if (callbacks?.onCreationSave) {
-            await callbacks.onCreationSave({
-              creationId,
-              type: "image-to-video",
-              videoUrl: result.videoUrl,
-              thumbnailUrl: result.thumbnailUrl,
-              imageUri,
-              metadata: options as Record<string, unknown> | undefined,
-            });
-          }
-
-          callbacks?.onGenerate?.(result);
-        } else {
-          const error = result.error || "Generation failed";
-          setState((prev) => ({ ...prev, isProcessing: false, error }));
-          config.onError?.(error);
-          callbacks?.onError?.(error);
-        }
-
-        config.onProcessingComplete?.(result);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ImageToVideoFeature] Generation error:", errorMessage);
-        }
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          error: errorMessage,
-        }));
-        config.onError?.(errorMessage);
-        callbacks?.onError?.(errorMessage);
-        return { success: false, error: errorMessage };
-      }
-    },
-    [userId, config, callbacks],
-  );
-}

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

@@ -1,107 +0,0 @@
-/**
- * Image-to-Video Feature Hook
- * Provider-agnostic hook with callbacks integration
- */
-
-import { useState, useCallback, useMemo } from "react";
-import { useGenerationExecution } from "./useGenerationExecution";
-import { validateImageToVideoGeneration } from "./useImageToVideoValidation";
-import type {
-  ImageToVideoFeatureState,
-  ImageToVideoFeatureConfig,
-  ImageToVideoResult,
-  ImageToVideoFeatureCallbacks,
-  ImageToVideoGenerateParams,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-// Initial state (inlined from constants file)
-const INITIAL_STATE: ImageToVideoFeatureState = {
-  imageUri: null,
-  motionPrompt: "",
-  videoUrl: null,
-  thumbnailUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-// Types (inlined from types file)
-export interface UseImageToVideoFeatureProps {
-  config: ImageToVideoFeatureConfig;
-  callbacks?: ImageToVideoFeatureCallbacks;
-  userId: string;
-}
-
-export interface UseImageToVideoFeatureReturn {
-  state: ImageToVideoFeatureState;
-  setImageUri: (uri: string) => void;
-  setMotionPrompt: (prompt: string) => void;
-  generate: (params?: ImageToVideoGenerateParams) => Promise<ImageToVideoResult>;
-  reset: () => void;
-  isReady: boolean;
-  canGenerate: boolean;
-}
-
-export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
-  const { config, callbacks, userId } = props;
-  const [state, setState] = useState<ImageToVideoFeatureState>(INITIAL_STATE);
-
-  const executeGeneration = useGenerationExecution({
-    userId,
-    config,
-    callbacks,
-    setState,
-  });
-
-  const setImageUri = useCallback(
-    (uri: string) => {
-      setState((prev) => ({ ...prev, imageUri: uri, error: null }));
-      config.onImageSelect?.(uri);
-    },
-    [config],
-  );
-
-  const setMotionPrompt = useCallback((prompt: string) => {
-    setState((prev) => ({ ...prev, motionPrompt: prompt }));
-  }, []);
-
-  const generate = useCallback(
-    async (params?: ImageToVideoGenerateParams): Promise<ImageToVideoResult> => {
-      const { imageUri: paramImageUri, motionPrompt: paramMotionPrompt, ...options } = params || {};
-      const effectiveImageUri = paramImageUri || state.imageUri;
-      const effectiveMotionPrompt = paramMotionPrompt ?? state.motionPrompt;
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] generate called, hasImage:", !!effectiveImageUri);
-      }
-
-      if (paramImageUri) {
-        setState((prev) => ({ ...prev, imageUri: paramImageUri }));
-      }
-
-      const validation = await validateImageToVideoGeneration(
-        effectiveImageUri,
-        callbacks,
-        config.creditCost,
-      );
-
-      if (!validation.shouldProceed) {
-        return validation;
-      }
-
-      return executeGeneration(effectiveImageUri!, effectiveMotionPrompt, options);
-    },
-    [state.imageUri, state.motionPrompt, callbacks, config.creditCost, executeGeneration],
-  );
-
-  const reset = useCallback(() => {
-    setState(INITIAL_STATE);
-  }, []);
-
-  const isReady = useMemo(() => state.imageUri !== null && !state.isProcessing, [state.imageUri, state.isProcessing]);
-  const canGenerate = useMemo(() => isReady && !state.error, [isReady, state.error]);
-
-  return { state, setImageUri, setMotionPrompt, generate, reset, isReady, canGenerate };
-}

package/src/features/image-to-video/presentation/hooks/useImageToVideoForm.ts

@@ -1,119 +0,0 @@
-/**
- * Image-to-Video Form Hook
- * Composes form state and generation for complete form management
- */
-
-import { useMemo, useCallback } from "react";
-
-declare const __DEV__: boolean;
-import { useFormState, type UseFormStateOptions } from "./useFormState";
-import { useGeneration } from "./useGeneration";
-import type {
-  ImageToVideoFormState,
-  ImageToVideoFormActions,
-  ImageToVideoGenerationState,
-  ImageToVideoCallbacks,
-  MusicMoodId,
-} from "../../domain/types";
-
-export interface UseImageToVideoFormOptions extends UseFormStateOptions {
-  callbacks: ImageToVideoCallbacks;
-}
-
-export interface UseImageToVideoFormReturn {
-  state: ImageToVideoFormState;
-  actions: ImageToVideoFormActions;
-  generationState: ImageToVideoGenerationState;
-  handleGenerate: () => Promise<void>;
-  handleMusicSelect: (moodId: MusicMoodId) => void;
-  handleSelectImages: () => Promise<void>;
-  isReady: boolean;
-}
-
-export function useImageToVideoForm(
-  options: UseImageToVideoFormOptions
-): UseImageToVideoFormReturn {
-  const { callbacks, defaults } = options;
-
-  const { state, actions } = useFormState({ defaults });
-
-  const { generationState, handleGenerate, isReady } = useGeneration({
-    formState: state,
-    callbacks,
-  });
-
-  const handleMusicSelect = useCallback(
-    (moodId: MusicMoodId) => {
-      if (moodId === "custom" && callbacks.onSelectCustomAudio) {
-        callbacks.onSelectCustomAudio().then((uri) => {
-          if (uri) {
-            actions.setCustomAudioUri(uri);
-            actions.setMusicMood("custom");
-          }
-        });
-      } else {
-        actions.setMusicMood(moodId);
-        if (moodId !== "custom") {
-          actions.setCustomAudioUri(null);
-        }
-      }
-    },
-    [callbacks, actions]
-  );
-
-  const handleSelectImages = useCallback(async () => {
-    if (__DEV__) {
-       
-      console.log("[useImageToVideoForm] handleSelectImages called");
-    }
-    if (callbacks.onSelectImages) {
-      try {
-        const images = await callbacks.onSelectImages();
-        if (__DEV__) {
-           
-          console.log("[useImageToVideoForm] Images selected:", images.length);
-        }
-        if (images.length > 0) {
-          actions.addImages(images);
-          if (__DEV__) {
-             
-            console.log("[useImageToVideoForm] Images added to state");
-          }
-        }
-      } catch (error) {
-        if (__DEV__) {
-           
-          console.error("[useImageToVideoForm] Error selecting images:", error);
-        }
-      }
-    } else {
-      if (__DEV__) {
-         
-        console.warn("[useImageToVideoForm] No onSelectImages callback provided");
-      }
-    }
-  }, [callbacks, actions]);
-
-  const formReturn = useMemo<UseImageToVideoFormReturn>(
-    () => ({
-      state,
-      actions,
-      generationState,
-      handleGenerate,
-      handleMusicSelect,
-      handleSelectImages,
-      isReady,
-    }),
-    [
-      state,
-      actions,
-      generationState,
-      handleGenerate,
-      handleMusicSelect,
-      handleSelectImages,
-      isReady,
-    ]
-  );
-
-  return formReturn;
-}

package/src/features/image-to-video/presentation/hooks/useImageToVideoValidation.ts

@@ -1,46 +0,0 @@
-/**
- * Image-to-Video Validation Utilities
- */
-
-import type { ImageToVideoFeatureCallbacks, ImageToVideoResult } from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface ValidationResult extends ImageToVideoResult {
-  shouldProceed: boolean;
-}
-
-export async function validateImageToVideoGeneration(
-  effectiveImageUri: string | null,
-  callbacks?: ImageToVideoFeatureCallbacks,
-  creditCost?: number,
-): Promise<ValidationResult> {
-  if (!effectiveImageUri) {
-    const error = "Image is required";
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageToVideoFeature] Generate failed: Image is required");
-    }
-    callbacks?.onError?.(error);
-    return { success: false, error, shouldProceed: false };
-  }
-
-  if (callbacks?.onAuthCheck && !callbacks.onAuthCheck()) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageToVideoFeature] Generate failed: Authentication required");
-    }
-    return { success: false, error: "Authentication required", shouldProceed: false };
-  }
-
-  if (callbacks?.onCreditCheck && creditCost) {
-    const hasCredits = await callbacks.onCreditCheck(creditCost);
-    if (!hasCredits) {
-      callbacks?.onShowPaywall?.(creditCost);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] Generate failed: Insufficient credits");
-      }
-      return { success: false, error: "Insufficient credits", shouldProceed: false };
-    }
-  }
-
-  return { success: true, shouldProceed: true };
-}

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

@@ -1,5 +0,0 @@
-// Hooks
-export * from "./hooks";
-
-// Components
-export * from "./components";