@umituz/react-native-ai-generation-content 1.27.13 → 1.27.14

package/package.json

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

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

@@ -1,11 +1,15 @@
 /**
  * Image-to-Video Feature Hook
- * Provider-agnostic hook with callbacks integration
+ * Uses centralized useGenerationOrchestrator for consistent auth, credits, and error handling
  */
 
 import { useState, useCallback, useMemo } from "react";
-import { useGenerationExecution } from "./useGenerationExecution";
-import { validateImageToVideoGeneration } from "./useImageToVideoValidation";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
+import { executeImageToVideo } from "../../infrastructure/services";
 import type {
   ImageToVideoFeatureState,
   ImageToVideoFeatureConfig,
@@ -16,7 +20,6 @@ import type {
 
 declare const __DEV__: boolean;
 
-// Initial state (inlined from constants file)
 const INITIAL_STATE: ImageToVideoFeatureState = {
   imageUri: null,
   motionPrompt: "",
@@ -27,7 +30,14 @@ const INITIAL_STATE: ImageToVideoFeatureState = {
   error: null,
 };
 
-// Types (inlined from types file)
+const DEFAULT_ALERT_MESSAGES: AlertMessages = {
+  networkError: "No internet connection. Please check your network.",
+  policyViolation: "Content not allowed. Please try again.",
+  saveFailed: "Failed to save. Please try again.",
+  creditFailed: "Credit operation failed. Please try again.",
+  unknown: "An error occurred. Please try again.",
+};
+
 export interface UseImageToVideoFeatureProps {
   config: ImageToVideoFeatureConfig;
   callbacks?: ImageToVideoFeatureCallbacks;
@@ -44,15 +54,99 @@ export interface UseImageToVideoFeatureReturn {
   canGenerate: boolean;
 }
 
+interface VideoGenerationInput {
+  imageUri: string;
+  imageBase64: string;
+  motionPrompt: string;
+  options?: Omit<ImageToVideoGenerateParams, "imageUri" | "motionPrompt">;
+  creationId: string;
+}
+
+function generateCreationId(): string {
+  return `image-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
 export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
   const { config, callbacks, userId } = props;
   const [state, setState] = useState<ImageToVideoFeatureState>(INITIAL_STATE);
 
-  const executeGeneration = useGenerationExecution({
+  const strategy: GenerationStrategy<VideoGenerationInput, ImageToVideoResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[ImageToVideo] Executing generation, creationId:", input.creationId);
+        }
+
+        config.onProcessingStart?.();
+
+        callbacks?.onGenerationStart?.({
+          creationId: input.creationId,
+          type: "image-to-video",
+          imageUri: input.imageUri,
+          metadata: input.options as Record<string, unknown> | undefined,
+        }).catch(() => {});
+
+        const result = await executeImageToVideo(
+          {
+            imageUri: input.imageUri,
+            imageBase64: input.imageBase64,
+            userId,
+            motionPrompt: input.motionPrompt || undefined,
+            options: input.options,
+          },
+          {
+            model: config.model,
+            buildInput: config.buildInput,
+            extractResult: config.extractResult,
+            onProgress: (progress) => {
+              setState((prev) => ({ ...prev, progress }));
+              onProgress?.(progress);
+              callbacks?.onProgress?.(progress);
+            },
+          },
+        );
+
+        if (!result.success || !result.videoUrl) {
+          throw new Error(result.error || "Generation failed");
+        }
+
+        setState((prev) => ({
+          ...prev,
+          videoUrl: result.videoUrl ?? null,
+          thumbnailUrl: result.thumbnailUrl ?? null,
+        }));
+
+        return result;
+      },
+      getCreditCost: () => config.creditCost ?? 0,
+      save: async (result) => {
+        if (result.success && result.videoUrl && state.imageUri) {
+          await callbacks?.onCreationSave?.({
+            creationId: generateCreationId(),
+            type: "image-to-video",
+            videoUrl: result.videoUrl,
+            thumbnailUrl: result.thumbnailUrl,
+            imageUri: state.imageUri,
+          });
+        }
+      },
+    }),
+    [config, callbacks, userId, state.imageUri],
+  );
+
+  const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
-    config,
-    callbacks,
-    setState,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks?.onShowPaywall?.(config.creditCost ?? 0),
+    onSuccess: (result) => {
+      const videoResult = result as ImageToVideoResult;
+      callbacks?.onGenerate?.(videoResult);
+      config.onProcessingComplete?.(videoResult);
+    },
+    onError: (err) => {
+      callbacks?.onError?.(err.message);
+      config.onError?.(err.message);
+    },
   });
 
   const setImageUri = useCallback(
@@ -77,23 +171,40 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
         console.log("[ImageToVideoFeature] generate called, hasImage:", !!effectiveImageUri);
       }
 
+      if (!effectiveImageUri) {
+        const error = "Image is required";
+        setState((prev) => ({ ...prev, error }));
+        callbacks?.onError?.(error);
+        return { success: false, error };
+      }
+
       if (paramImageUri) {
         setState((prev) => ({ ...prev, imageUri: paramImageUri }));
       }
 
-      const validation = await validateImageToVideoGeneration(
-        effectiveImageUri,
-        callbacks,
-        config.creditCost,
-      );
-
-      if (!validation.shouldProceed) {
-        return validation;
+      setState((prev) => ({ ...prev, isProcessing: true, error: null, progress: 0 }));
+
+      try {
+        const imageBase64 = await config.prepareImage(effectiveImageUri);
+
+        const input: VideoGenerationInput = {
+          imageUri: effectiveImageUri,
+          imageBase64,
+          motionPrompt: effectiveMotionPrompt,
+          options,
+          creationId: generateCreationId(),
+        };
+
+        await orchestrator.generate(input);
+        setState((prev) => ({ ...prev, isProcessing: false }));
+        return { success: true, videoUrl: state.videoUrl || undefined };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Generation failed";
+        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
+        return { success: false, error: message };
       }
-
-      return executeGeneration(effectiveImageUri!, effectiveMotionPrompt, options);
     },
-    [state.imageUri, state.motionPrompt, callbacks, config.creditCost, executeGeneration],
+    [state.imageUri, state.motionPrompt, state.videoUrl, config, callbacks, orchestrator],
   );
 
   const reset = useCallback(() => {

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

@@ -83,13 +83,6 @@ export type {
   UseTextToImageFormReturn,
 } from "./presentation";
 
-// Provider-based Feature Hook
-export { useTextToImageFeature } from "./presentation";
-export type {
-  UseTextToImageFeatureProps,
-  UseTextToImageFeatureReturn,
-} from "./presentation";
-
 // =============================================================================
 // PRESENTATION LAYER - Components
 // =============================================================================

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

@@ -21,10 +21,3 @@ export type {
   UseTextToImageFormOptions,
   UseTextToImageFormReturn,
 } from "./useTextToImageForm";
-
-// Provider-based Feature Hook
-export { useTextToImageFeature } from "./useTextToImageFeature";
-export type {
-  UseTextToImageFeatureProps,
-  UseTextToImageFeatureReturn,
-} from "./useTextToImageFeature";

package/src/infrastructure/utils/feature-utils.ts

@@ -3,14 +3,9 @@
  * Uses ONLY configured app services - no alternatives
  */
 
-import * as FileSystem from "expo-file-system";
+import { readFileAsBase64 } from "@umituz/react-native-design-system";
 import { getAuthService, getCreditService, getPaywallService, isAppServicesConfigured } from "../config/app-services.config";
 
-async function readFileAsBase64(uri: string): Promise<string> {
-  const base64 = await FileSystem.readAsStringAsync(uri, { encoding: "base64" });
-  return `data:image/jpeg;base64,${base64}`;
-}
-
 declare const __DEV__: boolean;
 
 export type ImageSelector = () => Promise<string | null>;

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

@@ -1,143 +0,0 @@
-/**
- * useGenerationExecution Hook
- * Handles the core generation execution logic for image-to-video
- */
-
-import { useCallback } from "react";
-import { executeImageToVideo } from "../../infrastructure/services";
-import type {
-  ImageToVideoFeatureConfig,
-  ImageToVideoFeatureCallbacks,
-  ImageToVideoResult,
-  ImageToVideoGenerateParams,
-  ImageToVideoFeatureState,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-interface UseGenerationExecutionParams {
-  userId: string;
-  config: ImageToVideoFeatureConfig;
-  callbacks?: ImageToVideoFeatureCallbacks;
-  setState: React.Dispatch<React.SetStateAction<ImageToVideoFeatureState>>;
-}
-
-export function useGenerationExecution({
-  userId,
-  config,
-  callbacks,
-  setState,
-}: UseGenerationExecutionParams) {
-  return useCallback(
-    async (
-      imageUri: string,
-      motionPrompt: string,
-      options?: Omit<ImageToVideoGenerateParams, "imageUri" | "motionPrompt">,
-    ): Promise<ImageToVideoResult> => {
-      const creationId = `image-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-
-      setState((prev) => ({
-        ...prev,
-        imageUri,
-        isProcessing: true,
-        progress: 0,
-        error: null,
-      }));
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] Starting generation, creationId:", creationId);
-      }
-
-      config.onProcessingStart?.();
-
-      if (callbacks?.onGenerationStart) {
-        callbacks.onGenerationStart({
-          creationId,
-          type: "image-to-video",
-          imageUri,
-          metadata: options as Record<string, unknown> | undefined,
-        }).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[ImageToVideoFeature] onGenerationStart failed:", err);
-          }
-        });
-      }
-
-      try {
-        const imageBase64 = await config.prepareImage(imageUri);
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[ImageToVideoFeature] Image prepared, calling executeImageToVideo");
-        }
-
-        const result = await executeImageToVideo(
-          {
-            imageUri,
-            imageBase64,
-            userId,
-            motionPrompt: motionPrompt || undefined,
-            options,
-          },
-          {
-            model: config.model,
-            buildInput: config.buildInput,
-            extractResult: config.extractResult,
-            onProgress: (progress) => {
-              setState((prev) => ({ ...prev, progress }));
-              callbacks?.onProgress?.(progress);
-            },
-          },
-        );
-
-        if (result.success && result.videoUrl) {
-          setState((prev) => ({
-            ...prev,
-            videoUrl: result.videoUrl ?? null,
-            thumbnailUrl: result.thumbnailUrl ?? null,
-            isProcessing: false,
-            progress: 100,
-          }));
-
-          if (callbacks?.onCreditDeduct && config.creditCost) {
-            await callbacks.onCreditDeduct(config.creditCost);
-          }
-
-          if (callbacks?.onCreationSave) {
-            await callbacks.onCreationSave({
-              creationId,
-              type: "image-to-video",
-              videoUrl: result.videoUrl,
-              thumbnailUrl: result.thumbnailUrl,
-              imageUri,
-              metadata: options as Record<string, unknown> | undefined,
-            });
-          }
-
-          callbacks?.onGenerate?.(result);
-        } else {
-          const error = result.error || "Generation failed";
-          setState((prev) => ({ ...prev, isProcessing: false, error }));
-          config.onError?.(error);
-          callbacks?.onError?.(error);
-        }
-
-        config.onProcessingComplete?.(result);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ImageToVideoFeature] Generation error:", errorMessage);
-        }
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          error: errorMessage,
-        }));
-        config.onError?.(errorMessage);
-        callbacks?.onError?.(errorMessage);
-        return { success: false, error: errorMessage };
-      }
-    },
-    [userId, config, callbacks],
-  );
-}

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

