@umituz/react-native-ai-generation-content 1.17.1 → 1.17.2

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

@@ -0,0 +1,113 @@
+/**
+ * Text-to-Image Executor
+ * Provider-agnostic text-to-image execution using active AI provider
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import type {
+  TextToImageRequest,
+  TextToImageResult,
+  TextToImageInputBuilder,
+  TextToImageResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteTextToImageOptions {
+  model: string;
+  buildInput: TextToImageInputBuilder;
+  extractResult?: TextToImageResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+function defaultExtractResult(
+  result: unknown,
+): { imageUrl?: string; imageUrls?: string[] } | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.image === "string") {
+    return { imageUrl: r.image };
+  }
+
+  if (Array.isArray(r.images)) {
+    const urls = r.images
+      .map((img) => {
+        if (typeof img === "string") return img;
+        if (img && typeof img === "object" && "url" in img) {
+          return (img as { url: string }).url;
+        }
+        return null;
+      })
+      .filter((url): url is string => url !== null);
+
+    if (urls.length > 0) {
+      return { imageUrl: urls[0], imageUrls: urls };
+    }
+  }
+
+  return undefined;
+}
+
+export async function executeTextToImage(
+  request: TextToImageRequest,
+  options: ExecuteTextToImageOptions,
+): Promise<TextToImageResult> {
+  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.prompt) {
+    return { success: false, error: "Prompt is required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[TextToImage] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const input = buildInput(request.prompt, request.options);
+    onProgress?.(20);
+
+    const result = await provider.run(model, input);
+    onProgress?.(90);
+
+    const extractor = extractResult || defaultExtractResult;
+    const extracted = extractor(result);
+    onProgress?.(100);
+
+    if (!extracted?.imageUrl) {
+      return { success: false, error: "No image in response" };
+    }
+
+    return {
+      success: true,
+      imageUrl: extracted.imageUrl,
+      imageUrls: extracted.imageUrls,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[TextToImage] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+export function hasTextToImageSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

package/src/features/text-to-image/presentation/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useTextToImageFeature } from "./useTextToImageFeature";
+export type {
+  UseTextToImageFeatureProps,
+  UseTextToImageFeatureReturn,
+} from "./useTextToImageFeature";

package/src/features/text-to-image/presentation/hooks/useTextToImageFeature.ts

@@ -0,0 +1,111 @@
+/**
+ * Text-to-Image Feature Hook
+ * Provider-agnostic hook for text-to-image generation
+ */
+
+import { useState, useCallback } from "react";
+import { executeTextToImage } from "../../infrastructure/services";
+import type {
+  TextToImageFeatureState,
+  TextToImageFeatureConfig,
+  TextToImageResult,
+  TextToImageOptions,
+} from "../../domain/types";
+
+export interface UseTextToImageFeatureProps {
+  config: TextToImageFeatureConfig;
+  userId: string;
+}
+
+export interface UseTextToImageFeatureReturn {
+  state: TextToImageFeatureState;
+  setPrompt: (prompt: string) => void;
+  generate: (options?: TextToImageOptions) => Promise<TextToImageResult>;
+  reset: () => void;
+  isReady: boolean;
+}
+
+const initialState: TextToImageFeatureState = {
+  prompt: "",
+  imageUrl: null,
+  imageUrls: [],
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useTextToImageFeature(
+  props: UseTextToImageFeatureProps,
+): UseTextToImageFeatureReturn {
+  const { config, userId } = props;
+  const [state, setState] = useState<TextToImageFeatureState>(initialState);
+
+  const setPrompt = useCallback(
+    (prompt: string) => {
+      setState((prev) => ({ ...prev, prompt, error: null }));
+      config.onPromptChange?.(prompt);
+    },
+    [config],
+  );
+
+  const generate = useCallback(
+    async (options?: TextToImageOptions): Promise<TextToImageResult> => {
+      if (!state.prompt) {
+        const error = "Prompt is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({
+        ...prev,
+        isProcessing: true,
+        progress: 0,
+        error: null,
+      }));
+
+      config.onProcessingStart?.();
+
+      const result = await executeTextToImage(
+        { prompt: state.prompt, userId, options },
+        {
+          model: config.model,
+          buildInput: config.buildInput,
+          extractResult: config.extractResult,
+          onProgress: (progress) => {
+            setState((prev) => ({ ...prev, progress }));
+          },
+        },
+      );
+
+      if (result.success && result.imageUrl) {
+        setState((prev) => ({
+          ...prev,
+          imageUrl: result.imageUrl ?? null,
+          imageUrls: result.imageUrls ?? [],
+          isProcessing: false,
+          progress: 100,
+        }));
+      } else {
+        const error = result.error || "Generation failed";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error,
+        }));
+        config.onError?.(error);
+      }
+
+      config.onProcessingComplete?.(result);
+      return result;
+    },
+    [state.prompt, userId, config],
+  );
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  const isReady = state.prompt.length > 0 && !state.isProcessing;
+
+  return { state, setPrompt, generate, reset, isReady };
+}

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

