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

package/package.json

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

package/src/domains/creations/presentation/components/CreationsHomeCard.tsx

@@ -34,7 +34,7 @@ export function CreationsHomeCard({
 }: CreationsHomeCardProps) {
   const tokens = useAppDesignTokens();
 
-  // eslint-disable-next-line no-console
+   
   if (__DEV__) {
     // eslint-disable-next-line no-console
     console.log("[CreationsHomeCard] Render:", {

package/src/domains/creations/presentation/hooks/useAdvancedFilter.ts

@@ -10,7 +10,6 @@ import {
   MEDIA_FILTER_OPTIONS,
   STATUS_FILTER_OPTIONS,
   calculateCreationStats,
-  getTypesForCategory,
   isTypeInCategory,
 } from "../../domain/types";
 import type { CreationCategory, CreationStatus, CreationTypeId } from "../../domain/types";

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -55,7 +55,7 @@ function CreationsGalleryScreenContent({
   repository,
   config,
   t,
-  locale = "en-US",
+  locale: _locale = "en-US",
   enableEditing = false,
   onImageEdit,
   onEmptyAction,
@@ -196,13 +196,16 @@ function CreationsGalleryScreenContent({
     >
       {/* Main Content Grid - handles empty/loading via ListEmptyComponent */}
       <CreationsGrid
-        creations={filtered as any}
+        creations={filtered}
         isLoading={isLoading}
         onRefresh={() => void refetch()}
-        onPress={handleView}
-        onShare={async (creation) => handleShare(creation as any)}
-        onDelete={(creation) => handleDelete(creation as any)}
-        onFavorite={(creation) => handleFavorite(creation as any, !(creation as any).isFavorite)}
+        onPress={(creation) => handleView(creation as Creation)}
+        onShare={async (creation) => handleShare(creation as Creation)}
+        onDelete={(creation) => handleDelete(creation as Creation)}
+        onFavorite={(creation) => {
+          const c = creation as Creation;
+          handleFavorite(c, !c.isFavorite);
+        }}
         contentContainerStyle={{ paddingBottom: tokens.spacing.xl }}
         ListEmptyComponent={renderEmptyComponent}
       />

package/src/domains/face-detection/infrastructure/validators/faceValidator.ts

@@ -32,7 +32,7 @@ export const parseDetectionResponse = (
       confidence: Number(parsed.confidence) || 0,
       message: String(parsed.reason || ""),
     };
-  } catch (error) {
+  } catch {
     return createFailedResult("Failed to parse response");
   }
 };

package/src/domains/prompts/infrastructure/services/PromptGenerationService.ts

@@ -17,7 +17,7 @@ export class PromptGenerationService implements IPromptGenerationService {
 
         const generatedText = this.replaceTemplateVariables(template.template, variables);
         resolve({ success: true, data: generatedText });
-      } catch (error) {
+      } catch {
         resolve({
           success: false,
           error: 'GENERATION_FAILED',

package/src/domains/prompts/presentation/hooks/useFaceSwap.ts

@@ -62,7 +62,7 @@ export const useFaceSwap = (
       };
 
       setResult(generationResult);
-    } catch (error) {
+    } catch {
       setError('An unexpected error occurred');
     }
   }, [faceSwapService, historyRepository, setError, setResult, clearError]);
@@ -70,7 +70,7 @@ export const useFaceSwap = (
   const getAvailableStyles = useCallback(async (): Promise<string[]> => {
     try {
       return await faceSwapService.getAvailableStyles();
-    } catch (error) {
+    } catch {
       setError('Failed to load available styles');
       return [];
     }

package/src/domains/prompts/presentation/hooks/usePromptGeneration.ts

@@ -70,7 +70,7 @@ export const usePromptGeneration = (
         setGeneratedPrompt(newPrompt);
 
         void loadHistory(50);
-      } catch (error) {
+      } catch {
         setError('An unexpected error occurred');
       }
     },
@@ -87,7 +87,7 @@ export const usePromptGeneration = (
         } else {
           setError(('message' in result && result.message) || 'Failed to load history');
         }
-      } catch (error) {
+      } catch {
         setError('Failed to load history');
       }
     },
@@ -99,7 +99,7 @@ export const usePromptGeneration = (
     try {
       await historyRepository.clear();
       setHistory([]);
-    } catch (error) {
+    } catch {
       setError('Failed to clear history');
     }
   }, [historyRepository, setHistory, setError, clearError]);
@@ -110,7 +110,7 @@ export const usePromptGeneration = (
       try {
         await historyRepository.save(prompt);
         void loadHistory(50);
-      } catch (error) {
+      } catch {
         setError('Failed to save to history');
       }
     },

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * Image-to-Video Feature Types
+ * Request, Result, Config types for image-to-video generation
+ */
+
+export interface ImageToVideoOptions {
+  duration?: number;
+  motionStrength?: number;
+  aspectRatio?: "16:9" | "9:16" | "1:1";
+  fps?: number;
+}
+
+export interface ImageToVideoRequest {
+  imageUri: string;
+  imageBase64?: string;
+  userId: string;
+  motionPrompt?: string;
+  options?: ImageToVideoOptions;
+}
+
+export interface ImageToVideoResult {
+  success: boolean;
+  videoUrl?: string;
+  thumbnailUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface ImageToVideoFeatureState {
+  imageUri: string | null;
+  motionPrompt: string;
+  videoUrl: string | null;
+  thumbnailUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface ImageToVideoTranslations {
+  uploadTitle: string;
+  uploadSubtitle: string;
+  motionPromptPlaceholder: string;
+  generateButtonText: string;
+  processingText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export type ImageToVideoInputBuilder = (
+  imageBase64: string,
+  motionPrompt?: string,
+  options?: ImageToVideoOptions,
+) => Record<string, unknown>;
+
+export type ImageToVideoResultExtractor = (
+  result: unknown,
+) => { videoUrl?: string; thumbnailUrl?: string } | undefined;
+
+export interface ImageToVideoFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: ImageToVideoInputBuilder;
+  extractResult?: ImageToVideoResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: ImageToVideoResult) => void;
+  onError?: (error: string) => void;
+}

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

@@ -0,0 +1,10 @@
+export type {
+  ImageToVideoOptions,
+  ImageToVideoRequest,
+  ImageToVideoResult,
+  ImageToVideoFeatureState,
+  ImageToVideoTranslations,
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+  ImageToVideoFeatureConfig,
+} from "./image-to-video.types";

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

@@ -0,0 +1,27 @@
+/**
+ * Image-to-Video Feature
+ * Provider-agnostic image-to-video generation feature
+ */
+
+// Domain Types
+export type {
+  ImageToVideoOptions,
+  ImageToVideoRequest,
+  ImageToVideoResult,
+  ImageToVideoFeatureState,
+  ImageToVideoTranslations,
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+  ImageToVideoFeatureConfig,
+} from "./domain";
+
+// Infrastructure Services
+export { executeImageToVideo, hasImageToVideoSupport } from "./infrastructure";
+export type { ExecuteImageToVideoOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useImageToVideoFeature } from "./presentation";
+export type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+} from "./presentation";

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

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

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

@@ -0,0 +1,112 @@
+/**
+ * Image-to-Video Executor
+ * Provider-agnostic image-to-video execution using active AI provider
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import { cleanBase64 } from "../../../../infrastructure/utils";
+import type {
+  ImageToVideoRequest,
+  ImageToVideoResult,
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteImageToVideoOptions {
+  model: string;
+  buildInput: ImageToVideoInputBuilder;
+  extractResult?: ImageToVideoResultExtractor;
+  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 executeImageToVideo(
+  request: ImageToVideoRequest,
+  options: ExecuteImageToVideoOptions,
+): Promise<ImageToVideoResult> {
+  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.imageBase64) {
+    return { success: false, error: "Image base64 is required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[ImageToVideo] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const imageBase64 = cleanBase64(request.imageBase64);
+    onProgress?.(30);
+
+    const input = buildInput(imageBase64, request.motionPrompt, request.options);
+    onProgress?.(40);
+
+    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("[ImageToVideo] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+export function hasImageToVideoSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

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

@@ -0,0 +1,5 @@
+export {
+  executeImageToVideo,
+  hasImageToVideoSupport,
+} from "./image-to-video-executor";
+export type { ExecuteImageToVideoOptions } from "./image-to-video-executor";

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

@@ -0,0 +1,5 @@
+export { useImageToVideoFeature } from "./useImageToVideoFeature";
+export type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+} from "./useImageToVideoFeature";

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

@@ -0,0 +1,121 @@
+/**
+ * Image-to-Video Feature Hook
+ * Provider-agnostic hook for image-to-video generation
+ */
+
+import { useState, useCallback } from "react";
+import { executeImageToVideo } from "../../infrastructure/services";
+import type {
+  ImageToVideoFeatureState,
+  ImageToVideoFeatureConfig,
+  ImageToVideoResult,
+  ImageToVideoOptions,
+} from "../../domain/types";
+
+export interface UseImageToVideoFeatureProps {
+  config: ImageToVideoFeatureConfig;
+  userId: string;
+}
+
+export interface UseImageToVideoFeatureReturn {
+  state: ImageToVideoFeatureState;
+  setImageUri: (uri: string) => void;
+  setMotionPrompt: (prompt: string) => void;
+  generate: (options?: ImageToVideoOptions) => Promise<ImageToVideoResult>;
+  reset: () => void;
+  isReady: boolean;
+}
+
+const initialState: ImageToVideoFeatureState = {
+  imageUri: null,
+  motionPrompt: "",
+  videoUrl: null,
+  thumbnailUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useImageToVideoFeature(
+  props: UseImageToVideoFeatureProps,
+): UseImageToVideoFeatureReturn {
+  const { config, userId } = props;
+  const [state, setState] = useState<ImageToVideoFeatureState>(initialState);
+
+  const setImageUri = useCallback(
+    (uri: string) => {
+      setState((prev) => ({ ...prev, imageUri: uri, error: null }));
+      config.onImageSelect?.(uri);
+    },
+    [config],
+  );
+
+  const setMotionPrompt = useCallback((prompt: string) => {
+    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 };
+      }
+
+      setState((prev) => ({
+        ...prev,
+        isProcessing: true,
+        progress: 0,
+        error: null,
+      }));
+
+      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 (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.imageUri, state.motionPrompt, userId, config],
+  );
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  const isReady = state.imageUri !== null && !state.isProcessing;
+
+  return { state, setImageUri, setMotionPrompt, generate, reset, isReady };
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+export type {
+  TextToImageOptions,
+  TextToImageRequest,
+  TextToImageResult,
+  TextToImageFeatureState,
+  TextToImageTranslations,
+  TextToImageInputBuilder,
+  TextToImageResultExtractor,
+  TextToImageFeatureConfig,
+} from "./text-to-image.types";

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

@@ -0,0 +1,66 @@
+/**
+ * Text-to-Image Feature Types
+ * Request, Result, Config types for text-to-image generation
+ */
+
+export interface TextToImageOptions {
+  aspectRatio?: "16:9" | "9:16" | "1:1";
+  size?: "512x512" | "768x768" | "1024x1024" | "1024x1792" | "1792x1024";
+  numImages?: number;
+  guidanceScale?: number;
+  seed?: number;
+}
+
+export interface TextToImageRequest {
+  prompt: string;
+  userId: string;
+  negativePrompt?: string;
+  options?: TextToImageOptions;
+}
+
+export interface TextToImageResult {
+  success: boolean;
+  imageUrl?: string;
+  imageUrls?: string[];
+  error?: string;
+  requestId?: string;
+}
+
+export interface TextToImageFeatureState {
+  prompt: string;
+  imageUrl: string | null;
+  imageUrls: string[];
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface TextToImageTranslations {
+  promptPlaceholder: string;
+  generateButtonText: string;
+  processingText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export type TextToImageInputBuilder = (
+  prompt: string,
+  options?: TextToImageOptions,
+) => Record<string, unknown>;
+
+export type TextToImageResultExtractor = (
+  result: unknown,
+) => { imageUrl?: string; imageUrls?: string[] } | undefined;
+
+export interface TextToImageFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: TextToImageInputBuilder;
+  extractResult?: TextToImageResultExtractor;
+  onPromptChange?: (prompt: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: TextToImageResult) => void;
+  onError?: (error: string) => void;
+}

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

@@ -1 +1,27 @@
-export * from './domain/entities';
+/**
+ * Text-to-Image Feature
+ * Provider-agnostic text-to-image generation feature
+ */
+
+// Domain Types
+export type {
+  TextToImageOptions,
+  TextToImageRequest,
+  TextToImageResult,
+  TextToImageFeatureState,
+  TextToImageTranslations,
+  TextToImageInputBuilder,
+  TextToImageResultExtractor,
+  TextToImageFeatureConfig,
+} from "./domain";
+
+// Infrastructure Services
+export { executeTextToImage, hasTextToImageSupport } from "./infrastructure";
+export type { ExecuteTextToImageOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useTextToImageFeature } from "./presentation";
+export type {
+  UseTextToImageFeatureProps,
+  UseTextToImageFeatureReturn,
+} from "./presentation";

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

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

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

@@ -0,0 +1,5 @@
+export {
+  executeTextToImage,
+  hasTextToImageSupport,
+} from "./text-to-image-executor";
+export type { ExecuteTextToImageOptions } from "./text-to-image-executor";