@umituz/react-native-ai-generation-content 1.17.138 → 1.17.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.138",
+  "version": "1.17.140",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/features/ai-hug/presentation/components/AIHugFeature.tsx

@@ -121,7 +121,6 @@ export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
               sourcePlaceholder={translations.sourceUploadTitle}
               targetPlaceholder={translations.targetUploadTitle}
               layout="horizontal"
-              variant="portrait"
             />
           </View>
         </AIGenerationForm>

package/src/features/ai-kiss/presentation/components/AIKissFeature.tsx

@@ -115,7 +115,6 @@ export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
               sourcePlaceholder={translations.sourceUploadTitle}
               targetPlaceholder={translations.targetUploadTitle}
               layout="horizontal"
-              variant="portrait"
             />
           </View>
         </AIGenerationForm>

package/src/features/face-swap/presentation/components/FaceSwapFeature.tsx

@@ -118,7 +118,6 @@ export const FaceSwapFeature: React.FC<FaceSwapFeatureProps> = ({
               sourcePlaceholder={translations.sourceUploadTitle}
               targetPlaceholder={translations.targetUploadTitle}
               layout="horizontal"
-              variant="portrait"
             />
           </View>
         </AIGenerationForm>

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

@@ -16,6 +16,11 @@ export interface ImageToVideoOptions {
   musicMood?: MusicMoodId;
 }
 
+export interface ImageToVideoGenerateParams extends ImageToVideoOptions {
+  imageUri?: string;
+  motionPrompt?: string;
+}
+
 export interface ImageToVideoRequest {
   imageUri: string;
   imageBase64?: string;
@@ -75,6 +80,34 @@ export type ImageToVideoResultExtractor = (
   result: unknown,
 ) => { videoUrl?: string; thumbnailUrl?: string } | undefined;
 
+export interface ImageToVideoFeatureCallbacks {
+  onCreditCheck?: (cost: number) => Promise<boolean>;
+  onCreditDeduct?: (cost: number) => Promise<void>;
+  onAuthCheck?: () => boolean;
+  onShowPaywall?: (creditCost: number) => void;
+  onGenerationStart?: (data: ImageToVideoGenerationStartData) => Promise<void>;
+  onCreationSave?: (data: ImageToVideoCreationData) => Promise<void>;
+  onGenerate?: (result: ImageToVideoResult) => void;
+  onProgress?: (progress: number) => void;
+  onError?: (error: string) => void;
+}
+
+export interface ImageToVideoGenerationStartData {
+  creationId: string;
+  type: string;
+  imageUri: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ImageToVideoCreationData {
+  creationId: string;
+  type: string;
+  videoUrl: string;
+  thumbnailUrl?: string;
+  imageUri: string;
+  metadata?: Record<string, unknown>;
+}
+
 export interface ImageToVideoFeatureConfig {
   providerId?: string;
   creditCost?: number;

package/src/features/image-to-video/domain/types/index.ts

@@ -24,6 +24,7 @@ export type {
 // Core Feature Types
 export type {
   ImageToVideoOptions,
+  ImageToVideoGenerateParams,
   ImageToVideoRequest,
   ImageToVideoResult,
   ImageToVideoGenerationState,
@@ -31,5 +32,8 @@ export type {
   ImageToVideoTranslations,
   ImageToVideoInputBuilder,
   ImageToVideoResultExtractor,
+  ImageToVideoFeatureCallbacks,
+  ImageToVideoGenerationStartData,
+  ImageToVideoCreationData,
   ImageToVideoFeatureConfig,
 } from "./image-to-video.types";

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

@@ -33,6 +33,7 @@ export type {
 // Core Feature Types
 export type {
   ImageToVideoOptions,
+  ImageToVideoGenerateParams,
   ImageToVideoRequest,
   ImageToVideoResult,
   ImageToVideoGenerationState,
@@ -40,6 +41,9 @@ export type {
   ImageToVideoTranslations,
   ImageToVideoInputBuilder,
   ImageToVideoResultExtractor,
+  ImageToVideoFeatureCallbacks,
+  ImageToVideoGenerationStartData,
+  ImageToVideoCreationData,
   ImageToVideoFeatureConfig,
 } from "./domain";
 

package/src/features/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -78,9 +78,21 @@ export async function executeImageToVideo(
     onProgress?.(30);
 
     const input = buildInput(imageBase64, request.motionPrompt, request.options);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ImageToVideo] Input keys:", Object.keys(input));
+    }
+
     onProgress?.(40);
 
     const result = await provider.run(model, input);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ImageToVideo] Result received:", JSON.stringify(result, null, 2).slice(0, 500));
+    }
+
     onProgress?.(90);
 
     const extractor = extractResult || defaultExtractResult;
@@ -88,6 +100,10 @@ export async function executeImageToVideo(
     onProgress?.(100);
 
     if (!extracted?.videoUrl) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[ImageToVideo] No video URL in extracted result:", extracted);
+      }
       return { success: false, error: "No video in response" };
     }
 
@@ -98,11 +114,14 @@ export async function executeImageToVideo(
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    const fullError = error instanceof Error ? error.stack : JSON.stringify(error);
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
-      console.error("[ImageToVideo] Error:", message);
+      console.error("[ImageToVideo] Execution error:", message);
+      // eslint-disable-next-line no-console
+      console.error("[ImageToVideo] Full error:", fullError);
     }
-    return { success: false, error: message };
+    return { success: false, error: message || "Generation failed" };
   }
 }
 

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

@@ -1,19 +1,23 @@
 /**
  * Image-to-Video Feature Hook
- * Provider-agnostic hook for image-to-video generation
+ * Provider-agnostic hook with callbacks integration
  */
 
-import { useState, useCallback } from "react";
+import { useState, useCallback, useMemo } from "react";
 import { executeImageToVideo } from "../../infrastructure/services";
 import type {
   ImageToVideoFeatureState,
   ImageToVideoFeatureConfig,
   ImageToVideoResult,
-  ImageToVideoOptions,
+  ImageToVideoFeatureCallbacks,
+  ImageToVideoGenerateParams,
 } from "../../domain/types";
 
+declare const __DEV__: boolean;
+
 export interface UseImageToVideoFeatureProps {
   config: ImageToVideoFeatureConfig;
+  callbacks?: ImageToVideoFeatureCallbacks;
   userId: string;
 }
 
@@ -21,12 +25,13 @@ export interface UseImageToVideoFeatureReturn {
   state: ImageToVideoFeatureState;
   setImageUri: (uri: string) => void;
   setMotionPrompt: (prompt: string) => void;
-  generate: (options?: ImageToVideoOptions) => Promise<ImageToVideoResult>;
+  generate: (params?: ImageToVideoGenerateParams) => Promise<ImageToVideoResult>;
   reset: () => void;
   isReady: boolean;
+  canGenerate: boolean;
 }
 
-const initialState: ImageToVideoFeatureState = {
+const INITIAL_STATE: ImageToVideoFeatureState = {
   imageUri: null,
   motionPrompt: "",
   videoUrl: null,
@@ -39,8 +44,8 @@ const initialState: ImageToVideoFeatureState = {
 export function useImageToVideoFeature(
   props: UseImageToVideoFeatureProps,
 ): UseImageToVideoFeatureReturn {
-  const { config, userId } = props;
-  const [state, setState] = useState<ImageToVideoFeatureState>(initialState);
+  const { config, callbacks, userId } = props;
+  const [state, setState] = useState<ImageToVideoFeatureState>(INITIAL_STATE);
 
   const setImageUri = useCallback(
     (uri: string) => {
@@ -54,68 +59,191 @@ export function useImageToVideoFeature(
     setState((prev) => ({ ...prev, motionPrompt: prompt }));
   }, []);
 
-  const generate = useCallback(
-    async (options?: ImageToVideoOptions): Promise<ImageToVideoResult> => {
-      if (!state.imageUri) {
-        const error = "Image is required";
-        setState((prev) => ({ ...prev, error }));
-        return { success: false, error };
-      }
+  const executeGeneration = 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__) {
+        // eslint-disable-next-line no-console
+        console.log("[ImageToVideoFeature] Starting generation:", { imageUri, creationId });
+      }
+
       config.onProcessingStart?.();
 
-      const imageBase64 = await config.prepareImage(state.imageUri);
-
-      const result = await executeImageToVideo(
-        {
-          imageUri: state.imageUri,
-          imageBase64,
-          userId,
-          motionPrompt: state.motionPrompt || undefined,
-          options,
-        },
-        {
-          model: config.model,
-          buildInput: config.buildInput,
-          extractResult: config.extractResult,
-          onProgress: (progress) => {
-            setState((prev) => ({ ...prev, progress }));
-          },
-        },
-      );
+      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__) {
+            // eslint-disable-next-line no-console
+            console.warn("[ImageToVideoFeature] onGenerationStart failed:", err);
+          }
+        });
+      }
 
-      if (result.success && result.videoUrl) {
+      try {
+        const imageBase64 = await config.prepareImage(imageUri);
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          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__) {
+          // eslint-disable-next-line no-console
+          console.error("[ImageToVideoFeature] Generation error:", errorMessage);
+        }
         setState((prev) => ({
           ...prev,
-          videoUrl: result.videoUrl ?? null,
-          thumbnailUrl: result.thumbnailUrl ?? null,
           isProcessing: false,
-          progress: 100,
+          error: errorMessage,
         }));
-      } else {
-        const error = result.error || "Generation failed";
-        setState((prev) => ({ ...prev, isProcessing: false, error }));
-        config.onError?.(error);
+        config.onError?.(errorMessage);
+        callbacks?.onError?.(errorMessage);
+        return { success: false, error: errorMessage };
       }
+    },
+    [userId, config, callbacks],
+  );
 
-      config.onProcessingComplete?.(result);
-      return result;
+  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__) {
+        // eslint-disable-next-line no-console
+        console.log("[ImageToVideoFeature] generate called:", {
+          paramImageUri,
+          stateImageUri: state.imageUri,
+          effectiveImageUri,
+        });
+      }
+
+      if (!effectiveImageUri) {
+        const error = "Image is required";
+        setState((prev) => ({ ...prev, error }));
+        callbacks?.onError?.(error);
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[ImageToVideoFeature] Generate failed: Image is required");
+        }
+        return { success: false, error };
+      }
+
+      if (paramImageUri) {
+        setState((prev) => ({ ...prev, imageUri: paramImageUri }));
+      }
+
+      if (callbacks?.onAuthCheck && !callbacks.onAuthCheck()) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[ImageToVideoFeature] Generate failed: Authentication required");
+        }
+        return { success: false, error: "Authentication required" };
+      }
+
+      if (callbacks?.onCreditCheck && config.creditCost) {
+        const hasCredits = await callbacks.onCreditCheck(config.creditCost);
+        if (!hasCredits) {
+          callbacks?.onShowPaywall?.(config.creditCost);
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[ImageToVideoFeature] Generate failed: Insufficient credits");
+          }
+          return { success: false, error: "Insufficient credits" };
+        }
+      }
+
+      return executeGeneration(effectiveImageUri, effectiveMotionPrompt, options);
     },
-    [state.imageUri, state.motionPrompt, userId, config],
+    [state.imageUri, state.motionPrompt, callbacks, config.creditCost, executeGeneration],
   );
 
   const reset = useCallback(() => {
-    setState(initialState);
+    setState(INITIAL_STATE);
   }, []);
 
-  const isReady = state.imageUri !== null && !state.isProcessing;
+  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 };
+  return { state, setImageUri, setMotionPrompt, generate, reset, isReady, canGenerate };
 }