@@ -0,0 +1 @@
+export * from "./hooks";

package/src/features/text-to-video/domain/index.ts

@@ -0,0 +1 @@
+export * from "./types";

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

@@ -0,0 +1,10 @@
+export type {
+  TextToVideoOptions,
+  TextToVideoRequest,
+  TextToVideoResult,
+  TextToVideoFeatureState,
+  TextToVideoTranslations,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
+  TextToVideoFeatureConfig,
+} from "./text-to-video.types";

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

@@ -0,0 +1,65 @@
+/**
+ * Text-to-Video Feature Types
+ * Request, Result, Config types for text-to-video generation
+ */
+
+export interface TextToVideoOptions {
+  duration?: number;
+  fps?: number;
+  guidanceScale?: number;
+  aspectRatio?: "16:9" | "9:16" | "1:1";
+}
+
+export interface TextToVideoRequest {
+  prompt: string;
+  userId: string;
+  negativePrompt?: string;
+  options?: TextToVideoOptions;
+}
+
+export interface TextToVideoResult {
+  success: boolean;
+  videoUrl?: string;
+  thumbnailUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface TextToVideoFeatureState {
+  prompt: string;
+  videoUrl: string | null;
+  thumbnailUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface TextToVideoTranslations {
+  promptPlaceholder: string;
+  generateButtonText: string;
+  processingText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export type TextToVideoInputBuilder = (
+  prompt: string,
+  options?: TextToVideoOptions,
+) => Record<string, unknown>;
+
+export type TextToVideoResultExtractor = (
+  result: unknown,
+) => { videoUrl?: string; thumbnailUrl?: string } | undefined;
+
+export interface TextToVideoFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: TextToVideoInputBuilder;
+  extractResult?: TextToVideoResultExtractor;
+  onPromptChange?: (prompt: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: TextToVideoResult) => void;
+  onError?: (error: string) => void;
+}

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

@@ -1 +1,27 @@
-export * from './domain/entities';
+/**
+ * Text-to-Video Feature
+ * Provider-agnostic text-to-video generation feature
+ */
+
+// Domain Types
+export type {
+  TextToVideoOptions,
+  TextToVideoRequest,
+  TextToVideoResult,
+  TextToVideoFeatureState,
+  TextToVideoTranslations,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
+  TextToVideoFeatureConfig,
+} from "./domain";
+
+// Infrastructure Services
+export { executeTextToVideo, hasTextToVideoSupport } from "./infrastructure";
+export type { ExecuteTextToVideoOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useTextToVideoFeature } from "./presentation";
+export type {
+  UseTextToVideoFeatureProps,
+  UseTextToVideoFeatureReturn,
+} from "./presentation";

package/src/features/text-to-video/infrastructure/index.ts

@@ -0,0 +1 @@
+export * from "./services";

package/src/features/text-to-video/infrastructure/services/index.ts

@@ -0,0 +1,5 @@
+export {
+  executeTextToVideo,
+  hasTextToVideoSupport,
+} from "./text-to-video-executor";
+export type { ExecuteTextToVideoOptions } from "./text-to-video-executor";

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

@@ -0,0 +1,108 @@
+/**
+ * Text-to-Video Executor
+ * Provider-agnostic text-to-video execution using active AI provider
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import type {
+  TextToVideoRequest,
+  TextToVideoResult,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteTextToVideoOptions {
+  model: string;
+  buildInput: TextToVideoInputBuilder;
+  extractResult?: TextToVideoResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+function defaultExtractResult(
+  result: unknown,
+): { videoUrl?: string; thumbnailUrl?: string } | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.video === "string") {
+    return { videoUrl: r.video };
+  }
+
+  if (r.video && typeof r.video === "object") {
+    const video = r.video as Record<string, unknown>;
+    if (typeof video.url === "string") {
+      return {
+        videoUrl: video.url,
+        thumbnailUrl:
+          typeof r.thumbnail === "string" ? r.thumbnail : undefined,
+      };
+    }
+  }
+
+  return undefined;
+}
+
+export async function executeTextToVideo(
+  request: TextToVideoRequest,
+  options: ExecuteTextToVideoOptions,
+): Promise<TextToVideoResult> {
+  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.prompt) {
+    return { success: false, error: "Prompt is required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[TextToVideo] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const input = buildInput(request.prompt, request.options);
+    onProgress?.(20);
+
+    const result = await provider.run(model, input);
+    onProgress?.(90);
+
+    const extractor = extractResult || defaultExtractResult;
+    const extracted = extractor(result);
+    onProgress?.(100);
+
+    if (!extracted?.videoUrl) {
+      return { success: false, error: "No video in response" };
+    }
+
+    return {
+      success: true,
+      videoUrl: extracted.videoUrl,
+      thumbnailUrl: extracted.thumbnailUrl,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[TextToVideo] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+export function hasTextToVideoSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

package/src/features/text-to-video/presentation/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useTextToVideoFeature } from "./useTextToVideoFeature";
+export type {
+  UseTextToVideoFeatureProps,
+  UseTextToVideoFeatureReturn,
+} from "./useTextToVideoFeature";

package/src/features/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -0,0 +1,111 @@
+/**
+ * Text-to-Video Feature Hook
+ * Provider-agnostic hook for text-to-video generation
+ */
+
+import { useState, useCallback } from "react";
+import { executeTextToVideo } from "../../infrastructure/services";
+import type {
+  TextToVideoFeatureState,
+  TextToVideoFeatureConfig,
+  TextToVideoResult,
+  TextToVideoOptions,
+} from "../../domain/types";
+
+export interface UseTextToVideoFeatureProps {
+  config: TextToVideoFeatureConfig;
+  userId: string;
+}
+
+export interface UseTextToVideoFeatureReturn {
+  state: TextToVideoFeatureState;
+  setPrompt: (prompt: string) => void;
+  generate: (options?: TextToVideoOptions) => Promise<TextToVideoResult>;
+  reset: () => void;
+  isReady: boolean;
+}
+
+const initialState: TextToVideoFeatureState = {
+  prompt: "",
+  videoUrl: null,
+  thumbnailUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useTextToVideoFeature(
+  props: UseTextToVideoFeatureProps,
+): UseTextToVideoFeatureReturn {
+  const { config, userId } = props;
+  const [state, setState] = useState<TextToVideoFeatureState>(initialState);
+
+  const setPrompt = useCallback(
+    (prompt: string) => {
+      setState((prev) => ({ ...prev, prompt, error: null }));
+      config.onPromptChange?.(prompt);
+    },
+    [config],
+  );
+
+  const generate = useCallback(
+    async (options?: TextToVideoOptions): Promise<TextToVideoResult> => {
+      if (!state.prompt) {
+        const error = "Prompt is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({
+        ...prev,
+        isProcessing: true,
+        progress: 0,
+        error: null,
+      }));
+
+      config.onProcessingStart?.();
+
+      const result = await executeTextToVideo(
+        { prompt: state.prompt, userId, options },
+        {
+          model: config.model,
+          buildInput: config.buildInput,
+          extractResult: config.extractResult,
+          onProgress: (progress) => {
+            setState((prev) => ({ ...prev, progress }));
+          },
+        },
+      );
+
+      if (result.success && result.videoUrl) {
+        setState((prev) => ({
+          ...prev,
+          videoUrl: result.videoUrl ?? null,
+          thumbnailUrl: result.thumbnailUrl ?? null,
+          isProcessing: false,
+          progress: 100,
+        }));
+      } else {
+        const error = result.error || "Generation failed";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error,
+        }));
+        config.onError?.(error);
+      }
+
+      config.onProcessingComplete?.(result);
+      return result;
+    },
+    [state.prompt, userId, config],
+  );
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  const isReady = state.prompt.length > 0 && !state.isProcessing;
+
+  return { state, setPrompt, generate, reset, isReady };
+}

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

