@umituz/react-native-ai-generation-content 1.26.7 → 1.26.8

package/package.json

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

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

@@ -9,8 +9,6 @@ import type { GenerationStrategy } from "../../../../presentation/hooks/generati
 import type { VideoFeatureType } from "../../../../domain/interfaces";
 import { executeVideoFeature } from "../../../../infrastructure/services/video-feature-executor.service";
 import { createCreationsRepository } from "../../../creations/infrastructure/adapters";
-import { enhanceCouplePrompt } from "../../../../features/couple-future/infrastructure/couplePromptEnhancer";
-import type { CoupleFeatureSelection } from "../../../../features/couple-future/domain/types";
 import type { WizardOutputType, WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 
 declare const __DEV__: boolean;
@@ -179,29 +177,29 @@ async function buildGenerationInput(
 
   // For image generation, enhance prompt with style selections
   if (outputType === "image") {
-    const selections: CoupleFeatureSelection = {};
+    const styleEnhancements: string[] = [];
 
     // Romantic mood (multi-select array)
     const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
     if (romanticMoods && romanticMoods.length > 0) {
-      selections.romanticMoods = romanticMoods;
+      styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
     }
 
     // Art style (single select)
     const artStyle = wizardData.selection_art_style as string | undefined;
     if (artStyle && artStyle !== "original") {
-      selections.artStyle = artStyle;
+      styleEnhancements.push(`Art style: ${artStyle}`);
     }
 
     // Artist style (single select)
     const artist = wizardData.selection_artist_style as string | undefined;
     if (artist && artist !== "original") {
-      selections.artist = artist;
+      styleEnhancements.push(`Artist style: ${artist}`);
     }
 
     // Enhance prompt with selected styles
-    if (Object.keys(selections).length > 0) {
-      prompt = enhanceCouplePrompt(prompt, selections);
+    if (styleEnhancements.length > 0) {
+      prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
     }
 
     return {

package/src/domains/generation/wizard/presentation/hooks/usePhotoUploadState.ts

@@ -7,7 +7,7 @@
 import { useState, useCallback } from "react";
 import * as ImagePicker from "expo-image-picker";
 import { Alert } from "react-native";
-import type { UploadedImage } from "../../../../features/partner-upload/domain/types";
+import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 
 export interface PhotoUploadConfig {
   readonly maxFileSizeMB?: number;

package/src/domains/generation/wizard/presentation/screens/GenericPhotoUploadScreen.tsx

@@ -17,8 +17,7 @@ import {
 } from "@umituz/react-native-design-system";
 import { PhotoUploadCard } from "../../../../presentation/components";
 import { FaceDetectionToggle } from "../../../../domains/face-detection";
-import { PhotoTips } from "../../../../features/partner-upload/presentation/components/PhotoTips";
-import type { UploadedImage } from "../../../../features/partner-upload/domain/types";
+import type { UploadedImage } from "../../../../presentation/hooks/generation/useAIGenerateState";
 import { usePhotoUploadState } from "../hooks/usePhotoUploadState";
 
 export interface PhotoUploadScreenTranslations {
@@ -135,16 +134,6 @@ export const GenericPhotoUploadScreen: React.FC<PhotoUploadScreenProps> = ({
           {translations.subtitle}
         </AtomicText>
 
-        {/* Photo Tips - InfoGrid version */}
-        {showPhotoTips && (
-          <PhotoTips
-            t={t}
-            titleKey="photoUpload.tips.title"
-            headerIcon="bulb"
-            style={{ marginHorizontal: 24, marginBottom: 20 }}
-          />
-        )}
-
         {showFaceDetection && onFaceDetectionToggle && (
           <FaceDetectionToggle
             isEnabled={faceDetectionEnabled}

package/src/domains/generation/wizard/presentation/steps/PhotoUploadStep.tsx

@@ -6,10 +6,8 @@
 
 import React from "react";
 import type { PhotoUploadStepConfig } from "../../domain/entities/wizard-config.types";
-
-// Use wizard domain's generic photo upload screen - NO feature-specific references!
+import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 import { GenericPhotoUploadScreen } from "../screens/GenericPhotoUploadScreen";
-import type { UploadedImage } from "../../../../features/partner-upload/domain/types";
 
 export interface PhotoUploadStepProps {
   readonly config: PhotoUploadStepConfig;

package/src/presentation/hooks/generation/useAIGenerateState.ts

@@ -12,6 +12,9 @@ export interface UploadedImage {
   uri: string;
   previewUrl?: string;
   name?: string;
+  width?: number;
+  height?: number;
+  fileSize?: number;
 }
 
 import { useState, useCallback } from "react";

package/src/presentation/layouts/types/layout-props.ts

@@ -4,10 +4,6 @@
  */
 
 import type { ReactNode } from "react";
-import type {
-  BaseSingleImageHookReturn,
-  BaseDualImageHookReturn,
-} from "../../../features/image-to-image/domain/types";
 import type {
   ModalTranslations,
   BaseLayoutTranslations,
@@ -24,6 +20,36 @@ import type {
   SingleImageWithPromptFeatureState,
 } from "./feature-states";
 
+/**
+ * Base hook return for single image features
+ */
+export interface BaseSingleImageHookReturn {
+  readonly imageUri: string | null;
+  readonly processedUrl: string | null;
+  readonly isProcessing: boolean;
+  readonly progress: number;
+  selectImage(): Promise<void>;
+  process(): Promise<void>;
+  save(): Promise<void>;
+  reset(): void;
+}
+
+/**
+ * Base hook return for dual image features
+ */
+export interface BaseDualImageHookReturn {
+  readonly sourceImageUri: string | null;
+  readonly targetImageUri: string | null;
+  readonly processedUrl: string | null;
+  readonly isProcessing: boolean;
+  readonly progress: number;
+  selectSourceImage(): Promise<void>;
+  selectTargetImage(): Promise<void>;
+  process(): Promise<void>;
+  save(): Promise<void>;
+  reset(): void;
+}
+
 /**
  * Single image feature layout props
  * Note: No modal - shows fullscreen progress when processing (FutureUS pattern)

package/src/presentation/hooks/generation/useAIFeatureGeneration.ts

@@ -1,180 +0,0 @@
-
-import { useCallback } from "react";
-import { useImageGeneration } from "./useImageGeneration";
-import { useVideoGeneration } from "./useVideoGeneration";
-import { executeImageToVideo } from "../../../features/image-to-video";
-import { executeTextToVideo } from "../../../features/text-to-video";
-import { useGenerationOrchestrator } from "./orchestrator";
-import { prepareImage } from "../../../infrastructure/utils";
-import type { AIFeatureId } from "../../screens/ai-feature/types";
-import type { ImageFeatureType, VideoFeatureType } from "../../../domain/interfaces";
-import type { AlertMessages, GenerationError } from "./types";
-
-interface FeatureGenerationConfig {
-  featureType: AIFeatureId;
-  userId?: string;
-  alertMessages: AlertMessages;
-  onSuccess?: (result: string) => void;
-  onError?: (error: GenerationError) => void;
-  creditCost?: number;
-  onCreditsExhausted?: () => void;
-  /** REQUIRED for video features: Video generation model ID from app config */
-  videoModel?: string;
-}
-
-export function useAIFeatureGeneration({
-  featureType,
-  userId,
-  alertMessages,
-  onSuccess,
-  onError,
-  creditCost = 1,
-  onCreditsExhausted,
-  videoModel,
-}: FeatureGenerationConfig) {
-
-  // Hook for standard image features
-  const { generate: generateImage } = useImageGeneration({
-    featureType: featureType as ImageFeatureType,
-    userId,
-    processResult: (imageUrl) => imageUrl,
-    alertMessages,
-    onSuccess,
-    onError,
-    creditCost,
-    onCreditsExhausted,
-  });
-
-  // Hook for standard video features (ai-hug, ai-kiss)
-  const { generate: generateVideo } = useVideoGeneration({
-    featureType: featureType as VideoFeatureType,
-    userId,
-    processResult: (videoUrl) => videoUrl,
-    alertMessages,
-    onSuccess,
-    onError,
-    creditCost,
-    onCreditsExhausted,
-  });
-
-  // Orchestrator for Image-to-Video
-  const { generate: generateImageToVideo } = useGenerationOrchestrator(
-    {
-      execute: async (input: { imageUri: string; prompt: string; duration: number }, onProgress) => {
-        if (!videoModel) {
-          throw new Error(
-            "videoModel is required for image-to-video feature. " +
-            "Please provide videoModel from app's generation config."
-          );
-        }
-
-        const result = await executeImageToVideo(
-          {
-            imageUri: input.imageUri, // Pass URI directly
-            imageBase64: await prepareImage(input.imageUri),
-            motionPrompt: input.prompt,
-            options: { duration: input.duration },
-            userId: userId || "anonymous",
-          },
-          {
-            model: videoModel,
-            buildInput: (image, prompt, opts) => ({
-              image,
-              prompt,
-              ...opts
-            }),
-            onProgress,
-          }
-        );
-        if (!result.success || !result.videoUrl) throw new Error(result.error || "Generation failed");
-        return result.videoUrl;
-      },
-      getCreditCost: () => creditCost,
-    },
-    { userId, alertMessages, onSuccess, onError, onCreditsExhausted }
-  );
-
-  // Orchestrator for Text-to-Video
-  const { generate: generateTextToVideo } = useGenerationOrchestrator(
-    {
-      execute: async (input: { prompt: string; duration: number }, onProgress) => {
-        if (!videoModel) {
-          throw new Error(
-            "videoModel is required for text-to-video feature. " +
-            "Please provide videoModel from app's generation config."
-          );
-        }
-
-        const result = await executeTextToVideo(
-          {
-            prompt: input.prompt,
-            options: { duration: input.duration },
-            userId: userId || "anonymous",
-          },
-          {
-            model: videoModel,
-            buildInput: (prompt, opts) => ({ prompt, ...opts }),
-            onProgress,
-          }
-        );
-        if (!result.success || !result.videoUrl) throw new Error(result.error || "Generation failed");
-        return result.videoUrl;
-      },
-      getCreditCost: () => creditCost,
-    },
-    { userId, alertMessages, onSuccess, onError, onCreditsExhausted }
-  );
-
-  const generate = useCallback(async (data: {
-    prompt: string;
-    style: string;
-    duration: number;
-    images: { uri: string }[];
-  }) => {
-    switch (featureType) {
-      case "image-to-video":
-        if (!data.images[0]?.uri) throw new Error("Image required for image-to-video");
-        return await generateImageToVideo({ 
-          imageUri: data.images[0].uri, 
-          prompt: data.prompt, 
-          duration: data.duration 
-        });
-
-      case "text-to-video":
-        return await generateTextToVideo({ 
-          prompt: data.prompt, 
-          duration: data.duration 
-        });
-
-      case "ai-hug":
-      case "ai-kiss":
-        if (data.images.length < 2) throw new Error("Two images required");
-        return await generateVideo({
-          sourceImageBase64: await prepareImage(data.images[0].uri),
-          targetImageBase64: await prepareImage(data.images[1].uri),
-        });
-
-      default:
-        // Default to Image Generation
-        if (data.images.length > 0) {
-           // Single or dual image
-           if (data.images.length === 2 && (featureType === "face-swap")) {
-              return await generateImage({
-                sourceImageBase64: await prepareImage(data.images[0].uri),
-                targetImageBase64: await prepareImage(data.images[1].uri),
-                options: { style: data.style }
-              });
-           }
-           // Single image features
-           return await generateImage({
-             imageBase64: await prepareImage(data.images[0].uri),
-             prompt: data.prompt,
-             options: { style: data.style }
-           });
-        }
-        throw new Error(`Unsupported feature or missing input: ${featureType}`);
-    }
-  }, [featureType, generateImage, generateVideo, generateImageToVideo, generateTextToVideo]);
-
-  return { generate };
-}