@umituz/react-native-ai-generation-content 1.26.63 → 1.26.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.63",
+  "version": "1.26.65",
   "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/image-generation.strategy.ts

@@ -14,6 +14,7 @@ import {
   DEFAULT_STYLE_VALUE,
   MODEL_INPUT_DEFAULTS,
 } from "./wizard-strategy.constants";
+import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
 
 declare const __DEV__: boolean;
 
@@ -86,7 +87,15 @@ async function executeImageGeneration(
       return { success: false, error: "At least one image required" };
     }
 
-    const enhancedPrompt = `Create a photorealistic image featuring the exact two people from the provided photos. Use the person from @image1 and the person from @image2 exactly as they appear in the reference images - maintain their facial features, expressions, and identity. ${input.prompt}. Professional photography, high quality, detailed, natural lighting, photorealistic rendering.`;
+    // Build face preservation prompt dynamically based on number of people
+    const enhancedPrompt = buildFacePreservationPrompt({
+      scenarioPrompt: input.prompt,
+      personCount: imageUrls.length,
+    });
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ImageStrategy] Face preservation prompt for", imageUrls.length, "person(s)");
+    }
 
     const modelInput = {
       image_urls: imageUrls,

package/src/domains/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -26,6 +26,7 @@ import type { Creation } from "../../../../creations/domain/entities/Creation";
 import { useResultActions } from "../../../../result-preview/presentation/hooks/useResultActions";
 import { validateScenario } from "../utilities/validateScenario";
 import { WizardStepRenderer } from "./WizardStepRenderer";
+import { StarRatingPicker } from "../../../../result-preview/presentation/components/StarRatingPicker";
 
 export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
@@ -37,6 +38,7 @@ export interface GenericWizardFlowProps {
   readonly onGenerationComplete?: (result: unknown) => void;
   readonly onGenerationError?: (error: string) => void;
   readonly onCreditsExhausted?: () => void;
+  readonly onRate?: (creationId: string, rating: number, description: string) => Promise<boolean>;
   readonly onBack?: () => void;
   readonly onTryAgain?: () => void;
   readonly t: (key: string) => string;
@@ -56,6 +58,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   onGenerationComplete,
   onGenerationError,
   onCreditsExhausted,
+  onRate,
   onBack,
   onTryAgain,
   t,
@@ -66,6 +69,8 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
 }) => {
   const tokens = useAppDesignTokens();
   const [currentCreation, setCurrentCreation] = useState<Creation | null>(null);
+  const [showRatingPicker, setShowRatingPicker] = useState(false);
+  const [hasRated, setHasRated] = useState(false);
   const prevStepIdRef = useRef<string | undefined>(undefined);
 
   const flowSteps = useMemo<StepDefinition[]>(() => {
@@ -155,6 +160,21 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
     nextStep();
   }, [currentStepIndex, flowSteps.length, customData, setCustomData, nextStep, onGenerationStart]);
 
+  const handleOpenRatingPicker = useCallback(() => {
+    setShowRatingPicker(true);
+  }, []);
+
+  const handleSubmitRating = useCallback(async (rating: number, description: string) => {
+    if (!currentCreation?.id || !onRate) return;
+    const success = await onRate(currentCreation.id, rating, description);
+    if (success) {
+      setHasRated(true);
+    }
+    setShowRatingPicker(false);
+  }, [currentCreation, onRate]);
+
+  const showRatingButton = Boolean(onRate) && !hasRated;
+
   return (
     <View style={[styles.container, { backgroundColor: tokens.colors.backgroundPrimary }]}>
       <WizardStepRenderer
@@ -165,17 +185,28 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
         generationResult={generationResult}
         isSaving={isSaving}
         isSharing={isSharing}
+        showRating={showRatingButton}
         onNext={nextStep}
         onBack={handleBack}
         onPhotoContinue={handlePhotoContinue}
         onDownload={handleDownload}
         onShare={handleShare}
+        onRate={handleOpenRatingPicker}
         onTryAgain={onTryAgain}
         t={t}
         renderPreview={renderPreview}
         renderGenerating={renderGenerating}
         renderResult={renderResult}
       />
+      <StarRatingPicker
+        visible={showRatingPicker}
+        onClose={() => setShowRatingPicker(false)}
+        onRate={handleSubmitRating}
+        title={t("result.rateTitle")}
+        submitLabel={t("common.submit")}
+        cancelLabel={t("common.cancel")}
+        descriptionPlaceholder={t("result.feedbackPlaceholder")}
+      />
     </View>
   );
 };

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.tsx

@@ -18,11 +18,13 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
   generationResult,
   isSaving,
   isSharing,
+  showRating = true,
   onNext,
   onBack,
   onPhotoContinue,
   onDownload,
   onShare,
+  onRate,
   onTryAgain,
   t,
   renderPreview,
@@ -77,11 +79,13 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
           isSharing={isSharing}
           onDownload={onDownload}
           onShare={onShare}
+          onRate={onRate}
           onTryAgain={handleTryAgain}
           onNavigateBack={handleTryAgain}
           hideLabel
           iconOnly
           showTryAgain
