@umituz/react-native-ai-generation-content 1.20.37 → 1.20.39

package/package.json

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

package/src/domains/prompts/domain/entities/BasePromptStructure.ts

@@ -0,0 +1,195 @@
+/**
+ * Base Prompt Structure for AI Image Generation
+ * Optimized for character identity preservation and photorealistic output
+ * 
+ * This module provides core prompt building blocks that ensure:
+ * - Strict facial identity preservation
+ * - High-quality photorealistic rendering
+ * - Consistent character appearance across generations
+ * - Professional photography standards
+ */
+
+/**
+ * Core identity preservation instruction
+ * This is the foundation for maintaining facial consistency
+ */
+export const IDENTITY_PRESERVATION_CORE = `CRITICAL IDENTITY PRESERVATION:
+{
+  "policy": "MAINTAIN EXACT FACIAL IDENTITY FROM INPUT",
+  "rule_1": "Perfect facial identity preservation - the output MUST depict the EXACT SAME PERSON from the input photo.",
+  "rule_2": "Preserve all unique facial features: bone structure, eye shape, nose, mouth, facial proportions.",
+  "rule_3": "Maintain natural skin texture with pores and realistic details.",
+  "rule_4": "Keep the person's recognizable identity while adapting to the scenario context.",
+  "rule_5": "NEVER alter core facial characteristics that define the person's identity."
+}`;
+
+/**
+ * Photorealistic rendering instruction
+ * Ensures high-quality, professional photography output
+ */
+export const PHOTOREALISTIC_RENDERING = `PHOTOREALISTIC RENDERING REQUIREMENTS:
+{
+  "style": "HIGH-END PHOTOREALISTIC PHOTOGRAPH",
+  "quality": "8k resolution, ultra-detailed textures, professional photography",
+  "lighting": "Cinematic lighting with natural shadows and highlights",
+  "camera": "Shot on professional DSLR camera (Canon EOS R5, Sony A7R V, or equivalent)",
+  "lens": "Professional lens with appropriate focal length (35mm, 50mm, 85mm)",
+  "prohibited": "STRICTLY NO anime, cartoons, illustrations, sketches, 3D renders, or non-photorealistic styles",
+  "output": "Must look like a real photograph taken by a professional photographer"
+}`;
+
+/**
+ * Character pose and framing guidelines
+ * Prevents absurd poses and ensures natural positioning
+ */
+export const NATURAL_POSE_GUIDELINES = `NATURAL POSE AND FRAMING:
+{
+  "framing": "Medium-shot cinematic portrait (waist-up or full-body as appropriate)",
+  "pose": "Natural, relaxed pose - standing, sitting, or contextually appropriate position",
+  "eye_contact": "Looking directly at the camera with natural expression",
+  "body_language": "Confident, natural body language without exaggerated or awkward positions",
+  "interaction": "If multiple people: standing side-by-side, close together, or naturally interacting",
+  "avoid": "NO absurd poses, unnatural contortions, or physically impossible positions"
+}`;
+
+/**
+ * Complete base prompt combining all core elements
+ */
+export const MASTER_BASE_PROMPT = `${IDENTITY_PRESERVATION_CORE}
+
+${PHOTOREALISTIC_RENDERING}
+
+${NATURAL_POSE_GUIDELINES}`;
+
+/**
+ * Creates a complete AI prompt with identity preservation
+ * 
+ * @param scenarioPrompt - The specific scenario description
+ * @param options - Optional customization
+ * @returns Complete AI-ready prompt
+ */
+export interface CreatePromptOptions {
+  /** Include identity preservation instructions (default: true) */
+  includeIdentityPreservation?: boolean;
+  /** Include photorealistic rendering instructions (default: true) */
+  includePhotoRealism?: boolean;
+  /** Include natural pose guidelines (default: true) */
+  includePoseGuidelines?: boolean;
+  /** Additional custom instructions */
+  customInstructions?: string;
+}
+
+export const createEnhancedPrompt = (
+  scenarioPrompt: string,
+  options: CreatePromptOptions = {}
+): string => {
+  const {
+    includeIdentityPreservation = true,
+    includePhotoRealism = true,
+    includePoseGuidelines = true,
+    customInstructions,
+  } = options;
+
+  const parts: string[] = [];
+
+  if (includeIdentityPreservation) {
+    parts.push(IDENTITY_PRESERVATION_CORE);
+  }
+
+  if (includePhotoRealism) {
+    parts.push(PHOTOREALISTIC_RENDERING);
+  }
+
+  if (includePoseGuidelines) {
+    parts.push(NATURAL_POSE_GUIDELINES);
+  }
+
+  if (customInstructions) {
+    parts.push(customInstructions);
+  }
+
+  parts.push(`\nSCENARIO DESCRIPTION:\n${scenarioPrompt}`);
+
+  return parts.join('\n\n');
+};
+
+/**
+ * Creates a transformation prompt for costume/style changes
+ * Maintains identity while changing appearance
+ * 
+ * @param styleName - Name of the target style/theme
+ * @param costume - Costume/clothing description
+ * @param background - Background/environment description
+ * @returns Complete transformation prompt
+ */
+export const createTransformationPrompt = (
+  styleName: string,
+  costume: string,
+  background: string,
+): string => `
+${IDENTITY_PRESERVATION_CORE}
+
+${PHOTOREALISTIC_RENDERING}
+
+TRANSFORMATION REQUEST:
+{
+  "target_theme": "${styleName}",
+  "modifications": {
+    "clothing_update": "${costume.replace(/\n/g, ' ').trim()}",
+    "environment_update": "${background.replace(/\n/g, ' ').trim()}"
+  },
+  "visual_constraints": {
+    "style_matching": "Render as a premium DSLR photograph",
+    "face_preservation": "Maintain 100% identity of the person",
+    "lighting": "Realistic professional studio or outdoor cinematic lighting",
+    "pose": "Natural, contextually appropriate pose"
+  }
+}
+
+FINAL COMMAND: Transform the input person into a strictly photorealistic ${styleName}. The result MUST be a real-life looking person in high-quality ${styleName} attire, maintaining perfect facial identity.`;
+
+/**
+ * Simplified prompt for scenarios that already include detailed instructions
+ * Adds only the essential identity preservation layer
+ * 
+ * @param existingPrompt - The existing detailed prompt
+ * @returns Enhanced prompt with identity preservation
+ */
+export const enhanceExistingPrompt = (existingPrompt: string): string => {
+  return `${IDENTITY_PRESERVATION_CORE}
+
+${existingPrompt}`;
+};
+
+/**
+ * Couple/duo specific prompt enhancement
+ * Ensures both people maintain their identities
+ */
+export const COUPLE_IDENTITY_PRESERVATION = `COUPLE IDENTITY PRESERVATION:
+{
+  "requirement": "Both individuals must maintain their exact facial identities",
+  "person_a": "Perfect preservation of first person's facial features and identity",
+  "person_b": "Perfect preservation of second person's facial features and identity",
+  "interaction": "Natural, loving interaction between the two people",
+  "positioning": "Standing side-by-side, close together, or in contextually appropriate positions",
+  "eye_contact": "Both looking at the camera with natural expressions"
+}`;
+
+/**
+ * Creates a couple-specific prompt
+ * 
+ * @param scenarioPrompt - The scenario description for the couple
+ * @returns Complete couple-optimized prompt
+ */
+export const createCouplePrompt = (scenarioPrompt: string): string => {
+  return `${IDENTITY_PRESERVATION_CORE}
+
+${COUPLE_IDENTITY_PRESERVATION}
+
+${PHOTOREALISTIC_RENDERING}
+
+${NATURAL_POSE_GUIDELINES}
+
+SCENARIO DESCRIPTION:
+${scenarioPrompt}`;
+};

