@umituz/react-native-ai-generation-content 1.65.1 → 1.65.2

package/src/domains/image-to-video/domain/types/image-to-video.types.ts

@@ -1,118 +1,28 @@
 /**
- * Image-to-Video Feature Types
+ * Image-to-Video Feature Types - Barrel Export
  * Request, Result, Config types for image-to-video generation
  */
 
-import type { AnimationStyleId } from "./animation.types";
-import type { VideoDuration } from "./duration.types";
-
-export interface ImageToVideoOptions {
-  duration?: number;
-  motionStrength?: number;
-  aspectRatio?: "16:9" | "9:16" | "1:1";
-  fps?: number;
-  animationStyle?: AnimationStyleId;
-}
-
-export interface ImageToVideoGenerateParams extends ImageToVideoOptions {
-  imageUri?: string;
-  motionPrompt?: string;
-}
-
-export interface ImageToVideoRequest {
-  imageUri: string;
-  imageBase64?: string;
-  userId: string;
-  motionPrompt?: string;
-  options?: ImageToVideoOptions;
-  allImages?: string[];
-  animationStyle?: AnimationStyleId;
-  duration?: VideoDuration;
-  model?: string;
-}
-
-export interface ImageToVideoResult {
-  success: boolean;
-  videoUrl?: string;
-  thumbnailUrl?: string;
-  error?: string;
-  requestId?: string;
-}
-
-export interface ImageToVideoGenerationState {
-  isGenerating: boolean;
-  progress: number;
-  error: string | null;
-}
-
-export interface ImageToVideoFeatureState {
-  imageUri: string | null;
-  motionPrompt: string;
-  videoUrl: string | null;
-  thumbnailUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
-}
-
-export interface ImageToVideoTranslations {
-  uploadTitle: string;
-  uploadSubtitle: string;
-  motionPromptPlaceholder: string;
-  generateButtonText: string;
-  processingText: string;
-  successText: string;
-  saveButtonText: string;
-  tryAnotherText: string;
-}
-
-export type ImageToVideoInputBuilder = (
-  imageBase64: string,
-  motionPrompt?: string,
-  options?: ImageToVideoOptions,
-) => Record<string, unknown>;
-
-export type ImageToVideoResultExtractor = (
-  result: unknown,
-) => { videoUrl?: string; thumbnailUrl?: string } | undefined;
-
-export interface ImageToVideoFeatureCallbacks {
-  onCreditCheck?: (cost: number) => Promise<boolean>;
-  onCreditDeduct?: (cost: number) => Promise<void>;
-  onAuthCheck?: () => boolean;
-  onShowPaywall?: (creditCost: number) => void;
-  onGenerationStart?: (data: ImageToVideoGenerationStartData) => Promise<void>;
-  onCreationSave?: (data: ImageToVideoCreationData) => Promise<void>;
-  onGenerate?: (result: ImageToVideoResult) => void;
-  onProgress?: (progress: number) => void;
-  onError?: (error: string) => void;
-}
-
-export interface ImageToVideoGenerationStartData {
-  creationId: string;
-  type: string;
-  imageUri: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface ImageToVideoCreationData {
-  creationId: string;
-  type: string;
-  videoUrl: string;
-  thumbnailUrl?: string;
-  imageUri: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface ImageToVideoFeatureConfig {
-  providerId?: string;
-  creditCost?: number;
-  model: string;
-  buildInput: ImageToVideoInputBuilder;
-  extractResult?: ImageToVideoResultExtractor;
-  prepareImage: (imageUri: string) => Promise<string>;
-  onImageSelect?: (uri: string) => void;
-  onProcessingStart?: () => void;
-  onProcessingComplete?: (result: ImageToVideoResult) => void;
-  onError?: (error: string) => void;
-}
+export type {
+  ImageToVideoOptions,
+  ImageToVideoGenerateParams,
+  ImageToVideoRequest,
+} from "./image-to-video-request.types";
+export type {
+  ImageToVideoResult,
+  ImageToVideoGenerationState,
+} from "./image-to-video-result.types";
+export type {
+  ImageToVideoFeatureState,
+  ImageToVideoTranslations,
+} from "./image-to-video-state.types";
+export type {
+  ImageToVideoGenerationStartData,
+  ImageToVideoCreationData,
+  ImageToVideoFeatureCallbacks,
+} from "./image-to-video-callbacks.types";
+export type {
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+  ImageToVideoFeatureConfig,
+} from "./image-to-video-config.types";

package/src/domains/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -1,6 +1,5 @@
 /**
  * Image-to-Video Executor
- * Provider-agnostic image-to-video execution using Template Method pattern
  */
 
 import { BaseExecutor } from "../../../../infrastructure/executors/base-executor";
@@ -11,48 +10,18 @@ import {
   type ExtractedVideoResult,
 } from "../../../../infrastructure/utils/video-result-extractor.util";
 import type { IAIProvider } from "../../../../domain/interfaces";
-import type {
-  ImageToVideoRequest,
-  ImageToVideoResult,
-  ImageToVideoInputBuilder,
-  ImageToVideoResultExtractor,
-} from "../../domain/types";
+import type { ImageToVideoRequest, ImageToVideoResult } from "../../domain/types";
 import { env } from "../../../../infrastructure/config/env.config";
-
-/**
- * Options for image-to-video execution
- */
-export interface ExecuteImageToVideoOptions {
-  model: string;
-  buildInput: ImageToVideoInputBuilder;
-  extractResult?: ImageToVideoResultExtractor;
-  onProgress?: (progress: number) => void;
-}
-
-/**
- * Map job status to progress percentage
- */
-const getProgressFromJobStatus = (status: string): number => {
-  switch (status.toLowerCase()) {
-    case "queued":
-      return 10;
-    case "in_queue":
-      return 15;
-    case "processing":
-      return 50;
-    case "in_progress":
-      return 60;
-    case "completed":
-      return 100;
-    default:
-      return 30;
-  }
+import type { ExecuteImageToVideoOptions } from "./image-to-video-executor.types";
+
+const STATUS_PROGRESS: Record<string, number> = {
+  queued: 10,
+  in_queue: 15,
+  processing: 50,
+  in_progress: 60,
+  completed: 100,
 };
 
-/**
- * Image-to-Video Executor using Template Method pattern
- * Eliminates code duplication through BaseExecutor
- */
 class ImageToVideoExecutor extends BaseExecutor<
   ImageToVideoRequest,
   ImageToVideoResult,
@@ -62,13 +31,8 @@ class ImageToVideoExecutor extends BaseExecutor<
     super("ImageToVideo");
   }
 
-  protected validateRequest(
-    request: ImageToVideoRequest,
-  ): string | undefined {
-    if (!request.imageBase64) {
-      return "Image base64 is required";
-    }
-    return undefined;
+  protected validateRequest(request: ImageToVideoRequest): string | undefined {
+    return request.imageBase64 ? undefined : "Image base64 is required";
   }
 
   protected async executeProvider(
@@ -79,42 +43,24 @@ class ImageToVideoExecutor extends BaseExecutor<
   ): Promise<unknown> {
     this.logInfo("Starting provider.subscribe()...");
 
-    // Use subscribe for video generation (long-running operation with queue)
-    // Provider reports real progress via onQueueUpdate callback
     const result = await provider.subscribe(model, input, {
       onQueueUpdate: (status: { status: string; queuePosition?: number }) => {
-        this.logInfo(
-          `Queue status: ${status.status}, position: ${status.queuePosition}`,
-        );
-        // Map provider status to progress
-        const progress = getProgressFromJobStatus(status.status);
-        onProgress?.(progress);
+        this.logInfo(`Queue: ${status.status}, pos: ${status.queuePosition}`);
+        onProgress?.(STATUS_PROGRESS[status.status.toLowerCase()] ?? 30);
       },
       timeoutMs: env.generationVideoTimeoutMs,
     });
 
-    this.logInfo(
-      `Subscribe resolved, result keys: ${result ? Object.keys(result as object) : "null"}`,
-    );
-
-    // FAL can return errors with COMPLETED status - check for this
+    this.logInfo(`Complete, keys: ${result ? Object.keys(result as object) : "null"}`);
     checkFalApiError(result);
-
     return result;
   }
 
-  protected validateExtractedResult(
-    extracted: ExtractedVideoResult | undefined,
-  ): string | undefined {
-    if (!extracted?.videoUrl) {
-      return "No video in response";
-    }
-    return undefined;
+  protected validateExtractedResult(extracted: ExtractedVideoResult | undefined): string | undefined {
+    return extracted?.videoUrl ? undefined : "No video in response";
   }
 
-  protected transformResult(
-    extracted: ExtractedVideoResult,
-  ): ImageToVideoResult {
+  protected transformResult(extracted: ExtractedVideoResult): ImageToVideoResult {
     return {
       success: true,
       videoUrl: extracted.videoUrl,
@@ -122,46 +68,27 @@ class ImageToVideoExecutor extends BaseExecutor<
     };
   }
 
-  protected getDefaultExtractor(): (
-    result: unknown,
-  ) => ExtractedVideoResult | undefined {
+  protected getDefaultExtractor(): (result: unknown) => ExtractedVideoResult | undefined {
     return defaultExtractVideoResult;
   }
 }
 
-// Singleton instance
 const executor = new ImageToVideoExecutor();
 
-/**
- * Execute image-to-video generation
- * Public API
- */
 export async function executeImageToVideo(
   request: ImageToVideoRequest,
   options: ExecuteImageToVideoOptions,
 ): Promise<ImageToVideoResult> {
-  const result: Result<ImageToVideoResult, string> = await executor.execute(
-    request,
-    {
-      model: options.model,
-      buildInput: (req) =>
-        options.buildInput(req.imageBase64!, req.motionPrompt, req.options),
-      extractResult: options.extractResult,
-      onProgress: options.onProgress,
-    },
-  );
-
-  // Convert Result<T, E> to return format
-  if (isSuccess(result)) {
-    return result.value;
-  }
-  return { success: false, error: result.error };
+  const result: Result<ImageToVideoResult, string> = await executor.execute(request, {
+    model: options.model,
+    buildInput: (req) => options.buildInput(req.imageBase64!, req.motionPrompt, req.options),
+    extractResult: options.extractResult,
+    onProgress: options.onProgress,
+  });
+
+  return isSuccess(result) ? result.value : { success: false, error: result.error };
 }
 
-/**
- * Check if image-to-video is supported
- * Public API
- */
 export function hasImageToVideoSupport(): boolean {
   return executor.hasSupport();
 }

package/src/domains/image-to-video/infrastructure/services/image-to-video-executor.types.ts

@@ -0,0 +1,15 @@
+/**
+ * Image-to-Video Executor Types
+ */
+
+import type {
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+} from "../../domain/types";
+
+export interface ExecuteImageToVideoOptions {
+  model: string;
+  buildInput: ImageToVideoInputBuilder;
+  extractResult?: ImageToVideoResultExtractor;
+  onProgress?: (progress: number) => void;
+}

package/src/domains/prompts/domain/base/constants.ts

@@ -0,0 +1,47 @@
+/**
+ * Base Prompt Structure Constants
+ * Core prompt building blocks for AI image generation
+ */
+
+export const IDENTITY_PRESERVATION_CORE = `CRITICAL IDENTITY PRESERVATION (HIGHEST PRIORITY):
+{
+  "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",
+    "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 remove natural features like freckles, moles, or wrinkles"
+  ],
+  "verification": "Before output: confirm face matches reference photo with 100% accuracy"
+}`;
+
+export const PHOTOREALISTIC_RENDERING = `PHOTOREALISTIC RENDERING REQUIREMENTS:
+{
+  "style": "PHOTOREALISTIC PHOTOGRAPH",
+  "quality": "high quality, professional photography",
+  "lighting": "Natural lighting with realistic shadows and highlights",
+  "prohibited": "STRICTLY NO anime, cartoons, illustrations, sketches, 3D renders, or non-photorealistic styles",
+  "output": "Must look like a real photograph"
+}`;
+
+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"
+}`;
+
+export const MASTER_BASE_PROMPT = `${IDENTITY_PRESERVATION_CORE}
+
+${PHOTOREALISTIC_RENDERING}
+
+${NATURAL_POSE_GUIDELINES}`;

package/src/domains/prompts/domain/base/creators.ts

@@ -0,0 +1,76 @@
+/**
+ * Base Prompt Creators
+ */
+
+import {
+  IDENTITY_PRESERVATION_CORE,
+  PHOTOREALISTIC_RENDERING,
+  NATURAL_POSE_GUIDELINES,
+} from "./constants";
+import type { CreatePromptOptions } from "./types";
+
+export const createPhotorealisticPrompt = (
+  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');
+};
+
+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 photograph",
+    "face_preservation": "Maintain 100% identity of the person",
+    "lighting": "Realistic professional recording lighting",
+    "pose": "Natural, contextually appropriate pose"
+  }
+}
+
+FINAL COMMAND: Transform the input person into a photorealistic ${styleName}. The result MUST be a real-life looking person in high-quality ${styleName} attire, maintaining perfect facial identity.`;
+
+export const enhanceExistingPrompt = (existingPrompt: string): string => {
+  return `${IDENTITY_PRESERVATION_CORE}
+
+${existingPrompt}`;
+};

package/src/domains/prompts/domain/base/types.ts

@@ -0,0 +1,10 @@
+/**
+ * Base Prompt Structure Types
+ */
+
+export interface CreatePromptOptions {
+  includeIdentityPreservation?: boolean;
+  includePhotoRealism?: boolean;
+  includePoseGuidelines?: boolean;
+  customInstructions?: string;
+}

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

@@ -1,4 +1,4 @@
-import { IDENTITY_PRESERVATION_CORE, NATURAL_POSE_GUIDELINES, PHOTOREALISTIC_RENDERING } from "./BasePromptStructure";
+import { IDENTITY_PRESERVATION_CORE, NATURAL_POSE_GUIDELINES, PHOTOREALISTIC_RENDERING } from "../base/constants";
 
 /**
  * Multi-person identity preservation rules

package/src/domains/prompts/index.ts

@@ -44,11 +44,13 @@ export {
   PHOTOREALISTIC_RENDERING,
   NATURAL_POSE_GUIDELINES,
   MASTER_BASE_PROMPT,
+} from './domain/base/constants';
+export {
   createPhotorealisticPrompt,
   createTransformationPrompt,
   enhanceExistingPrompt,
-} from './domain/entities/BasePromptStructure';
-export type { CreatePromptOptions } from './domain/entities/BasePromptStructure';
+} from './domain/base/creators';
+export type { CreatePromptOptions } from './domain/base/types';
 
 export {
   MULTI_PERSON_PRESERVATION_RULES,

package/src/domains/prompts/infrastructure/services/ImagePromptBuilder.ts

@@ -1,5 +1,5 @@
 /**
- * ImagePromptBuilder - Fluent builder for composing AI image generation prompts
+ * ImagePromptBuilder - Fluent builder for AI image generation prompts
  */
 
 import {
@@ -11,20 +11,7 @@ import {
   ANTI_REALISM_SEGMENTS,
   ANATOMY_NEGATIVE_SEGMENTS,
 } from "../../domain/entities/image-prompt-segments";
-
-export interface ImagePromptResult {
-  prompt: string;
-  negativePrompt: string;
-}
-
-export interface AnimeSelfiePromptResult {
-  prompt: string;
-  guidance_scale: number;
-}
-
-export interface ImagePromptBuilderOptions {
-  separator?: string;
-}
+import type { ImagePromptResult, ImagePromptBuilderOptions } from "./image-prompt-builder.types";
 
 export class ImagePromptBuilder {
   private positiveSegments: string[] = [];
@@ -35,99 +22,63 @@ export class ImagePromptBuilder {
     this.separator = options?.separator ?? ", ";
   }
 
-  /**
-   * Create a new ImagePromptBuilder instance
-   */
   static create(options?: ImagePromptBuilderOptions): ImagePromptBuilder {
     return new ImagePromptBuilder(options);
   }
 
-  /**
-   * Add identity preservation prompts - ensures AI preserves original person's features
-   */
   withIdentityPreservation(): this {
     this.positiveSegments.push(...Object.values(IDENTITY_SEGMENTS));
     this.negativeSegments.push(...Object.values(IDENTITY_NEGATIVE_SEGMENTS));
     return this;
   }
 
-  /**
-   * Add anime style prompts
-   */
   withAnimeStyle(): this {
     this.positiveSegments.push(...Object.values(ANIME_STYLE_SEGMENTS));
     this.negativeSegments.push(...Object.values(ANTI_REALISM_SEGMENTS));
     return this;
   }
 
-  /**
-   * Add quality enhancement prompts
-   */
   withQuality(): this {
     this.positiveSegments.push(...Object.values(QUALITY_SEGMENTS));
     this.negativeSegments.push(...Object.values(QUALITY_NEGATIVE_SEGMENTS));
     return this;
   }
 
-  /**
-   * Add anatomy safety negative prompts
-   */
   withAnatomySafety(): this {
     this.negativeSegments.push(...Object.values(ANATOMY_NEGATIVE_SEGMENTS));
     return this;
   }
 
-  /**
-   * Add anti-realism prompts (for stylized outputs)
-   */
   withAntiRealism(): this {
     this.negativeSegments.push(...Object.values(ANTI_REALISM_SEGMENTS));
     return this;
   }
 
-  /**
-   * Add custom positive segments
-   */
   withSegments(segments: string[]): this {
     this.positiveSegments.push(...segments);
     return this;
   }
 
-  /**
-   * Add custom negative segments
-   */
   withNegativeSegments(segments: string[]): this {
     this.negativeSegments.push(...segments);
     return this;
   }
 
-  /**
-   * Add a single custom segment
-   */
   withSegment(segment: string): this {
     this.positiveSegments.push(segment);
     return this;
   }
 
-  /**
-   * Add a single negative segment
-   */
   withNegativeSegment(segment: string): this {
     this.negativeSegments.push(segment);
     return this;
   }
 
-  /**
-   * Prepend segments (add to beginning)
-   */
   prependSegments(segments: string[]): this {
     this.positiveSegments.unshift(...segments);
     return this;
   }
 
-  /**
-   * Create a new builder extending this one
-   */
   extend(): ImagePromptBuilder {
     const builder = ImagePromptBuilder.create({ separator: this.separator });
     builder.positiveSegments = [...this.positiveSegments];
@@ -135,11 +86,7 @@ export class ImagePromptBuilder {
     return builder;
   }
 
-  /**
-   * Build the final prompt strings
-   */
   build(): ImagePromptResult {
-    // Remove duplicates and filter empty values
     const uniquePositive = [...new Set(this.positiveSegments)].filter(Boolean);
     const uniqueNegative = [...new Set(this.negativeSegments)].filter(Boolean);
 
@@ -148,21 +95,4 @@ export class ImagePromptBuilder {
       negativePrompt: uniqueNegative.join(this.separator),
     };
   }
-
-  /**
-   * Get current positive segments (for debugging)
-   */
-  getPositiveSegments(): string[] {
-    return [...this.positiveSegments];
-  }
-
-  /**
-   * Get current negative segments (for debugging)
-   */
-  getNegativeSegments(): string[] {
-    return [...this.negativeSegments];
-  }
 }
-
-// Re-export prompt creation utilities for backward compatibility
-export { createAnimeSelfiePrompt, createStyleTransferPrompt } from "../utils/prompt-creators.util";

package/src/domains/prompts/infrastructure/services/image-prompt-builder.types.ts

@@ -0,0 +1,17 @@
+/**
+ * Image Prompt Builder Types
+ */
+
+export interface ImagePromptResult {
+  prompt: string;
+  negativePrompt: string;
+}
+
+export interface AnimeSelfiePromptResult {
+  prompt: string;
+  guidance_scale: number;
+}
+
+export interface ImagePromptBuilderOptions {
+  separator?: string;
+}