@umituz/react-native-ai-generation-content 1.20.24 → 1.20.26

package/package.json

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

package/src/index.ts

@@ -70,7 +70,7 @@ export {
   useGeneration, usePendingJobs, useBackgroundGeneration,
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
-  useGenerationOrchestrator, useImageGeneration, useVideoGeneration,
+  useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useAIFeatureGeneration,
   createGenerationError, getAlertMessage, parseError,
 } from "./presentation/hooks";
 

package/src/presentation/components/index.ts

@@ -9,7 +9,9 @@ export * from "./StylePresetsGrid";
 export * from "./AIGenerationForm";
 export * from "./AIGenerationForm.types";
 export * from "./AIGenerationConfig";
+
 export * from "./flows/AIGenerateWizardFlow";
+export * from "./flows/AIGenerateWizardFlow.types";
 
 export type { GenerationProgressContentProps } from "./GenerationProgressContent";
 export type { GenerationProgressBarProps } from "./GenerationProgressBar";

package/src/presentation/hooks/generation/index.ts

@@ -9,6 +9,7 @@ export { useGenerationOrchestrator } from "./orchestrator";
 // Generic feature hooks
 export { useImageGeneration } from "./useImageGeneration";
 export { useVideoGeneration } from "./useVideoGeneration";
+export { useAIFeatureGeneration } from "./useAIFeatureGeneration";
 
 // Types
 export type {

package/src/presentation/hooks/generation/useAIFeatureGeneration.ts

@@ -0,0 +1,162 @@
+
+import { useCallback } from "react";
+import { useImageGeneration } from "./useImageGeneration";
+import { useVideoGeneration } from "./useVideoGeneration";
+import { executeImageToVideo } from "../../../features/image-to-video";
+import { executeTextToVideo } from "../../../features/text-to-video";
+import { useGenerationOrchestrator } from "./orchestrator";
+import { prepareImage } from "../../../infrastructure/utils";
+import type { AIFeatureId } from "../../screens/ai-feature/types";
+import type { ImageFeatureType, VideoFeatureType } from "../../../domain/interfaces";
+
+interface FeatureGenerationConfig {
+  featureType: AIFeatureId;
+  userId?: string;
+  alertMessages: any;
+  onSuccess?: (result: any) => void;
+  onError?: (error: any) => void;
+  creditCost?: number;
+  onCreditsExhausted?: () => void;
+}
+
+export function useAIFeatureGeneration({
+  featureType,
+  userId,
+  alertMessages,
+  onSuccess,
+  onError,
+  creditCost = 1,
+  onCreditsExhausted,
+}: FeatureGenerationConfig) {
+
+  // Hook for standard image features
+  const { generate: generateImage } = useImageGeneration({
+    featureType: featureType as ImageFeatureType,
+    userId,
+    processResult: (imageUrl) => imageUrl,
+    alertMessages,
+    onSuccess,
+    onError,
+    creditCost,
+    onCreditsExhausted,
+  });
+
+  // Hook for standard video features (ai-hug, ai-kiss)
+  const { generate: generateVideo } = useVideoGeneration({
+    featureType: featureType as VideoFeatureType,
+    userId,
+    processResult: (videoUrl) => videoUrl,
+    alertMessages,
+    onSuccess,
+    onError,
+    creditCost,
+    onCreditsExhausted,
+  });
+
+  // Orchestrator for Image-to-Video
+  const { generate: generateImageToVideo } = useGenerationOrchestrator(
+    {
+      execute: async (input: { imageUri: string; prompt: string; duration: number }, onProgress) => {
+        const result = await executeImageToVideo(
+          {
+            imageUri: input.imageUri, // Pass URI directly
+            imageBase64: await prepareImage(input.imageUri), 
+            motionPrompt: input.prompt,
+            options: { duration: input.duration },
+            userId: userId || "anonymous",
+          },
+          {
+            model: "kling-video", // Default or hardcoded for now, ideal to get from config
+            buildInput: (image, prompt, opts) => ({
+              image,
+              prompt,
+              ...opts
+            }),
+            onProgress,
+          }
+        );
+        if (!result.success || !result.videoUrl) throw new Error(result.error || "Generation failed");
+        return result.videoUrl;
+      },
+      getCreditCost: () => creditCost,
+    },
+    { userId, alertMessages, onSuccess, onError, onCreditsExhausted }
+  );
+
+  // Orchestrator for Text-to-Video
+  const { generate: generateTextToVideo } = useGenerationOrchestrator(
+    {
+      execute: async (input: { prompt: string; duration: number }, onProgress) => {
+        const result = await executeTextToVideo(
+          {
+            prompt: input.prompt,
+            options: { duration: input.duration },
+            userId: userId || "anonymous",
+          },
+          {
+            model: "kling-video", // Default
+            buildInput: (prompt, opts) => ({ prompt, ...opts }),
+            onProgress,
+          }
+        );
+        if (!result.success || !result.videoUrl) throw new Error(result.error || "Generation failed");
+        return result.videoUrl;
+      },
+      getCreditCost: () => creditCost,
+    },
+    { userId, alertMessages, onSuccess, onError, onCreditsExhausted }
+  );
+
+  const generate = useCallback(async (data: {
+    prompt: string;
+    style: string;
+    duration: number;
+    images: { uri: string }[];
+  }) => {
+    switch (featureType) {
+      case "image-to-video":
+        if (!data.images[0]?.uri) throw new Error("Image required for image-to-video");
+        return await generateImageToVideo({ 
+          imageUri: data.images[0].uri, 
+          prompt: data.prompt, 
+          duration: data.duration 
+        });
+
+      case "text-to-video":
+        return await generateTextToVideo({ 
+          prompt: data.prompt, 
+          duration: data.duration 
+        });
+
+      case "ai-hug":
+      case "ai-kiss":
+        if (data.images.length < 2) throw new Error("Two images required");
+        return await generateVideo({
+          sourceImageBase64: await prepareImage(data.images[0].uri),
+          targetImageBase64: await prepareImage(data.images[1].uri),
+        });
+
+      default:
+        // Default to Image Generation
+        if (data.images.length > 0) {
+           // Single or dual image
+           if (data.images.length === 2 && (featureType === "face-swap")) {
+              return await generateImage({
+                sourceImageBase64: await prepareImage(data.images[0].uri),
+                targetImageBase64: await prepareImage(data.images[1].uri),
+                options: { style: data.style }
+              });
+           }
+           // Single image features
+           return await generateImage({
+             imageBase64: await prepareImage(data.images[0].uri),
+             prompt: data.prompt,
+             options: { style: data.style }
+           });
+        }
+        throw new Error(`Unsupported feature or missing input: ${featureType}`);
+    }
+  }, [featureType, generateImage, generateVideo, generateImageToVideo, generateTextToVideo]);
+
+  return { generate };
+}

package/src/presentation/screens/ai-feature/registry.ts

@@ -104,6 +104,22 @@ export const AI_FEATURE_CONFIGS: Record<AIFeatureId, AIFeatureConfig> = {
     creditType: "image",
     translationPrefix: "ai-kiss",
   },
+  
+  // Generic Video Features
+  "image-to-video": {
+    id: "image-to-video",
+    mode: "single-with-prompt",
+    outputType: "video",
+    creditType: "video",
+    translationPrefix: "image-to-video",
+  },
+  "text-to-video": {
+    id: "text-to-video",
+    mode: "text-input",
+    outputType: "video",
+    creditType: "video",
+    translationPrefix: "text-to-video",
+  },
 };
 
 /**

package/src/presentation/screens/ai-feature/types.ts

@@ -19,7 +19,9 @@ export type AIFeatureId =
   | "face-swap"
   | "ai-hug"
   | "ai-kiss"
-  | "meme-generator";
+  | "meme-generator"
+  | "image-to-video"
+  | "text-to-video";
 
 /**
  * Image mode for the feature