@@ -1,46 +0,0 @@
-/**
- * Image-to-Video Validation Utilities
- */
-
-import type { ImageToVideoFeatureCallbacks, ImageToVideoResult } from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface ValidationResult extends ImageToVideoResult {
-  shouldProceed: boolean;
-}
-
-export async function validateImageToVideoGeneration(
-  effectiveImageUri: string | null,
-  callbacks?: ImageToVideoFeatureCallbacks,
-  creditCost?: number,
-): Promise<ValidationResult> {
-  if (!effectiveImageUri) {
-    const error = "Image is required";
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageToVideoFeature] Generate failed: Image is required");
-    }
-    callbacks?.onError?.(error);
-    return { success: false, error, shouldProceed: false };
-  }
-
-  if (callbacks?.onAuthCheck && !callbacks.onAuthCheck()) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageToVideoFeature] Generate failed: Authentication required");
-    }
-    return { success: false, error: "Authentication required", shouldProceed: false };
-  }
-
-  if (callbacks?.onCreditCheck && creditCost) {
-    const hasCredits = await callbacks.onCreditCheck(creditCost);
-    if (!hasCredits) {
-      callbacks?.onShowPaywall?.(creditCost);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] Generate failed: Insufficient credits");
-      }
-      return { success: false, error: "Insufficient credits", shouldProceed: false };
-    }
-  }
-
-  return { success: true, shouldProceed: true };
-}

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

@@ -1,111 +0,0 @@
-/**
- * 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 };
-}