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

package/src/features/upscaling/presentation/hooks/useUpscaleFeature.ts

@@ -4,18 +4,15 @@
  */
 
 import { useState, useCallback } from "react";
-import { executeUpscale } from "../../infrastructure/services";
+import { executeImageFeature } from "../../../../infrastructure/services";
 import type {
   UpscaleFeatureState,
   UpscaleFeatureConfig,
   UpscaleResult,
 } from "../../domain/types";
 
-declare const __DEV__: boolean;
-
 export interface UseUpscaleFeatureProps {
   config: UpscaleFeatureConfig;
-  userId: string;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
 }
@@ -38,7 +35,7 @@ const initialState: UpscaleFeatureState = {
 export function useUpscaleFeature(
   props: UseUpscaleFeatureProps,
 ): UseUpscaleFeatureReturn {
-  const { config, userId, onSelectImage, onSaveImage } = props;
+  const { config, onSelectImage, onSaveImage } = props;
   const [state, setState] = useState<UpscaleFeatureState>(initialState);
 
   const selectImage = useCallback(async () => {
@@ -70,37 +67,25 @@ export function useUpscaleFeature(
 
     config.onProcessingStart?.();
 
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[useUpscaleFeature] Starting upscale process");
-    }
-
     const imageBase64 = await config.prepareImage(state.imageUri);
 
-    const result: UpscaleResult = await executeUpscale(
+    const result = await executeImageFeature(
+      "upscale",
       {
-        imageUri: state.imageUri,
         imageBase64,
-        userId,
         options: { scaleFactor: config.defaultScaleFactor || 2 },
       },
-      {
-        model: config.model,
-        buildInput: config.buildInput,
-        extractResult: config.extractResult,
-        onProgress: handleProgress,
-      },
+      { extractResult: config.extractResult, onProgress: handleProgress },
     );
 
     if (result.success && result.imageUrl) {
-      const url = result.imageUrl;
       setState((prev) => ({
         ...prev,
         isProcessing: false,
-        processedUrl: url,
+        processedUrl: result.imageUrl!,
         progress: 100,
       }));
-      config.onProcessingComplete?.(result);
+      config.onProcessingComplete?.(result as UpscaleResult);
     } else {
       const errorMessage = result.error || "Processing failed";
       setState((prev) => ({
@@ -111,7 +96,7 @@ export function useUpscaleFeature(
       }));
       config.onError?.(errorMessage);
     }
-  }, [state.imageUri, userId, config, handleProgress]);
+  }, [state.imageUri, config, handleProgress]);
 
   const save = useCallback(async () => {
     if (!state.processedUrl) return;

package/src/index.ts

@@ -25,6 +25,10 @@ export type {
   AIJobStatusType,
   AILogEntry,
   SubscribeOptions,
+  ImageFeatureType,
+  VideoFeatureType,
+  ImageFeatureInputData,
+  VideoFeatureInputData,
 } from "./domain/interfaces";
 
 export {

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -0,0 +1,143 @@
+/**
+ * Image Feature Executor
+ * Single entry point for all image feature executions
+ * Output: image URL
+ */
+
+import { providerRegistry } from "./provider-registry.service";
+import { cleanBase64 } from "../utils";
+import type { ImageFeatureType, ImageFeatureInputData } from "../../domain/interfaces";
+
+declare const __DEV__: boolean;
+
+/**
+ * Result extractor function type
+ */
+export type ImageResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Execution options
+ */
+export interface ExecuteImageFeatureOptions {
+  extractResult?: ImageResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+/**
+ * Execution result
+ */
+export interface ImageFeatureResult {
+  success: boolean;
+  imageUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+/**
+ * Request data for image features
+ */
+export interface ImageFeatureRequest {
+  imageBase64?: string;
+  targetImageBase64?: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Default result extractor - handles common response formats
+ */
+function defaultExtractImageResult(result: unknown): string | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.image === "string") return r.image;
+  if (typeof r.imageUrl === "string") return r.imageUrl;
+  if (typeof r.output === "string") return r.output;
+  if (Array.isArray(r.images) && typeof r.images[0]?.url === "string") {
+    return r.images[0].url;
+  }
+
+  return undefined;
+}
+
+/**
+ * Execute any image feature using the active provider
+ */
+export async function executeImageFeature(
+  featureType: ImageFeatureType,
+  request: ImageFeatureRequest,
+  options?: ExecuteImageFeatureOptions,
+): Promise<ImageFeatureResult> {
+  const provider = providerRegistry.getActiveProvider();
+
+  if (!provider) {
+    return { success: false, error: "No AI provider configured" };
+  }
+
+  if (!provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  const { extractResult, onProgress } = options ?? {};
+
+  const model = provider.getImageFeatureModel(featureType);
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[Image:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const inputData: ImageFeatureInputData = {
+      imageBase64: request.imageBase64 ? cleanBase64(request.imageBase64) : "",
+      targetImageBase64: request.targetImageBase64
+        ? cleanBase64(request.targetImageBase64)
+        : undefined,
+      prompt: request.prompt,
+      options: request.options,
+    };
+
+    onProgress?.(30);
+
+    const input = provider.buildImageFeatureInput(featureType, inputData);
+
+    onProgress?.(40);
+
+    const result = await provider.run(model, input);
+
+    onProgress?.(90);
+
+    const extractor = extractResult ?? defaultExtractImageResult;
+    const imageUrl = extractor(result);
+
+    onProgress?.(100);
+
+    if (!imageUrl) {
+      return { success: false, error: "No image in response" };
+    }
+
+    return {
+      success: true,
+      imageUrl,
+      requestId: (result as { requestId?: string })?.requestId,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error(`[Image:${featureType}] Error:`, message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+/**
+ * Check if image features are supported
+ */
+export function hasImageFeatureSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

package/src/infrastructure/services/index.ts

@@ -12,3 +12,23 @@ export {
   createGenerationWrapper,
 } from "./generation-wrapper.service";
 export type { WrapperConfig } from "./generation-wrapper.service";
+export {
+  executeImageFeature,
+  hasImageFeatureSupport,
+} from "./image-feature-executor.service";
+export type {
+  ImageResultExtractor,
+  ExecuteImageFeatureOptions,
+  ImageFeatureResult,
+  ImageFeatureRequest,
+} from "./image-feature-executor.service";
+export {
+  executeVideoFeature,
+  hasVideoFeatureSupport,
+} from "./video-feature-executor.service";
+export type {
+  VideoResultExtractor,
+  ExecuteVideoFeatureOptions,
+  VideoFeatureResult,
+  VideoFeatureRequest,
+} from "./video-feature-executor.service";

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -0,0 +1,140 @@
+/**
+ * Video Feature Executor
+ * Single entry point for all video feature executions
+ * Output: video URL
+ */
+
+import { providerRegistry } from "./provider-registry.service";
+import { cleanBase64 } from "../utils";
+import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
+
+declare const __DEV__: boolean;
+
+/**
+ * Result extractor function type
+ */
+export type VideoResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Execution options
+ */
+export interface ExecuteVideoFeatureOptions {
+  extractResult?: VideoResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+/**
+ * Execution result
+ */
+export interface VideoFeatureResult {
+  success: boolean;
+  videoUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+/**
+ * Request data for video features
+ */
+export interface VideoFeatureRequest {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Default result extractor - handles common response formats
+ */
+function defaultExtractVideoResult(result: unknown): string | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.video === "string") return r.video;
+  if (typeof r.videoUrl === "string") return r.videoUrl;
+  if (typeof r.video_url === "string") return r.video_url;
+  if (typeof r.output === "string") return r.output;
+  if (typeof r.url === "string") return r.url;
+
+  return undefined;
+}
+
+/**
+ * Execute any video feature using the active provider
+ */
+export async function executeVideoFeature(
+  featureType: VideoFeatureType,
+  request: VideoFeatureRequest,
+  options?: ExecuteVideoFeatureOptions,
+): Promise<VideoFeatureResult> {
+  const provider = providerRegistry.getActiveProvider();
+
+  if (!provider) {
+    return { success: false, error: "No AI provider configured" };
+  }
+
+  if (!provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  const { extractResult, onProgress } = options ?? {};
+
+  const model = provider.getVideoFeatureModel(featureType);
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[Video:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const inputData: VideoFeatureInputData = {
+      sourceImageBase64: cleanBase64(request.sourceImageBase64),
+      targetImageBase64: cleanBase64(request.targetImageBase64),
+      prompt: request.prompt,
+      options: request.options,
+    };
+
+    onProgress?.(30);
+
+    const input = provider.buildVideoFeatureInput(featureType, inputData);
+
+    onProgress?.(40);
+
+    const result = await provider.run(model, input);
+
+    onProgress?.(90);
+
+    const extractor = extractResult ?? defaultExtractVideoResult;
+    const videoUrl = extractor(result);
+
+    onProgress?.(100);
+
+    if (!videoUrl) {
+      return { success: false, error: "No video in response" };
+    }
+
+    return {
+      success: true,
+      videoUrl,
+      requestId: (result as { requestId?: string })?.requestId,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error(`[Video:${featureType}] Error:`, message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+/**
+ * Check if video features are supported
+ */
+export function hasVideoFeatureSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

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

@@ -1,5 +0,0 @@
-/**
- * AI Hug Infrastructure Index
- */
-
-export * from "./services";

package/src/features/ai-hug/infrastructure/services/ai-hug-executor.ts

@@ -1,96 +0,0 @@
-/**
- * AI Hug Executor
- * Provider-agnostic AI hug execution using active AI provider
- * Model and input format are provided via options from app level
- */
-
-import { providerRegistry } from "../../../../infrastructure/services";
-import { cleanBase64 } from "../../../../infrastructure/utils";
-import type {
-  AIHugRequest,
-  AIHugResult,
-  AIHugInputBuilder,
-  AIHugResultExtractor,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface ExecuteAIHugOptions {
-  model: string;
-  buildInput: AIHugInputBuilder;
-  extractResult?: AIHugResultExtractor;
-  onProgress?: (progress: number) => void;
-}
-
-function defaultExtractResult(result: unknown): string | undefined {
-  if (typeof result !== "object" || result === null) return undefined;
-
-  const r = result as Record<string, unknown>;
-
-  if (typeof r.image === "string") return r.image;
-  if (Array.isArray(r.images) && r.images[0]?.url) return r.images[0].url;
-
-  return undefined;
-}
-
-export async function executeAIHug(
-  request: AIHugRequest,
-  options: ExecuteAIHugOptions,
-): Promise<AIHugResult> {
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  if (!request.sourceImageBase64 || !request.targetImageBase64) {
-    return { success: false, error: "Both source and target image base64 are required" };
-  }
-
-  const { model, buildInput, extractResult, onProgress } = options;
-
-  if (__DEV__) {
-    // eslint-disable-next-line no-console
-    console.log(`[AIHug] Provider: ${provider.providerId}, Model: ${model}`);
-  }
-
-  try {
-    onProgress?.(10);
-
-    const sourceBase64 = cleanBase64(request.sourceImageBase64);
-    const targetBase64 = cleanBase64(request.targetImageBase64);
-    onProgress?.(30);
-
-    const input = buildInput(sourceBase64, targetBase64, request.options);
-    onProgress?.(40);
-
-    const result = await provider.run(model, input);
-    onProgress?.(90);
-
-    const extractor = extractResult || defaultExtractResult;
-    const imageUrl = extractor(result);
-    onProgress?.(100);
-
-    if (!imageUrl) {
-      return { success: false, error: "No image in response" };
-    }
-
-    return { success: true, imageUrl };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.error("[AIHug] Error:", message);
-    }
-    return { success: false, error: message };
-  }
-}
-
-export function hasAIHugSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
-}

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

@@ -1,6 +0,0 @@
-/**
- * AI Hug Infrastructure Services Index
- */
-
-export { executeAIHug, hasAIHugSupport } from "./ai-hug-executor";
-export type { ExecuteAIHugOptions } from "./ai-hug-executor";

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

@@ -1,5 +0,0 @@
-/**
- * AI Kiss Infrastructure Index
- */
-
-export * from "./services";

package/src/features/ai-kiss/infrastructure/services/ai-kiss-executor.ts

@@ -1,96 +0,0 @@
-/**
- * AI Kiss Executor
- * Provider-agnostic AI kiss execution using active AI provider
- * Model and input format are provided via options from app level
- */
-
-import { providerRegistry } from "../../../../infrastructure/services";
-import { cleanBase64 } from "../../../../infrastructure/utils";
-import type {
-  AIKissRequest,
-  AIKissResult,
-  AIKissInputBuilder,
-  AIKissResultExtractor,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface ExecuteAIKissOptions {
-  model: string;
-  buildInput: AIKissInputBuilder;
-  extractResult?: AIKissResultExtractor;
-  onProgress?: (progress: number) => void;
-}
-
-function defaultExtractResult(result: unknown): string | undefined {
-  if (typeof result !== "object" || result === null) return undefined;
-
-  const r = result as Record<string, unknown>;
-
-  if (typeof r.image === "string") return r.image;
-  if (Array.isArray(r.images) && r.images[0]?.url) return r.images[0].url;
-
-  return undefined;
-}
-
-export async function executeAIKiss(
-  request: AIKissRequest,
-  options: ExecuteAIKissOptions,
-): Promise<AIKissResult> {
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  if (!request.sourceImageBase64 || !request.targetImageBase64) {
-    return { success: false, error: "Both source and target image base64 are required" };
-  }
-
-  const { model, buildInput, extractResult, onProgress } = options;
-
-  if (__DEV__) {
-    // eslint-disable-next-line no-console
-    console.log(`[AIKiss] Provider: ${provider.providerId}, Model: ${model}`);
-  }
-
-  try {
-    onProgress?.(10);
-
-    const sourceBase64 = cleanBase64(request.sourceImageBase64);
-    const targetBase64 = cleanBase64(request.targetImageBase64);
-    onProgress?.(30);
-
-    const input = buildInput(sourceBase64, targetBase64, request.options);
-    onProgress?.(40);
-
-    const result = await provider.run(model, input);
-    onProgress?.(90);
-
-    const extractor = extractResult || defaultExtractResult;
-    const imageUrl = extractor(result);
-    onProgress?.(100);
-
-    if (!imageUrl) {
-      return { success: false, error: "No image in response" };
-    }
-
-    return { success: true, imageUrl };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.error("[AIKiss] Error:", message);
-    }
-    return { success: false, error: message };
-  }
-}
-
-export function hasAIKissSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
-}

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

@@ -1,6 +0,0 @@
-/**
- * AI Kiss Infrastructure Services Index
- */
-
-export { executeAIKiss, hasAIKissSupport } from "./ai-kiss-executor";
-export type { ExecuteAIKissOptions } from "./ai-kiss-executor";

package/src/features/anime-selfie/infrastructure/index.ts

@@ -1,5 +0,0 @@
-/**
- * Anime Selfie Infrastructure Index
- */
-
-export * from "./services";