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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.27.13",
+  "version": "1.27.15",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -38,8 +38,7 @@
     "url": "git+https://github.com/umituz/react-native-ai-generation-content.git"
   },
   "dependencies": {
-    "@umituz/react-native-auth": "*",
-    "@umituz/react-native-firebase": "*"
+    "@umituz/react-native-auth": "^3.6.25"
   },
   "peerDependencies": {
     "@react-navigation/native": ">=6.0.0",
@@ -68,7 +67,7 @@
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@umituz/react-native-design-system": "^2.9.44",
-    "@umituz/react-native-firebase": "*",
+    "@umituz/react-native-firebase": "^1.13.87",
     "@umituz/react-native-localization": "*",
     "@umituz/react-native-subscription": "*",
     "eslint": "^9.0.0",

package/src/domains/generation/wizard/configs/image-to-video.config.ts

@@ -0,0 +1,39 @@
+/**
+ * Image to Video Wizard Config
+ * Config-driven wizard steps for image-to-video generation
+ */
+
+import type { WizardFeatureConfig } from "../domain/entities/wizard-config.types";
+
+export const IMAGE_TO_VIDEO_WIZARD_CONFIG: WizardFeatureConfig = {
+  id: "image-to-video",
+  name: "Image to Video",
+  steps: [
+    {
+      id: "photo_1",
+      type: "photo_upload",
+      label: "Your Photo",
+      showFaceDetection: false,
+      showPhotoTips: true,
+      required: true,
+    },
+    {
+      id: "motion_prompt",
+      type: "text_input",
+      required: false,
+      placeholderKey: "imageToVideo.motionPromptPlaceholder",
+      maxLength: 200,
+    },
+    {
+      id: "duration",
+      type: "selection",
+      selectionType: "duration",
+      options: [
+        { id: "5s", label: "5 seconds", value: 5 },
+        { id: "10s", label: "10 seconds", value: 10 },
+      ],
+      required: true,
+      defaultValue: "5s",
+    },
+  ],
+};

package/src/domains/generation/wizard/configs/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Wizard Feature Configs
+ * Pre-built configs for common generation features
+ */
+
+export { TEXT_TO_IMAGE_WIZARD_CONFIG } from "./text-to-image.config";
+export { TEXT_TO_VIDEO_WIZARD_CONFIG } from "./text-to-video.config";
+export { IMAGE_TO_VIDEO_WIZARD_CONFIG } from "./image-to-video.config";

package/src/domains/generation/wizard/configs/text-to-image.config.ts

@@ -0,0 +1,29 @@
+/**
+ * Text to Image Wizard Config
+ * Config-driven wizard steps for text-to-image generation
+ */
+
+import type { WizardFeatureConfig } from "../domain/entities/wizard-config.types";
+
+export const TEXT_TO_IMAGE_WIZARD_CONFIG: WizardFeatureConfig = {
+  id: "text-to-image",
+  name: "Text to Image",
+  steps: [
+    {
+      id: "prompt",
+      type: "text_input",
+      required: true,
+      placeholderKey: "textToImage.promptPlaceholder",
+      minLength: 3,
+      maxLength: 1000,
+      multiline: true,
+    },
+    {
+      id: "style",
+      type: "selection",
+      selectionType: "style",
+      options: [],
+      required: false,
+    },
+  ],
+};

package/src/domains/generation/wizard/configs/text-to-video.config.ts

@@ -0,0 +1,33 @@
+/**
+ * Text to Video Wizard Config
+ * Config-driven wizard steps for text-to-video generation
+ */
+
+import type { WizardFeatureConfig } from "../domain/entities/wizard-config.types";
+
+export const TEXT_TO_VIDEO_WIZARD_CONFIG: WizardFeatureConfig = {
+  id: "text-to-video",
+  name: "Text to Video",
+  steps: [
+    {
+      id: "prompt",
+      type: "text_input",
+      required: true,
+      placeholderKey: "textToVideo.promptPlaceholder",
+      minLength: 3,
+      maxLength: 500,
+      multiline: true,
+    },
+    {
+      id: "duration",
+      type: "selection",
+      selectionType: "duration",
+      options: [
+        { id: "5s", label: "5 seconds", value: 5 },
+        { id: "10s", label: "10 seconds", value: 10 },
+      ],
+      required: true,
+      defaultValue: "5s",
+    },
+  ],
+};

package/src/domains/generation/wizard/index.ts

@@ -51,3 +51,6 @@ export type { GenericWizardFlowProps } from "./presentation/components";
 
 // Presentation - Screens
 export { GeneratingScreen } from "./presentation/screens";
+
+// Feature Configs
+export * from "./configs";

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.strategy.ts

@@ -24,10 +24,13 @@ declare const __DEV__: boolean;
 // ============================================================================
 
 export interface ImageGenerationInput {
+  /** Photos are optional for text-to-image */
   readonly photos: readonly string[];
   readonly prompt: string;
   /** Optional interaction style for multi-person images */
   readonly interactionStyle?: InteractionStyle;
+  /** Optional style from wizard selection */
+  readonly style?: string;
 }
 
 export interface ImageGenerationResult {
@@ -40,29 +43,29 @@ export interface ImageGenerationResult {
 
 async function extractPhotosFromWizardData(
   wizardData: Record<string, unknown>,
-): Promise<string[] | null> {
+): Promise<string[]> {
   const photoKeys = Object.keys(wizardData)
     .filter((k) => k.includes(PHOTO_KEY_PREFIX))
     .sort();
 
   if (photoKeys.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[ImageStrategy] No photos found", { keys: Object.keys(wizardData) });
-    }
-    return null;
+    return [];
   }
 
   const photoUris: string[] = [];
   for (const key of photoKeys) {
     const photo = wizardData[key] as { uri?: string };
-    if (!photo?.uri) return null;
-    photoUris.push(photo.uri);
+    if (photo?.uri) {
+      photoUris.push(photo.uri);
+    }
   }
 
-  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  const validPhotos = photosBase64.filter(Boolean) as string[];
+  if (photoUris.length === 0) {
+    return [];
+  }
 
-  return validPhotos.length > 0 ? validPhotos : null;
+  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
+  return photosBase64.filter(Boolean) as string[];
 }
 
 // ============================================================================
@@ -85,43 +88,53 @@ async function executeImageGeneration(
     const formatBase64 = (base64: string): string =>
       base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
 
-    const imageUrls = input.photos.map(formatBase64);
-    if (imageUrls.length === 0) {
-      return { success: false, error: "At least one image required" };
-    }
+    const hasPhotos = input.photos.length > 0;
+    const imageUrls = hasPhotos ? input.photos.map(formatBase64) : [];
 
-    // Build face preservation prompt dynamically based on number of people
-    const facePrompt = buildFacePreservationPrompt({
-      scenarioPrompt: input.prompt,
-      personCount: imageUrls.length,
-    });
+    let finalPrompt = input.prompt;
 
-    // Build interaction style prompt for multi-person images
-    const interactionPrompt = buildInteractionStylePrompt({
-      style: input.interactionStyle ?? "romantic",
-      personCount: imageUrls.length,
-    });
-
-    // Combine prompts: face preservation + interaction style
-    const enhancedPrompt = interactionPrompt
-      ? `${facePrompt}\n\n${interactionPrompt}`
-      : facePrompt;
+    if (hasPhotos) {
+      // Photo-based: Build face preservation prompt
+      const facePrompt = buildFacePreservationPrompt({
+        scenarioPrompt: input.prompt,
+        personCount: imageUrls.length,
+      });
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageStrategy] Prompt built for", imageUrls.length, "person(s)", {
-        interactionStyle: input.interactionStyle ?? "romantic",
+      const interactionPrompt = buildInteractionStylePrompt({
+        style: input.interactionStyle ?? "romantic",
+        personCount: imageUrls.length,
       });
+
+      finalPrompt = interactionPrompt
+        ? `${facePrompt}\n\n${interactionPrompt}`
+        : facePrompt;
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageStrategy] Photo-based generation for", imageUrls.length, "person(s)");
+      }
+    } else {
+      // Text-to-image: Use prompt with optional style
+      if (input.style && input.style !== DEFAULT_STYLE_VALUE) {
+        finalPrompt = `${input.prompt}. Style: ${input.style}`;
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageStrategy] Text-to-image generation");
+      }
     }
 
