@umituz/react-native-ai-generation-content 1.17.24 → 1.17.26

package/package.json

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

package/src/domain/interfaces/ai-provider.interface.ts

@@ -44,6 +44,46 @@ export interface SubscribeOptions<T = unknown> {
   onResult?: (result: T) => void;
 }
 
+/**
+ * Feature types for image processing (output: image)
+ */
+export type ImageFeatureType =
+  | "upscale"
+  | "photo-restore"
+  | "face-swap"
+  | "anime-selfie"
+  | "remove-background"
+  | "remove-object"
+  | "hd-touch-up"
+  | "replace-background";
+
+/**
+ * Feature types for video generation (output: video)
+ */
+export type VideoFeatureType =
+  | "ai-hug"
+  | "ai-kiss";
+
+/**
+ * Input data for image features
+ */
+export interface ImageFeatureInputData {
+  imageBase64: string;
+  targetImageBase64?: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Input data for video features
+ */
+export interface VideoFeatureInputData {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
 /**
  * AI Provider Interface
  * All AI providers must implement this interface
@@ -73,4 +113,30 @@ export interface IAIProvider {
   run<T = unknown>(model: string, input: Record<string, unknown>): Promise<T>;
 
   reset(): void;
+
+  /**
+   * Get model ID for an image feature
+   */
+  getImageFeatureModel(feature: ImageFeatureType): string;
+
+  /**
+   * Build provider-specific input for an image feature
+   */
+  buildImageFeatureInput(
+    feature: ImageFeatureType,
+    data: ImageFeatureInputData,
+  ): Record<string, unknown>;
+
+  /**
+   * Get model ID for a video feature
+   */
+  getVideoFeatureModel(feature: VideoFeatureType): string;
+
+  /**
+   * Build provider-specific input for a video feature
+   */
+  buildVideoFeatureInput(
+    feature: VideoFeatureType,
+    data: VideoFeatureInputData,
+  ): Record<string, unknown>;
 }

package/src/features/ai-hug/domain/types/ai-hug.types.ts

@@ -1,6 +1,6 @@
 /**
  * AI Hug Feature Types
- * Request, Result, Config types for AI hug generation
+ * Request, Result, Config types for AI hug video generation
  */
 
 export interface AIHugOptions {
@@ -14,13 +14,13 @@ export interface AIHugRequest {
   sourceImageBase64?: string;
   targetImageBase64?: string;
   userId: string;
+  prompt?: string;
   options?: AIHugOptions;
 }
 
 export interface AIHugResult {
   success: boolean;
-  imageUrl?: string;
-  imageBase64?: string;
+  videoUrl?: string;
   error?: string;
   requestId?: string;
 }
@@ -28,7 +28,7 @@ export interface AIHugResult {
 export interface AIHugFeatureState {
   sourceImageUri: string | null;
   targetImageUri: string | null;
-  processedUrl: string | null;
+  processedVideoUrl: string | null;
   isProcessing: boolean;
   progress: number;
   error: string | null;
@@ -49,19 +49,10 @@ export interface AIHugTranslations {
   tryAnotherText: string;
 }
 
-export type AIHugInputBuilder = (
-  sourceBase64: string,
-  targetBase64: string,
-  options?: AIHugOptions,
-) => Record<string, unknown>;
-
 export type AIHugResultExtractor = (result: unknown) => string | undefined;
 
 export interface AIHugFeatureConfig {
-  providerId?: string;
   creditCost?: number;
-  model: string;
-  buildInput: AIHugInputBuilder;
   extractResult?: AIHugResultExtractor;
   prepareImage: (imageUri: string) => Promise<string>;
   onSourceImageSelect?: (uri: string) => void;

package/src/features/ai-hug/domain/types/index.ts

@@ -8,7 +8,6 @@ export type {
   AIHugResult,
   AIHugFeatureState,
   AIHugTranslations,
-  AIHugInputBuilder,
   AIHugResultExtractor,
   AIHugFeatureConfig,
 } from "./ai-hug.types";

package/src/features/ai-hug/index.ts

@@ -1,6 +1,6 @@
 /**
  * AI Hug Feature
- * Provider-agnostic AI hug generation feature
+ * Provider-agnostic AI hug video generation feature
  */
 
 // Domain Types
@@ -11,14 +11,9 @@ export type {
   AIHugFeatureState,
   AIHugTranslations,
   AIHugFeatureConfig,
-  AIHugInputBuilder,
   AIHugResultExtractor,
 } from "./domain";
 
-// Infrastructure Services
-export { executeAIHug, hasAIHugSupport } from "./infrastructure";
-export type { ExecuteAIHugOptions } from "./infrastructure";
-
 // Presentation Hooks
 export { useAIHugFeature } from "./presentation";
 export type {

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

@@ -1,11 +1,11 @@
 /**
  * AIHugFeature Component
- * Self-contained AI hug feature UI component
+ * Self-contained AI hug video feature UI component
  * Uses hook internally, only requires config and translations
  */
 
 import React, { useCallback } from "react";
-import { View, ScrollView, StyleSheet, Image, Dimensions } from "react-native";
+import { View, ScrollView, StyleSheet, Dimensions } from "react-native";
 import {
   useAppDesignTokens,
   AtomicText,
@@ -22,16 +22,16 @@ import type {
 export interface AIHugFeatureProps {
   /** Feature configuration with provider-specific settings */
   config: AIHugFeatureConfig;
-  /** User ID for the generation request */
-  userId: string;
   /** Translations for all UI text */
   translations: AIHugTranslations;
   /** Source image picker callback */
   onSelectSourceImage: () => Promise<string | null>;
   /** Target image picker callback */
   onSelectTargetImage: () => Promise<string | null>;
-  /** Save image callback */
-  onSaveImage: (imageUrl: string) => Promise<void>;
+  /** Save video callback */
+  onSaveVideo: (videoUrl: string) => Promise<void>;
+  /** Custom video player renderer - required for video playback */
+  renderVideoPlayer: (props: { videoUrl: string; size: number }) => React.ReactNode;
   /** Optional custom processing modal renderer */
   renderProcessingModal?: (props: {
     visible: boolean;
@@ -41,21 +41,20 @@ export interface AIHugFeatureProps {
 
 export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
   config,
-  userId,
   translations,
   onSelectSourceImage,
   onSelectTargetImage,
-  onSaveImage,
+  onSaveVideo,
+  renderVideoPlayer,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
 
   const feature = useAIHugFeature({
     config,
-    userId,
     onSelectSourceImage,
     onSelectTargetImage,
-    onSaveImage,
+    onSaveVideo,
   });
 
   const handleProcess = useCallback(() => {
@@ -76,9 +75,9 @@ export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
 
   const canProcess = feature.sourceImageUri && feature.targetImageUri && !feature.isProcessing;
 
-  if (feature.processedUrl) {
+  if (feature.processedVideoUrl) {
     const screenWidth = Dimensions.get("window").width;
-    const imageSize = screenWidth - 48;
+    const videoSize = screenWidth - 48;
 
     return (
       <ScrollView
@@ -93,12 +92,8 @@ export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
           {translations.successText}
         </AtomicText>
 
-        <View style={styles.resultImageContainer}>
-          <Image
-            source={{ uri: feature.processedUrl }}
-            style={[styles.resultImage, { width: imageSize, height: imageSize }]}
-            resizeMode="contain"
-          />
+        <View style={styles.resultVideoContainer}>
+          {renderVideoPlayer({ videoUrl: feature.processedVideoUrl, size: videoSize })}
         </View>
 
         <View style={styles.resultActions}>
@@ -190,14 +185,11 @@ const styles = StyleSheet.create({
     textAlign: "center",
     marginBottom: 24,
   },
-  resultImageContainer: {
+  resultVideoContainer: {
     alignItems: "center",
     marginHorizontal: 24,
     marginBottom: 24,
   },
-  resultImage: {
-    borderRadius: 16,
-  },
   resultActions: {
     marginHorizontal: 24,
     gap: 12,

package/src/features/ai-hug/presentation/hooks/useAIHugFeature.ts

@@ -1,24 +1,21 @@
 /**
  * useAIHugFeature Hook
- * Manages AI hug feature state and actions
+ * Manages AI hug video generation state and actions
  */
 
 import { useState, useCallback } from "react";
-import { executeAIHug } from "../../infrastructure/services";
+import { executeVideoFeature } from "../../../../infrastructure/services";
 import type {
   AIHugFeatureState,
   AIHugFeatureConfig,
   AIHugResult,
 } from "../../domain/types";
 
-declare const __DEV__: boolean;
-
 export interface UseAIHugFeatureProps {
   config: AIHugFeatureConfig;
-  userId: string;
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
-  onSaveImage: (imageUrl: string) => Promise<void>;
+  onSaveVideo: (videoUrl: string) => Promise<void>;
 }
 
 export interface UseAIHugFeatureReturn extends AIHugFeatureState {
@@ -32,7 +29,7 @@ export interface UseAIHugFeatureReturn extends AIHugFeatureState {
 const initialState: AIHugFeatureState = {
   sourceImageUri: null,
   targetImageUri: null,
-  processedUrl: null,
+  processedVideoUrl: null,
   isProcessing: false,
   progress: 0,
   error: null,
@@ -41,7 +38,7 @@ const initialState: AIHugFeatureState = {
 export function useAIHugFeature(
   props: UseAIHugFeatureProps,
 ): UseAIHugFeatureReturn {
-  const { config, userId, onSelectSourceImage, onSelectTargetImage, onSaveImage } = props;
+  const { config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
   const [state, setState] = useState<AIHugFeatureState>(initialState);
 
   const selectSourceImage = useCallback(async () => {
@@ -86,39 +83,23 @@ export function useAIHugFeature(
 
     config.onProcessingStart?.();
 
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[useAIHugFeature] Starting AI hug process");
-    }
-
     const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
     const targetImageBase64 = await config.prepareImage(state.targetImageUri);
 
-    const result: AIHugResult = await executeAIHug(
-      {
-        sourceImageUri: state.sourceImageUri,
-        targetImageUri: state.targetImageUri,
-        sourceImageBase64,
-        targetImageBase64,
-        userId,
-      },
-      {
-        model: config.model,
-        buildInput: config.buildInput,
-        extractResult: config.extractResult,
-        onProgress: handleProgress,
-      },
+    const result = await executeVideoFeature(
+      "ai-hug",
+      { sourceImageBase64, targetImageBase64 },
+      { extractResult: config.extractResult, onProgress: handleProgress },
     );
 
-    if (result.success && result.imageUrl) {
-      const url = result.imageUrl;
+    if (result.success && result.videoUrl) {
       setState((prev) => ({
         ...prev,
         isProcessing: false,
-        processedUrl: url,
+        processedVideoUrl: result.videoUrl!,
         progress: 100,
       }));
-      config.onProcessingComplete?.(result);
+      config.onProcessingComplete?.({ success: true, videoUrl: result.videoUrl });
     } else {
       const errorMessage = result.error || "Processing failed";
       setState((prev) => ({
@@ -129,18 +110,18 @@ export function useAIHugFeature(
       }));
       config.onError?.(errorMessage);
     }
-  }, [state.sourceImageUri, state.targetImageUri, userId, config, handleProgress]);
+  }, [state.sourceImageUri, state.targetImageUri, config, handleProgress]);
 
   const save = useCallback(async () => {
-    if (!state.processedUrl) return;
+    if (!state.processedVideoUrl) return;
 
     try {
-      await onSaveImage(state.processedUrl);
+      await onSaveVideo(state.processedVideoUrl);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       setState((prev) => ({ ...prev, error: message }));
     }
-  }, [state.processedUrl, onSaveImage]);
+  }, [state.processedVideoUrl, onSaveVideo]);
 
   const reset = useCallback(() => {
     setState(initialState);

package/src/features/ai-kiss/domain/types/ai-kiss.types.ts

@@ -1,6 +1,6 @@
 /**
  * AI Kiss Feature Types
- * Request, Result, Config types for AI kiss generation
+ * Request, Result, Config types for AI kiss video generation
  */
 
 export interface AIKissOptions {
@@ -14,13 +14,13 @@ export interface AIKissRequest {
   sourceImageBase64?: string;
   targetImageBase64?: string;
   userId: string;
+  prompt?: string;
   options?: AIKissOptions;
 }
 
 export interface AIKissResult {
   success: boolean;
-  imageUrl?: string;
-  imageBase64?: string;
+  videoUrl?: string;
   error?: string;
   requestId?: string;
 }
@@ -28,7 +28,7 @@ export interface AIKissResult {
 export interface AIKissFeatureState {
   sourceImageUri: string | null;
   targetImageUri: string | null;
-  processedUrl: string | null;
+  processedVideoUrl: string | null;
   isProcessing: boolean;
   progress: number;
   error: string | null;
@@ -49,19 +49,10 @@ export interface AIKissTranslations {
   tryAnotherText: string;
 }
 
-export type AIKissInputBuilder = (
-  sourceBase64: string,
-  targetBase64: string,
-  options?: AIKissOptions,
-) => Record<string, unknown>;
-
 export type AIKissResultExtractor = (result: unknown) => string | undefined;
 
 export interface AIKissFeatureConfig {
-  providerId?: string;
   creditCost?: number;
-  model: string;
-  buildInput: AIKissInputBuilder;
   extractResult?: AIKissResultExtractor;
   prepareImage: (imageUri: string) => Promise<string>;
   onSourceImageSelect?: (uri: string) => void;

package/src/features/ai-kiss/domain/types/index.ts

@@ -8,7 +8,6 @@ export type {
   AIKissResult,
   AIKissFeatureState,
   AIKissTranslations,
-  AIKissInputBuilder,
   AIKissResultExtractor,
   AIKissFeatureConfig,
 } from "./ai-kiss.types";

package/src/features/ai-kiss/index.ts

@@ -1,6 +1,6 @@
 /**
  * AI Kiss Feature
- * Provider-agnostic AI kiss generation feature
+ * Provider-agnostic AI kiss video generation feature
  */
 
 // Domain Types
@@ -11,14 +11,9 @@ export type {
   AIKissFeatureState,
   AIKissTranslations,
   AIKissFeatureConfig,
-  AIKissInputBuilder,
   AIKissResultExtractor,
 } from "./domain";
 
-// Infrastructure Services
-export { executeAIKiss, hasAIKissSupport } from "./infrastructure";
-export type { ExecuteAIKissOptions } from "./infrastructure";
-
 // Presentation Hooks
 export { useAIKissFeature } from "./presentation";
 export type {

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

@@ -1,11 +1,11 @@
 /**
  * AIKissFeature Component
- * Self-contained AI kiss feature UI component
+ * Self-contained AI kiss video feature UI component
  * Uses hook internally, only requires config and translations
  */
 
 import React, { useCallback } from "react";
-import { View, ScrollView, StyleSheet, Image, Dimensions } from "react-native";
+import { View, ScrollView, StyleSheet, Dimensions } from "react-native";
 import {
   useAppDesignTokens,
   AtomicText,
@@ -21,11 +21,12 @@ import type {
 
 export interface AIKissFeatureProps {
   config: AIKissFeatureConfig;
-  userId: string;
   translations: AIKissTranslations;
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
-  onSaveImage: (imageUrl: string) => Promise<void>;
+  onSaveVideo: (videoUrl: string) => Promise<void>;
+  /** Custom video player renderer - required for video playback */
+  renderVideoPlayer: (props: { videoUrl: string; size: number }) => React.ReactNode;
   renderProcessingModal?: (props: {
     visible: boolean;
     progress: number;
@@ -34,21 +35,20 @@ export interface AIKissFeatureProps {
 
 export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
   config,
-  userId,
   translations,
   onSelectSourceImage,
   onSelectTargetImage,
-  onSaveImage,
+  onSaveVideo,
+  renderVideoPlayer,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
 
   const feature = useAIKissFeature({
     config,
-    userId,
     onSelectSourceImage,
     onSelectTargetImage,
-    onSaveImage,
+    onSaveVideo,
   });
 
   const handleProcess = useCallback(() => {
@@ -69,9 +69,9 @@ export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
 
   const canProcess = feature.sourceImageUri && feature.targetImageUri && !feature.isProcessing;
 
-  if (feature.processedUrl) {
+  if (feature.processedVideoUrl) {
     const screenWidth = Dimensions.get("window").width;
-    const imageSize = screenWidth - 48;
+    const videoSize = screenWidth - 48;
 
     return (
       <ScrollView
@@ -86,12 +86,8 @@ export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
           {translations.successText}
         </AtomicText>
 
-        <View style={styles.resultImageContainer}>
-          <Image
-            source={{ uri: feature.processedUrl }}
-            style={[styles.resultImage, { width: imageSize, height: imageSize }]}
-            resizeMode="contain"
-          />
+        <View style={styles.resultVideoContainer}>
+          {renderVideoPlayer({ videoUrl: feature.processedVideoUrl, size: videoSize })}
         </View>
 
         <View style={styles.resultActions}>
@@ -183,14 +179,11 @@ const styles = StyleSheet.create({
     textAlign: "center",
     marginBottom: 24,
   },
-  resultImageContainer: {
+  resultVideoContainer: {
     alignItems: "center",
     marginHorizontal: 24,
     marginBottom: 24,
   },
-  resultImage: {
-    borderRadius: 16,
-  },
   resultActions: {
     marginHorizontal: 24,
     gap: 12,

package/src/features/ai-kiss/presentation/hooks/useAIKissFeature.ts

@@ -1,24 +1,21 @@
 /**
  * useAIKissFeature Hook
- * Manages AI kiss feature state and actions
+ * Manages AI kiss video generation state and actions
  */
 
 import { useState, useCallback } from "react";
-import { executeAIKiss } from "../../infrastructure/services";
+import { executeVideoFeature } from "../../../../infrastructure/services";
 import type {
   AIKissFeatureState,
   AIKissFeatureConfig,
   AIKissResult,
 } from "../../domain/types";
 
-declare const __DEV__: boolean;
-
 export interface UseAIKissFeatureProps {
   config: AIKissFeatureConfig;
-  userId: string;
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
-  onSaveImage: (imageUrl: string) => Promise<void>;
+  onSaveVideo: (videoUrl: string) => Promise<void>;
 }
 
 export interface UseAIKissFeatureReturn extends AIKissFeatureState {
@@ -32,7 +29,7 @@ export interface UseAIKissFeatureReturn extends AIKissFeatureState {
 const initialState: AIKissFeatureState = {
   sourceImageUri: null,
   targetImageUri: null,
-  processedUrl: null,
+  processedVideoUrl: null,
   isProcessing: false,
   progress: 0,
   error: null,
@@ -41,7 +38,7 @@ const initialState: AIKissFeatureState = {
 export function useAIKissFeature(
   props: UseAIKissFeatureProps,
 ): UseAIKissFeatureReturn {
-  const { config, userId, onSelectSourceImage, onSelectTargetImage, onSaveImage } = props;
+  const { config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
   const [state, setState] = useState<AIKissFeatureState>(initialState);
 
   const selectSourceImage = useCallback(async () => {
@@ -86,39 +83,23 @@ export function useAIKissFeature(
 
     config.onProcessingStart?.();
 
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[useAIKissFeature] Starting AI kiss process");
-    }
-
     const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
     const targetImageBase64 = await config.prepareImage(state.targetImageUri);
 
-    const result: AIKissResult = await executeAIKiss(
-      {
-        sourceImageUri: state.sourceImageUri,
-        targetImageUri: state.targetImageUri,
-        sourceImageBase64,
-        targetImageBase64,
-        userId,
-      },
-      {
-        model: config.model,
-        buildInput: config.buildInput,
-        extractResult: config.extractResult,
-        onProgress: handleProgress,
-      },
+    const result = await executeVideoFeature(
+      "ai-kiss",
+      { sourceImageBase64, targetImageBase64 },
+      { extractResult: config.extractResult, onProgress: handleProgress },
     );
 
-    if (result.success && result.imageUrl) {
-      const url = result.imageUrl;
+    if (result.success && result.videoUrl) {
       setState((prev) => ({
         ...prev,
         isProcessing: false,
-        processedUrl: url,
+        processedVideoUrl: result.videoUrl!,
         progress: 100,
       }));
-      config.onProcessingComplete?.(result);
+      config.onProcessingComplete?.({ success: true, videoUrl: result.videoUrl });
     } else {
       const errorMessage = result.error || "Processing failed";
       setState((prev) => ({
@@ -129,18 +110,18 @@ export function useAIKissFeature(
       }));
       config.onError?.(errorMessage);
     }
-  }, [state.sourceImageUri, state.targetImageUri, userId, config, handleProgress]);
+  }, [state.sourceImageUri, state.targetImageUri, config, handleProgress]);
 
   const save = useCallback(async () => {
-    if (!state.processedUrl) return;
+    if (!state.processedVideoUrl) return;
 
     try {
-      await onSaveImage(state.processedUrl);
+      await onSaveVideo(state.processedVideoUrl);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       setState((prev) => ({ ...prev, error: message }));
     }
-  }, [state.processedUrl, onSaveImage]);
+  }, [state.processedVideoUrl, onSaveVideo]);
 
   const reset = useCallback(() => {
     setState(initialState);