package/src/domains/prompts/index.ts

@@ -91,3 +91,16 @@ export type { ImagePromptResult, ImagePromptBuilderOptions, AnimeSelfiePromptRes
 
 export { DEFAULT_TEXT_TO_IMAGE_PROMPTS, DEFAULT_TEXT_TO_VOICE_PROMPTS } from './domain/entities/sample-prompts';
 export type { PromptSuggestion } from './domain/entities/sample-prompts';
+
+export { 
+  IDENTITY_PRESERVATION_CORE, 
+  PHOTOREALISTIC_RENDERING, 
+  NATURAL_POSE_GUIDELINES, 
+  MASTER_BASE_PROMPT,
+  COUPLE_IDENTITY_PRESERVATION,
+  createEnhancedPrompt,
+  createTransformationPrompt,
+  enhanceExistingPrompt,
+  createCouplePrompt
+} from './domain/entities/BasePromptStructure';
+export type { CreatePromptOptions } from './domain/entities/BasePromptStructure';

package/src/features/hd-touch-up/presentation/hooks/useHDTouchUpFeature.ts

@@ -4,7 +4,7 @@
  */
 
 import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
-import type { HDTouchUpFeatureConfig, HDTouchUpResult } from "../../domain/types";
+import type { HDTouchUpFeatureConfig } from "../../domain/types";
 
 export interface UseHDTouchUpFeatureProps {
   config: HDTouchUpFeatureConfig;

package/src/features/photo-restoration/presentation/hooks/usePhotoRestoreFeature.ts

@@ -4,7 +4,7 @@
  */
 
 import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
-import type { PhotoRestoreFeatureConfig, PhotoRestoreResult } from "../../domain/types";
+import type { PhotoRestoreFeatureConfig } from "../../domain/types";
 
 export interface UsePhotoRestoreFeatureProps {
   config: PhotoRestoreFeatureConfig;

package/src/features/remove-background/presentation/hooks/useRemoveBackgroundFeature.ts

@@ -4,7 +4,7 @@
  */
 
 import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
-import type { RemoveBackgroundFeatureConfig, RemoveBackgroundResult } from "../../domain/types";
+import type { RemoveBackgroundFeatureConfig } from "../../domain/types";
 
 export interface UseRemoveBackgroundFeatureProps {
   config: RemoveBackgroundFeatureConfig;

package/src/features/upscaling/presentation/hooks/useUpscaleFeature.ts

@@ -4,7 +4,7 @@
  */
 
 import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
-import type { UpscaleFeatureConfig, UpscaleResult } from "../../domain/types";
+import type { UpscaleFeatureConfig } from "../../domain/types";
 
 export interface UseUpscaleFeatureProps {
   config: UpscaleFeatureConfig;

package/src/presentation/components/AIGenerationConfig.tsx

@@ -4,7 +4,6 @@ import { View, Image, StyleSheet } from "react-native";
 import { AIGenerationHero } from "./AIGenerationHero";
 import { AIGenerationForm } from "./AIGenerationForm";
 import type { AIGenerationFormProps } from "./AIGenerationForm.types";
-import { useAppDesignTokens } from "@umituz/react-native-design-system";
 
 export interface AIGenerationConfigProps extends Omit<AIGenerationFormProps, "isGenerating" | "progress"> {
   readonly heroTitle: string;
@@ -24,8 +23,6 @@ export const AIGenerationConfig: React.FC<AIGenerationConfigProps> = ({
   progress = 0,
   ...formProps
 }) => {
-  const tokens = useAppDesignTokens();
-
   return (
     <View style={styles.container}>
       {heroTitle && (

package/src/presentation/components/flows/AIGenerateWizardFlow.tsx

@@ -61,7 +61,7 @@ export const AIGenerateWizardFlow: React.FC<AIGenerateWizardFlowProps> = ({
         <PartnerStepScreen
           t={t}
           onBack={handleBack}
-          onContinue={(img: any) => {
+          onContinue={(img: { uri: string; previewUrl?: string }) => {
             setStepImage(isStep2 ? 1 : 0, { uri: img.uri, previewUrl: img.previewUrl || img.uri });
             handleNext();
           }}
@@ -184,7 +184,7 @@ export const AIGenerateWizardFlow: React.FC<AIGenerateWizardFlowProps> = ({
               isGenerating={isGenerating}
               progress={progress}
               presets={presets}
-              onPresetPress={handleGenerate as any}
+              onPresetPress={() => { void handleGenerate(); }}
               prompt={prompt}
               onPromptChange={setPrompt}
               styles={styleOptions}

package/src/presentation/components/flows/AIGenerateWizardFlow.types.ts

@@ -33,11 +33,24 @@ export interface AIGenerateWizardTranslations {
   readonly maxFileSize: string;
 }
 
+export interface StyleOption {
+  readonly id: string;
+  readonly label: string;
+  readonly icon?: string;
+}
+
+export interface PresetOption {
+  readonly id: string;
+  readonly label: string;
+  readonly prompt?: string;
+  readonly icon?: string;
+}
+
 export interface AIGenerateWizardFlowProps {
   readonly featureType: string;
   readonly translations: AIGenerateWizardTranslations;
-  readonly styleOptions: any[];
-  readonly presets: any[];
+  readonly styleOptions: StyleOption[];
+  readonly presets: PresetOption[];
   readonly durationOptions: number[];
   readonly onGenerate: (data: {
     prompt: string;

package/src/presentation/components/flows/useAIGenerateWizardFlow.ts

@@ -3,9 +3,16 @@ import { useMemo, useCallback, useEffect } from "react";
 import { useAIGenerateState, AIGenerateStep } from "../../hooks/generation/useAIGenerateState";
 import { getAIFeatureConfig, hasAIFeature } from "../../screens/ai-feature/registry";
 
+interface GenerationData {
+  prompt: string;
+  style: string;
+  duration: number;
+  images: { uri: string; previewUrl?: string }[];
+}
+
 interface UseAIGenerateWizardFlowProps {
   featureType: string;
-  onGenerate: (data: any) => Promise<string | null | void>;
+  onGenerate: (data: GenerationData) => Promise<string | null | void>;
   onBack?: () => void;
 }
 
@@ -15,15 +22,15 @@ export function useAIGenerateWizardFlow({
   onBack: onBackProp,
 }: UseAIGenerateWizardFlowProps) {
   const state = useAIGenerateState();
-  const { 
-    currentStep, setCurrentStep, isGenerating, setIsGenerating, 
-    setProgress, setResult, images, prompt, selectedStyle, 
-    selectedDuration, setStepImage 
+  const {
+    currentStep, setCurrentStep, setIsGenerating,
+    setProgress, setResult, images, prompt, selectedStyle,
+    selectedDuration
   } = state;
 
   const imageCountRequired = useMemo(() => {
     if (!featureType || !hasAIFeature(featureType)) return 0;
-    const config = getAIFeatureConfig(featureType as any);
+    const config = getAIFeatureConfig(featureType as Parameters<typeof getAIFeatureConfig>[0]);
     if (config.mode === "dual" || config.mode === "dual-video") return 2;
     if (config.mode === "single" || config.mode === "single-with-prompt")
       return 1;

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

@@ -70,7 +70,10 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
-  const defaultCredits = useDeductCredit({ userId, onCreditsExhausted }) as any;
+  const defaultCredits = useDeductCredit({ userId, onCreditsExhausted }) as {
+    checkCredits: (amount: number) => Promise<boolean>;
+    deductCredit: (amount: number) => Promise<void>;
+  };
 
   // Use provided credit callbacks or default to useDeductCredit hook
   const checkCredits = credits?.checkCredits ?? defaultCredits.checkCredits;

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

@@ -9,12 +9,25 @@ import { prepareImage } from "../../../infrastructure/utils";
 import type { AIFeatureId } from "../../screens/ai-feature/types";
 import type { ImageFeatureType, VideoFeatureType } from "../../../domain/interfaces";
 
+interface AlertMessages {
+  success?: string;
+  error?: string;
+  network?: string;
+  credits?: string;
+}
+
+interface GenerationError {
+  type: string;
+  message: string;
+  originalError?: Error;
+}
+
 interface FeatureGenerationConfig {
   featureType: AIFeatureId;
   userId?: string;
-  alertMessages: any;
-  onSuccess?: (result: any) => void;
-  onError?: (error: any) => void;
+  alertMessages: AlertMessages;
+  onSuccess?: (result: string) => void;
+  onError?: (error: GenerationError) => void;
   creditCost?: number;
   onCreditsExhausted?: () => void;
 }