+          showRating={showRating}
           translations={{
             title: t("generation.result.title"),
             saveButton: t("generation.result.save"),

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.types.ts

@@ -10,11 +10,13 @@ export interface WizardStepRendererProps {
   readonly generationResult: unknown;
   readonly isSaving: boolean;
   readonly isSharing: boolean;
+  readonly showRating?: boolean;
   readonly onNext: () => void;
   readonly onBack: () => void;
   readonly onPhotoContinue: (stepId: string, image: UploadedImage) => void;
   readonly onDownload: () => void;
   readonly onShare: () => void;
+  readonly onRate?: () => void;
   readonly onTryAgain?: () => void;
   readonly t: (key: string) => string;
   readonly renderPreview?: (onContinue: () => void) => React.ReactElement | null;

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

@@ -12,15 +12,26 @@
 /**
  * Core identity preservation instruction
  * This is the foundation for maintaining facial consistency
+ * Updated with stricter rules based on AI image generation best practices
  */
-export const IDENTITY_PRESERVATION_CORE = `CRITICAL IDENTITY PRESERVATION:
+export const IDENTITY_PRESERVATION_CORE = `CRITICAL IDENTITY PRESERVATION (HIGHEST PRIORITY):
 {
-  "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."
+  "policy": "PRESERVE 100% IDENTICAL FACIAL APPEARANCE FROM INPUT",
+  "mandatory_rules": [
+    "The face must be EXACTLY as it appears in the reference photo - 100% identical",
+    "Preserve every facial detail: bone structure, eye shape, eye color, nose shape, lip shape",
+    "Maintain natural skin texture with pores, marks, and realistic details",
+    "Keep the person instantly recognizable - any deviation is NOT acceptable"
+  ],
+  "forbidden_modifications": [
+    "Do NOT change face shape or facial proportions",
+    "Do NOT alter eye color, eye shape, or eye spacing",
+    "Do NOT modify nose shape, size, or position",
+    "Do NOT change lip shape, thickness, or natural expression",
+    "Do NOT alter skin tone or smooth skin texture",
+    "Do NOT remove natural features like freckles, moles, or wrinkles"
+  ],
+  "verification": "Before output: confirm face matches reference photo with 100% accuracy"
 }`;
 
 /**
@@ -162,29 +173,47 @@ ${existingPrompt}`;
 };
 
 /**
- * Couple/duo specific prompt enhancement
- * Ensures both people maintain their identities
+ * Multi-person identity preservation rules
+ * Ensures all people maintain their identities with strict rules
+ * Supports any number of people (1, 2, 3, N)
  */
-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"
-}`;
+export const MULTI_PERSON_PRESERVATION_RULES = {
+  requirement: "ALL individuals must have 100% identical facial appearance to their reference photos",
+  perPersonRule: "Use EXACTLY the person from @imageN - preserve 100% identical facial features",
+  forbidden: [
+    "Do NOT swap, mix, or blend facial features between people",
+    "Do NOT idealize or beautify any face",
+    "Do NOT alter facial proportions or characteristics",
+  ],
+  positioning: "Natural positioning, all looking at camera with natural expressions",
+} as const;
 
 /**
- * Creates a couple-specific prompt
- * 
- * @param scenarioPrompt - The scenario description for the couple
- * @returns Complete couple-optimized prompt
+ * Creates a multi-person prompt dynamically
+ *
+ * @param scenarioPrompt - The scenario description
+ * @param personCount - Number of people (1, 2, 3, N)
+ * @returns Complete prompt with identity preservation for all people
  */
-export const createCouplePrompt = (scenarioPrompt: string): string => {
+export const createMultiPersonPrompt = (
+  scenarioPrompt: string,
+  personCount: number,
+): string => {
+  const personRefs = Array.from({ length: personCount }, (_, i) =>
+    `Person ${i + 1}: @image${i + 1} - preserve 100% facial identity`
+  ).join("\n  ");
+
   return `${IDENTITY_PRESERVATION_CORE}
 
-${COUPLE_IDENTITY_PRESERVATION}
+MULTI-PERSON IDENTITY PRESERVATION (${personCount} people):
+{
+  "requirement": "${MULTI_PERSON_PRESERVATION_RULES.requirement}",
+  "references": [
+    ${personRefs}
+  ],
+  "forbidden": ${JSON.stringify(MULTI_PERSON_PRESERVATION_RULES.forbidden)},
+  "positioning": "${MULTI_PERSON_PRESERVATION_RULES.positioning}"
+}
 
 ${PHOTOREALISTIC_RENDERING}
 

package/src/domains/prompts/index.ts

@@ -84,15 +84,21 @@ export type { IdentitySegment, AnimeStyleSegment, QualitySegment } from './domai
 export { ImagePromptBuilder, createAnimeSelfiePrompt, createStyleTransferPrompt } from './infrastructure/services/ImagePromptBuilder';
 export type { ImagePromptResult, ImagePromptBuilderOptions, AnimeSelfiePromptResult } from './infrastructure/services/ImagePromptBuilder';
 
-export { 
-  IDENTITY_PRESERVATION_CORE, 
-  PHOTOREALISTIC_RENDERING, 
-  NATURAL_POSE_GUIDELINES, 
+export {
+  IDENTITY_PRESERVATION_CORE,
+  PHOTOREALISTIC_RENDERING,
+  NATURAL_POSE_GUIDELINES,
   MASTER_BASE_PROMPT,
-  COUPLE_IDENTITY_PRESERVATION,
+  MULTI_PERSON_PRESERVATION_RULES,
   createEnhancedPrompt,
   createTransformationPrompt,
   enhanceExistingPrompt,
-  createCouplePrompt
+  createMultiPersonPrompt,
 } from './domain/entities/BasePromptStructure';
 export type { CreatePromptOptions } from './domain/entities/BasePromptStructure';
+
+export {
+  buildFacePreservationPrompt,
+  buildMinimalFacePreservationPrompt,
+} from './infrastructure/builders/face-preservation-builder';
+export type { FacePreservationOptions } from './infrastructure/builders/face-preservation-builder';

package/src/domains/prompts/infrastructure/builders/face-preservation-builder.ts

@@ -0,0 +1,114 @@
+/**
+ * Face Preservation Prompt Builder
+ * Dynamic prompt builder for AI image generation with strict face identity preservation
+ * Supports any number of people (1, 2, 3, N)
+ *
+ * Based on best practices:
+ * - Face identity lock techniques
+ * - @imageN reference anchors
+ * - Explicit preservation and negative constraints
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface FacePreservationOptions {
+  /** The scenario/scene description */
+  scenarioPrompt: string;
+  /** Number of people in the generation */
+  personCount: number;
+  /** Optional custom preservation rules from main app */
+  customRules?: string[];
+  /** Optional custom forbidden actions from main app */
+  customForbidden?: string[];
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const FACE_LOCK_RULES = [
+  "Face identity locked - exact facial structure must be preserved",
+  "Same jawline, eye shape, eye color, nose, lips, skin tone",
+  "No facial morphing, no face swap, no face modification",
+  "Identity consistency enabled - high facial similarity required",
+] as const;
+
+const FORBIDDEN_ACTIONS = [
+  "Do NOT generate a new face",
+  "Do NOT modify facial structure or proportions",
+  "Do NOT alter skin tone, texture, or natural marks",
+  "Do NOT smooth skin or remove natural features",
+  "Do NOT change eye color or shape",
+] as const;
+
+// =============================================================================
+// Builder Functions
+// =============================================================================
+
+/**
+ * Generate person reference instructions for N people
+ */
+function buildPersonReferences(count: number): string {
+  if (count === 1) {
+    return "Use @image1 as the ONLY reference. The face must remain 100% identical to this image.";
+  }
+
+  const refs = Array.from({ length: count }, (_, i) => {
+    const num = i + 1;
+    return `Person ${num}: Use @image${num} - preserve 100% identical facial appearance`;
+  });
+
+  return refs.join("\n");
+}
+
+/**
+ * Build face preservation prompt dynamically
+ * Supports any number of people (1, 2, 3, N)
+ */
+export function buildFacePreservationPrompt(options: FacePreservationOptions): string {
+  const { scenarioPrompt, personCount, customRules, customForbidden } = options;
+
+  const rules = [...FACE_LOCK_RULES, ...(customRules ?? [])];
+  const forbidden = [...FORBIDDEN_ACTIONS, ...(customForbidden ?? [])];
+
+  const personRefs = buildPersonReferences(personCount);
+  const personWord = personCount === 1 ? "person" : "people";
+
+  return `CRITICAL FACE PRESERVATION: Create a photorealistic image of EXACTLY the ${personCount} ${personWord} from the provided reference photo${personCount > 1 ? "s" : ""}.
+
+REFERENCE IMAGES:
+${personRefs}
+
+FACE LOCK RULES:
+${rules.map((r) => `- ${r}`).join("\n")}
+
+FORBIDDEN:
+${forbidden.map((f) => `- ${f}`).join("\n")}
+
+SCENARIO:
+${scenarioPrompt}
+
+OUTPUT REQUIREMENTS:
+- Photorealistic photograph quality (professional DSLR)
+- Natural expressions and poses
+- High resolution, detailed textures
+- Each person's face must be 100% identical to their reference photo
+
+FINAL VERIFICATION: Before output, confirm all faces match reference images exactly.`;
+}
+
+/**
+ * Build a minimal face preservation prompt (for API character limits)
+ */
+export function buildMinimalFacePreservationPrompt(options: FacePreservationOptions): string {
+  const { scenarioPrompt, personCount } = options;
+  const personRefs = buildPersonReferences(personCount);
+
+  return `FACE IDENTITY LOCK: ${personCount} person(s) from reference photos.
+${personRefs}
+RULES: Preserve 100% facial identity, no modifications.
+SCENARIO: ${scenarioPrompt}
+OUTPUT: Photorealistic, faces identical to references.`;
+}