-    const modelInput = {
-      image_urls: imageUrls,
-      prompt: enhancedPrompt,
+    const modelInput: Record<string, unknown> = {
+      prompt: finalPrompt,
       aspect_ratio: MODEL_INPUT_DEFAULTS.aspectRatio,
       output_format: MODEL_INPUT_DEFAULTS.outputFormat,
       num_images: MODEL_INPUT_DEFAULTS.numImages,
       enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
     };
 
+    if (hasPhotos) {
+      modelInput.image_urls = imageUrls;
+    }
+
     let lastStatus = "";
     const result = await provider.subscribe(model, modelInput, {
       timeoutMs: GENERATION_TIMEOUT_MS,
@@ -151,39 +164,47 @@ export async function buildImageInput(
   scenario: WizardScenarioData,
 ): Promise<ImageGenerationInput | null> {
   const photos = await extractPhotosFromWizardData(wizardData);
-  if (!photos) return null;
 
-  if (!scenario.aiPrompt?.trim()) {
-    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  // Get prompt from wizardData (text_input step) OR scenario.aiPrompt
+  const userPrompt = wizardData.prompt as string | undefined;
+  const prompt = userPrompt?.trim() || scenario.aiPrompt?.trim();
+
+  if (!prompt) {
+    throw new Error("Prompt is required for image generation");
   }
 
-  let prompt = scenario.aiPrompt;
+  // For photo-based generation, apply style enhancements
+  let finalPrompt = prompt;
+  if (photos.length > 0) {
+    const styleEnhancements: string[] = [];
 
-  const styleEnhancements: string[] = [];
+    const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
+    if (romanticMoods?.length) {
+      styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
+    }
 
-  const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
-  if (romanticMoods?.length) {
-    styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
-  }
+    const artStyle = wizardData.selection_art_style as string | undefined;
+    if (artStyle && artStyle !== DEFAULT_STYLE_VALUE) {
+      styleEnhancements.push(`Art style: ${artStyle}`);
+    }
 
-  const artStyle = wizardData.selection_art_style as string | undefined;
-  if (artStyle && artStyle !== DEFAULT_STYLE_VALUE) {
-    styleEnhancements.push(`Art style: ${artStyle}`);
-  }
+    const artist = wizardData.selection_artist_style as string | undefined;
+    if (artist && artist !== DEFAULT_STYLE_VALUE) {
+      styleEnhancements.push(`Artist style: ${artist}`);
+    }
 
-  const artist = wizardData.selection_artist_style as string | undefined;
-  if (artist && artist !== DEFAULT_STYLE_VALUE) {
-    styleEnhancements.push(`Artist style: ${artist}`);
+    if (styleEnhancements.length > 0) {
+      finalPrompt = `${prompt}. ${styleEnhancements.join(", ")}`;
+    }
   }
 
-  if (styleEnhancements.length > 0) {
-    prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
-  }
+  // Get style from wizard selection (for text-to-image)
+  const style = wizardData.style as string | undefined;
 
   // Get interaction style from scenario (default: romantic for couple apps)
   const interactionStyle = (scenario.interactionStyle as InteractionStyle) ?? "romantic";
 
-  return { photos, prompt, interactionStyle };
+  return { photos, prompt: finalPrompt, style, interactionStyle };
 }
 
 // ============================================================================

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -11,16 +11,18 @@ import type { WizardScenarioData } from "../../presentation/hooks/useWizardGener
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { PHOTO_KEY_PREFIX, VIDEO_FEATURE_PATTERNS } from "./wizard-strategy.constants";
 
-declare const __DEV__: boolean;
-
 // ============================================================================
 // Types
 // ============================================================================
 
 export interface VideoGenerationInput {
-  readonly sourceImageBase64: string;
-  readonly targetImageBase64: string;
+  /** Source image (optional for text-to-video) */
+  readonly sourceImageBase64?: string;
+  /** Target image (optional, uses source if not provided) */
+  readonly targetImageBase64?: string;
   readonly prompt: string;
+  /** Video duration in seconds */
+  readonly duration?: number;
 }
 
 export interface VideoGenerationResult {
@@ -33,29 +35,29 @@ export interface VideoGenerationResult {
 
 async function extractPhotosFromWizardData(
   wizardData: Record<string, unknown>,
-): Promise<string[] | null> {
+): Promise<string[]> {
   const photoKeys = Object.keys(wizardData)
     .filter((k) => k.includes(PHOTO_KEY_PREFIX))
     .sort();
 
   if (photoKeys.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[VideoStrategy] No photos found", { keys: Object.keys(wizardData) });
-    }
-    return null;
+    return [];
   }
 
   const photoUris: string[] = [];
   for (const key of photoKeys) {
     const photo = wizardData[key] as { uri?: string };
-    if (!photo?.uri) return null;
-    photoUris.push(photo.uri);
+    if (photo?.uri) {
+      photoUris.push(photo.uri);
+    }
   }
 
-  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  const validPhotos = photosBase64.filter(Boolean) as string[];
+  if (photoUris.length === 0) {
+    return [];
+  }
 
-  return validPhotos.length > 0 ? validPhotos : null;
+  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
+  return photosBase64.filter(Boolean) as string[];
 }
 
 // ============================================================================
@@ -83,16 +85,24 @@ export async function buildVideoInput(
   scenario: WizardScenarioData,
 ): Promise<VideoGenerationInput | null> {
   const photos = await extractPhotosFromWizardData(wizardData);
-  if (!photos || photos.length < 1) return null;
 
-  if (!scenario.aiPrompt?.trim()) {
-    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  // Get prompt from wizardData or scenario
+  const userPrompt = wizardData.prompt as string | undefined;
+  const motionPrompt = wizardData.motion_prompt as string | undefined;
+  const prompt = userPrompt?.trim() || motionPrompt?.trim() || scenario.aiPrompt?.trim();
+
+  if (!prompt) {
+    throw new Error("Prompt is required for video generation");
   }
 
+  // Get duration from wizardData
+  const duration = wizardData.duration as number | undefined;
+
   return {
     sourceImageBase64: photos[0],
     targetImageBase64: photos[1] || photos[0],
-    prompt: scenario.aiPrompt,
+    prompt,
+    duration,
   };
 }
 
@@ -120,8 +130,8 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       const result = await executeVideoFeature(
         videoFeatureType,
         {
-          sourceImageBase64: videoInput.sourceImageBase64,
-          targetImageBase64: videoInput.targetImageBase64,
+          sourceImageBase64: videoInput.sourceImageBase64 || "",
+          targetImageBase64: videoInput.targetImageBase64 || videoInput.sourceImageBase64 || "",
           prompt: videoInput.prompt,
         },
         { onProgress },

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.constants.ts

@@ -29,4 +29,6 @@ export const MODEL_INPUT_DEFAULTS = {
 export const VIDEO_FEATURE_PATTERNS: Record<string, VideoFeatureType> = {
   kiss: "ai-kiss",
   hug: "ai-hug",
+  "text-to-video": "text-to-video",
+  "image-to-video": "image-to-video",
 };

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 };
-}