@umituz/react-native-ai-generation-content 1.37.11 → 1.37.13

package/package.json

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

package/src/domains/creations/presentation/hooks/useGalleryFilters.ts

@@ -7,7 +7,6 @@
 import { useState, useCallback, useMemo } from "react";
 import type { Creation } from "../../domain/entities/Creation";
 import type { FilterOption } from "../../domain/types/creation-filter";
-import type { BackgroundJob } from "../../../../domain/entities/job.types";
 import { useFilter } from "./useFilter";
 import { useCreationsFilter } from "./useCreationsFilter";
 
@@ -16,14 +15,13 @@ interface UseGalleryFiltersProps {
   readonly statusOptions: FilterOption[];
   readonly mediaOptions: FilterOption[];
   readonly t: (key: string) => string;
-  /** Pending background jobs to include in status counts */
-  readonly pendingJobs?: BackgroundJob[];
 }
 
 interface UseGalleryFiltersReturn {
   readonly filtered: Creation[];
   readonly isFiltered: boolean;
   readonly activeFiltersCount: number;
+  readonly processingCount: number;
   readonly statusFilterVisible: boolean;
   readonly mediaFilterVisible: boolean;
   readonly statusFilter: ReturnType<typeof useFilter>;
@@ -40,27 +38,27 @@ export function useGalleryFilters({
   statusOptions,
   mediaOptions,
   t,
-  pendingJobs = [],
 }: UseGalleryFiltersProps): UseGalleryFiltersReturn {
   const [statusFilterVisible, setStatusFilterVisible] = useState(false);
   const [mediaFilterVisible, setMediaFilterVisible] = useState(false);
 
-  // Calculate pending jobs count for status filter
-  const processingJobsCount = useMemo(() => {
-    return pendingJobs.filter(
-      (job) => job.status === "processing" || job.status === "queued",
+  // Calculate processing count from creations status (single source of truth)
+  const processingCount = useMemo(() => {
+    if (!creations) return 0;
+    return creations.filter(
+      (c) => c.status === "processing" || c.status === "queued",
     ).length;
-  }, [pendingJobs]);
+  }, [creations]);
 
   // Enrich status options with dynamic counts
   const enrichedStatusOptions = useMemo(() => {
     return statusOptions.map((option) => {
-      if (option.id === "processing" && processingJobsCount > 0) {
-        return { ...option, count: processingJobsCount };
+      if (option.id === "processing" && processingCount > 0) {
+        return { ...option, count: processingCount };
       }
       return option;
     });
-  }, [statusOptions, processingJobsCount]);
+  }, [statusOptions, processingCount]);
 
   const statusFilter = useFilter({ options: enrichedStatusOptions, t });
   const mediaFilter = useFilter({ options: mediaOptions, t });
@@ -85,6 +83,7 @@ export function useGalleryFilters({
     filtered,
     isFiltered,
     activeFiltersCount,
+    processingCount,
     statusFilterVisible,
     mediaFilterVisible,
     statusFilter,

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -12,7 +12,6 @@ import { useGalleryFilters } from "../hooks/useGalleryFilters";
 import { useGalleryCallbacks } from "../hooks/useGalleryCallbacks";
 import { GalleryHeader, CreationCard, GalleryEmptyStates } from "../components";
 import { GalleryResultPreview } from "../components/GalleryResultPreview";
-import { usePendingJobs } from "../../../../presentation/hooks/use-pending-jobs";
 import { MEDIA_FILTER_OPTIONS, STATUS_FILTER_OPTIONS } from "../../domain/types/creation-filter";
 import { getPreviewUrl } from "../../domain/utils";
 import type { Creation } from "../../domain/entities/Creation";
@@ -30,7 +29,6 @@ export function CreationsGalleryScreen({
   onEmptyAction,
   emptyActionLabel,
   showFilter = config.showFilter ?? true,
-  showPendingJobs = true,
 }: CreationsGalleryScreenProps) {
   const tokens = useAppDesignTokens();
   const [selectedCreation, setSelectedCreation] = useState<Creation | null>(null);
@@ -38,7 +36,6 @@ export function CreationsGalleryScreen({
   const hasAutoSelectedRef = useRef(false);
 
   const { data: creations, isLoading, refetch } = useCreations({ userId, repository });
-  const { jobs: pendingJobs } = usePendingJobs();
   const deleteMutation = useDeleteCreation({ userId, repository });
 
   useEffect(() => {
@@ -68,7 +65,7 @@ export function CreationsGalleryScreen({
   const showStatusFilter = config.filterConfig?.showStatusFilter ?? true;
   const showMediaFilter = config.filterConfig?.showMediaFilter ?? true;
 
-  const filters = useGalleryFilters({ creations, statusOptions, mediaOptions, t, pendingJobs });
+  const filters = useGalleryFilters({ creations, statusOptions, mediaOptions, t });
 
   useAppFocusEffect(useCallback(() => { void refetch(); }, [refetch]));
 
@@ -113,11 +110,6 @@ export function CreationsGalleryScreen({
     />
   ), [callbacks, getScenarioTitle]);
 
-  const activePendingCount = useMemo(() => {
-    if (!showPendingJobs) return 0;
-    return pendingJobs.filter((j) => j.status === "processing" || j.status === "queued").length;
-  }, [showPendingJobs, pendingJobs]);
-
   const renderHeader = useMemo(() => {
     if (!creations?.length && !isLoading) return null;
     return (
@@ -128,12 +120,12 @@ export function CreationsGalleryScreen({
           countLabel={t(config.translations.photoCount)}
           showFilter={showFilter}
           filterButtons={filterButtons}
-          pendingCount={activePendingCount}
+          pendingCount={filters.processingCount}
           pendingLabel={t("creations.processing")}
         />
       </View>
     );
-  }, [creations, isLoading, filters.filtered.length, showFilter, filterButtons, t, config, tokens, activePendingCount]);
+  }, [creations, isLoading, filters.filtered.length, filters.processingCount, showFilter, filterButtons, t, config, tokens]);
 
   const renderEmpty = useMemo(() => (
     <GalleryEmptyStates

package/src/domains/creations/presentation/screens/creations-gallery.types.ts

@@ -14,5 +14,4 @@ export interface CreationsGalleryScreenProps {
   readonly onEmptyAction?: () => void;
   readonly emptyActionLabel?: string;
   readonly showFilter?: boolean;
-  readonly showPendingJobs?: boolean;
 }

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

@@ -3,8 +3,7 @@
  * Handles the actual image generation execution
  */
 
-import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
-import { buildInteractionStylePrompt } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
+import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardImageInput } from "./image-generation.types";
 import {
   GENERATION_TIMEOUT_MS,
@@ -21,31 +20,19 @@ interface ExecutionResult {
   error?: string;
 }
 
-/**
- * Formats base64 string with proper data URI prefix
- */
 function formatBase64(base64: string): string {
   return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
 }
 
-/**
- * Builds the final prompt based on input type (photo-based or text-to-image)
- */
 function buildFinalPrompt(input: WizardImageInput, imageUrls: string[]): string {
   const hasPhotos = imageUrls.length > 0;
 
   if (hasPhotos) {
-    const facePrompt = buildFacePreservationPrompt({
-      scenarioPrompt: input.prompt,
-      personCount: imageUrls.length,
+    return buildUnifiedPrompt({
+      basePrompt: input.prompt,
+      photoCount: imageUrls.length,
+      interactionStyle: input.interactionStyle,
     });
-
-    const interactionPrompt = buildInteractionStylePrompt({
-      style: input.interactionStyle ?? "romantic",
-      personCount: imageUrls.length,
-    });
-
-    return interactionPrompt ? `${facePrompt}\n\n${interactionPrompt}` : facePrompt;
   }
 
   // Text-to-image with optional style
@@ -56,9 +43,6 @@ function buildFinalPrompt(input: WizardImageInput, imageUrls: string[]): string
   return input.prompt;
 }
 
-/**
- * Executes image generation using the AI provider
- */
 export async function executeImageGeneration(
   input: WizardImageInput,
   model: string,

package/src/domains/generation/wizard/infrastructure/strategies/shared/unified-prompt-builder.ts

@@ -0,0 +1,46 @@
+/**
+ * Unified Prompt Builder
+ * Single prompt building logic for ALL generation types (image & video)
+ * Uses MultiPersonPromptStructure for photo-based scenarios
+ * Uses createEnhancedPrompt for text-only scenarios
+ */
+
+import { createMultiPersonPrompt } from "../../../../../prompts/domain/entities/MultiPersonPromptStructure";
+import { createEnhancedPrompt } from "../../../../../prompts/domain/entities/BasePromptStructure";
+
+export interface BuildPromptOptions {
+  /** Base scenario prompt (aiPrompt from scenario config) */
+  readonly basePrompt: string;
+  /** Number of photos/people in generation */
+  readonly photoCount: number;
+  /** Interaction style from scenario (optional - only if scenario specifies it) */
+  readonly interactionStyle?: string;
+}
+
+/**
+ * Build unified prompt for any generation type
+ * - Photo-based: Uses createMultiPersonPrompt with @image1, @image2 references
+ * - Text-only: Uses createEnhancedPrompt with identity preservation
+ */
+export function buildUnifiedPrompt(options: BuildPromptOptions): string {
+  const { basePrompt, photoCount, interactionStyle } = options;
+
+  // Text-only generation (no photos)
+  if (photoCount === 0) {
+    return createEnhancedPrompt(basePrompt, {
+      includeIdentityPreservation: false,
+      includePhotoRealism: true,
+      includePoseGuidelines: true,
+    });
+  }
+
+  // Photo-based generation - use multi-person prompt with @imageN references
+  let finalPrompt = createMultiPersonPrompt(basePrompt, photoCount);
+
+  // Add interaction style if specified by scenario (no defaults)
+  if (interactionStyle) {
+    finalPrompt = `${finalPrompt}\n\nINTERACTION STYLE: ${interactionStyle}`;
+  }
+
+  return finalPrompt;
+}

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

@@ -5,54 +5,20 @@
 
 import { executeVideoFeature } from "../../../../../infrastructure/services/video-feature-executor.service";
 import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
+import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
-import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
 import { extractPrompt, extractDuration, extractAspectRatio, extractResolution } from "../utils";
 import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
 import { getVideoFeatureType } from "./video-generation.utils";
 import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
+import { validatePhotoCount } from "./video-generation.types";
 
 declare const __DEV__: boolean;
 
 export type { WizardVideoInput, WizardVideoResult, CreateVideoStrategyOptions } from "./video-generation.types";
 
-interface PhotoValidationResult {
-  isValid: boolean;
-  errorKey?: string;
-}
-
-function validatePhotoCount(
-  photoCount: number,
-  inputType: ScenarioInputType | undefined,
-): PhotoValidationResult {
-  const effectiveInputType = inputType ?? "single";
-
-  switch (effectiveInputType) {
-    case "dual":
-      if (photoCount < 2) {
-        return {
-          isValid: false,
-          errorKey: "error.generation.dualPhotosRequired",
-        };
-      }
-      break;
-    case "single":
-      if (photoCount < 1) {
-        return {
-          isValid: false,
-          errorKey: "error.generation.photoRequired",
-        };
-      }
-      break;
-    case "text":
-      break;
-  }
-
-  return { isValid: true };
-}
-
 export async function buildVideoInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
@@ -65,61 +31,50 @@ export async function buildVideoInput(
 
   const validation = validatePhotoCount(photos.length, scenario.inputType);
   if (!validation.isValid) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy] Validation failed", {
-        scenarioId: scenario.id,
-        inputType: scenario.inputType,
-        photoCount: photos.length,
-        errorKey: validation.errorKey,
-      });
-    }
     throw new Error(validation.errorKey ?? "error.generation.invalidInput");
   }
 
-  let prompt = extractPrompt(wizardData, scenario.aiPrompt);
+  let basePrompt = extractPrompt(wizardData, scenario.aiPrompt);
 
-  if (!prompt) {
+  if (!basePrompt) {
     const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
-      prompt = defaultPrompt;
+      basePrompt = defaultPrompt;
     } else {
       throw new Error("error.generation.promptRequired");
     }
   }
 
-  const input: WizardVideoInput = {
+  // Build unified prompt with face preservation
+  const finalPrompt = buildUnifiedPrompt({
+    basePrompt,
+    photoCount: photos.length,
+    interactionStyle: scenario.interactionStyle as string | undefined,
+  });
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy] Prompt built", {
+      baseLength: basePrompt.length,
+      finalLength: finalPrompt.length,
+      photoCount: photos.length,
+    });
+  }
+
+  return {
     sourceImageBase64: photos[0],
     targetImageBase64: photos[1] || photos[0],
-    prompt,
+    prompt: finalPrompt,
     duration: extractDuration(wizardData),
     aspectRatio: extractAspectRatio(wizardData),
     resolution: extractResolution(wizardData),
   };
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Input built", {
-      hasSource: !!input.sourceImageBase64,
-      hasTarget: !!input.targetImageBase64,
-      duration: input.duration,
-    });
-  }
-
-  return input;
 }
 
-// ============================================================================
-// Strategy Factory
-// ============================================================================
-
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Created", { scenarioId: scenario.id, videoFeatureType });
-  }
-
   let lastInputRef: WizardVideoInput | null = null;
 
   return {
@@ -152,7 +107,7 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       const videoResult = result as { videoUrl?: string };
       if (!input || !scenario?.id || !videoResult.videoUrl) return;
 
-      const creation = {
+      await repository.create(uid, {
         id: `${scenario.id}_${Date.now()}`,
         uri: videoResult.videoUrl,
         type: scenario.id,
@@ -161,14 +116,9 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title,
-        },
+        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
         output: { videoUrl: videoResult.videoUrl },
-      };
-
-      await repository.create(uid, creation);
+      });
     },
   };
 }

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

@@ -4,6 +4,7 @@
  */
 
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 
 export interface WizardVideoInput {
   /** Source image (optional for text-to-video) */
@@ -27,3 +28,32 @@ export interface CreateVideoStrategyOptions {
   readonly scenario: WizardScenarioData;
   readonly collectionName?: string;
 }
+
+export interface PhotoValidationResult {
+  isValid: boolean;
+  errorKey?: string;
+}
+
+export function validatePhotoCount(
+  photoCount: number,
+  inputType: ScenarioInputType | undefined,
+): PhotoValidationResult {
+  const effectiveInputType = inputType ?? "single";
+
+  switch (effectiveInputType) {
+    case "dual":
+      if (photoCount < 2) {
+        return { isValid: false, errorKey: "error.generation.dualPhotosRequired" };
+      }
+      break;
+    case "single":
+      if (photoCount < 1) {
+        return { isValid: false, errorKey: "error.generation.photoRequired" };
+      }
+      break;
+    case "text":
+      break;
+  }
+
+  return { isValid: true };
+}