@@ -0,0 +1 @@
+export * from "./hooks";

package/src/features/text-to-voice/domain/index.ts

@@ -0,0 +1 @@
+export * from "./types";

package/src/features/text-to-voice/domain/types/index.ts

@@ -0,0 +1,10 @@
+export type {
+  TextToVoiceOptions,
+  TextToVoiceRequest,
+  TextToVoiceResult,
+  TextToVoiceFeatureState,
+  TextToVoiceTranslations,
+  TextToVoiceInputBuilder,
+  TextToVoiceResultExtractor,
+  TextToVoiceFeatureConfig,
+} from "./text-to-voice.types";

package/src/features/text-to-voice/domain/types/text-to-voice.types.ts

@@ -0,0 +1,65 @@
+/**
+ * Text-to-Voice Feature Types
+ * Request, Result, Config types for text-to-voice generation
+ */
+
+export interface TextToVoiceOptions {
+  voice?: string;
+  speed?: number;
+  pitch?: number;
+  stability?: number;
+  similarityBoost?: number;
+}
+
+export interface TextToVoiceRequest {
+  text: string;
+  userId: string;
+  options?: TextToVoiceOptions;
+}
+
+export interface TextToVoiceResult {
+  success: boolean;
+  audioUrl?: string;
+  error?: string;
+  requestId?: string;
+  duration?: number;
+}
+
+export interface TextToVoiceFeatureState {
+  text: string;
+  audioUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface TextToVoiceTranslations {
+  textPlaceholder: string;
+  generateButtonText: string;
+  processingText: string;
+  successText: string;
+  playButtonText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export type TextToVoiceInputBuilder = (
+  text: string,
+  options?: TextToVoiceOptions,
+) => Record<string, unknown>;
+
+export type TextToVoiceResultExtractor = (
+  result: unknown,
+) => { audioUrl?: string; duration?: number } | undefined;
+
+export interface TextToVoiceFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: TextToVoiceInputBuilder;
+  extractResult?: TextToVoiceResultExtractor;
+  onTextChange?: (text: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: TextToVoiceResult) => void;
+  onError?: (error: string) => void;
+}

package/src/features/text-to-voice/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Text-to-Voice Feature
+ * Provider-agnostic text-to-voice generation feature
+ */
+
+// Domain Types
+export type {
+  TextToVoiceOptions,
+  TextToVoiceRequest,
+  TextToVoiceResult,
+  TextToVoiceFeatureState,
+  TextToVoiceTranslations,
+  TextToVoiceInputBuilder,
+  TextToVoiceResultExtractor,
+  TextToVoiceFeatureConfig,
+} from "./domain";
+
+// Infrastructure Services
+export { executeTextToVoice, hasTextToVoiceSupport } from "./infrastructure";
+export type { ExecuteTextToVoiceOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useTextToVoiceFeature } from "./presentation";
+export type {
+  UseTextToVoiceFeatureProps,
+  UseTextToVoiceFeatureReturn,
+} from "./presentation";

package/src/features/text-to-voice/infrastructure/index.ts

@@ -0,0 +1 @@
+export * from "./services";