@umituz/react-native-ai-generation-content 1.90.11 → 1.90.12

package/package.json

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

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -81,13 +81,13 @@ export async function pollJob<T = unknown>(
     try {
       // Check job status
       const statusResult = await withAbortSignal(
-        provider.checkStatus(requestId, model),
+        provider.getJobStatus(model, requestId),
         signal,
         config.maxTotalTimeMs ? config.maxTotalTimeMs - (Date.now() - startTime) : undefined
       );
 
       // Notify status change
-      if (onStatusChange && typeof statusResult === 'object' && 'status' in statusResult) {
+      if (onStatusChange && statusResult && typeof statusResult === 'object' && 'status' in statusResult) {
         onStatusChange(statusResult as JobStatus);
       }
 
@@ -96,7 +96,7 @@ export async function pollJob<T = unknown>(
       if (statusError) {
         return {
           success: false,
-          error: statusError,
+          error: statusError instanceof Error ? statusError : new Error(String(statusError)),
           attempts: attempt + 1,
           elapsedMs: Date.now() - startTime,
         };
@@ -106,7 +106,7 @@ export async function pollJob<T = unknown>(
       consecutiveErrors = 0;
 
       // Check if job is complete
-      if (isJobComplete(statusResult as JobStatus | Record<string, unknown>)) {
+      if (isJobComplete(statusResult as JobStatus | string)) {
         // Validate result
         const validationResult = validateResult(statusResult);
         if (!validationResult.isValid) {

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

@@ -4,8 +4,11 @@
  */
 
 import { useEffect } from 'react';
+import type { Creation } from '../../../../domain/entities/Creation';
 
 export interface UseProcessingJobsPollerConfig {
+  userId: string | null;
+  creations: Creation[];
   enabled?: boolean;
   interval?: number;
 }
@@ -16,24 +19,32 @@ export interface UseProcessingJobsPollerReturn {
 
 /**
  * Hook to poll processing jobs
- * TODO: Implement actual polling logic
  */
 export function useProcessingJobsPoller(
-  config: UseProcessingJobsPollerConfig = {}
+  config: UseProcessingJobsPollerConfig
 ): UseProcessingJobsPollerReturn {
-  const { enabled = false, interval = 5000 } = config;
+  const { userId, creations, enabled = false, interval = 5000 } = config;
 
   useEffect(() => {
-    if (!enabled) return;
+    if (!enabled || !userId) return;
 
     const timer = setInterval(() => {
-      // Polling logic here
+      // Polling logic here - check processing creations and update their status
+      const processingCreations = creations.filter(c => c.status === 'processing');
+      processingCreations.forEach(async (creation) => {
+        try {
+          // Check job status and update creation
+          // TODO: Implement actual polling logic
+        } catch (error) {
+          console.error('Error polling job status:', error);
+        }
+      });
     }, interval);
 
     return () => clearInterval(timer);
-  }, [enabled, interval]);
+  }, [enabled, interval, userId, creations]);
 
   return {
-    isPolling: enabled,
+    isPolling: enabled && !!userId,
   };
 }

package/src/domains/face-detection/domain/entities/FaceDetection.ts

@@ -13,6 +13,7 @@ export interface FaceDetectionResult {
 
 export interface FaceValidationState extends BaseFeatureState<FaceDetectionResult> {
   isValidating: boolean;
+  result?: FaceDetectionResult;
 }
 
 export interface FaceDetectionConfig {

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-prompt.ts

@@ -49,7 +49,7 @@ export function processCouplePrompt(
 
   // 4. CREATE FINAL PROMPT - Photorealistic
   logBuilderStep(prefix, "STEP 4: CREATE PHOTOREALISTIC PROMPT", {
-    isCouple: isCoupleMode,
+    isCoupleMode,
     hasCustomInstructions: !!customInstructions
   });
 

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

@@ -5,7 +5,8 @@
  */
 
 import type { WizardStrategy } from "./wizard-strategy.types";
-import type { CreateVideoStrategyOptions } from "./video-generation.types";
+import type { CreateVideoStrategyOptions, WizardVideoInput } from "./video-generation.types";
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import { validateWizardVideoInput } from "./video-generation.validation";
 import { executeVideoGeneration, submitVideoGenerationToQueue } from "./video-generation.executor";
 
@@ -48,3 +49,25 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
   };
 }
 
+/**
+ * Build video input from wizard data and scenario
+ */
+export async function buildVideoInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData
+): Promise<WizardVideoInput> {
+  const prompt = (wizardData.prompt as string | undefined) || scenario.prompt || "";
+  const input: WizardVideoInput = {
+    prompt,
+    sourceImageBase64: wizardData.sourceImageBase64 as string | undefined,
+    targetImageBase64: wizardData.targetImageBase64 as string | undefined,
+    duration: wizardData.duration as number | undefined,
+    aspectRatio: wizardData.aspectRatio as string | undefined,
+    resolution: wizardData.resolution as string | undefined,
+    audioUrl: wizardData.audioUrl as string | undefined,
+    qualityMode: wizardData.qualityMode as "draft" | "normal" | undefined,
+  };
+
+  return input;
+}
+

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

@@ -32,3 +32,17 @@ export interface CreateVideoStrategyOptions {
   /** Credit cost for this generation - REQUIRED, determined by the app */
   readonly creditCost: number;
 }
+
+export interface ExecutionResult {
+  success: boolean;
+  videoUrl?: string;
+  requestId?: string;
+  error?: string;
+}
+
+export interface SubmissionResult {
+  success: boolean;
+  requestId?: string;
+  model?: string;
+  error?: string;
+}

package/src/domains/generation/wizard/presentation/hooks/photo-upload/types.ts

@@ -2,10 +2,14 @@
  * Generic Photo Upload State Hook - Type Definitions
  */
 
-import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
-
-// Re-export for use in this module
-export type { UploadedImage };
+export interface UploadedImage {
+  uri: string;
+  base64?: string;
+  width?: number;
+  height?: number;
+  previewUrl?: string;
+  fileSize?: number;
+}
 
 export interface PhotoUploadConfig {
   readonly maxFileSizeMB?: number;

package/src/domains/generation/wizard/presentation/hooks/photo-upload/usePhotoUploadStateLogic.ts

@@ -4,7 +4,7 @@
 
 import { useCallback, useRef, useEffect } from "react";
 import { useMedia, MediaQuality, MediaValidationError, MEDIA_CONSTANTS } from "@umituz/react-native-design-system/media";
-import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "./types";
 import type { PhotoUploadConfig, PhotoUploadError, PhotoUploadTranslations } from "./types";
 
 export function usePhotoUploadStateLogic(

package/src/domains/generation/wizard/presentation/hooks/video-queue/use-video-queue-utils.ts

@@ -109,15 +109,24 @@ export function extractInputMetadata(params: {
   readonly model: string;
   readonly prompt: string;
   readonly imageUrls?: string[];
+  readonly duration?: number;
+  readonly resolution?: string;
+  readonly aspectRatio?: string;
 }): {
   readonly model: string;
   readonly prompt: string;
   readonly imageUrls: string[];
+  readonly duration?: number;
+  readonly resolution?: string;
+  readonly aspectRatio?: string;
 } {
   return {
     model: params.model,
     prompt: params.prompt,
     imageUrls: params.imageUrls || [],
+    duration: params.duration,
+    resolution: params.resolution,
+    aspectRatio: params.aspectRatio,
   };
 }
 

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationStart.ts

@@ -39,7 +39,15 @@ export function useStartGeneration(
       let creationId: string | null = null;
       if (userId && prompt) {
         try {
-          const { duration, resolution, aspectRatio } = extractInputMetadata(input);
+          const inputRecord = input as Record<string, unknown>;
+          const { duration, resolution, aspectRatio } = extractInputMetadata({
+            model: scenario.model || "",
+            prompt,
+            imageUrls: (inputRecord.imageUrls || inputRecord.image_url) as string[] | undefined,
+            duration: inputRecord.duration as number | undefined,
+            resolution: inputRecord.resolution as string | undefined,
+            aspectRatio: inputRecord.aspectRatio as string | undefined,
+          });
 
           const result = await persistence.saveAsProcessing(userId, {
             scenarioId: scenario.id,

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

@@ -11,6 +11,7 @@ export interface ImageToVideoFormState {
   animationStyle: AnimationStyleId;
   duration: VideoDuration;
   motionPrompt: string;
+  onError?: (error: string) => void;
 }
 
 export interface ImageToVideoFormActions {

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -68,7 +68,7 @@ export async function executeImageFeature(
     if (!urlValidation.isValid) {
       return {
         success: false,
-        error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`
+        error: `Invalid image URL received: ${Object.values(urlValidation.errors).join(", ")}`
       };
     }
 

package/src/infrastructure/services/multi-image-generation.executor.ts

@@ -100,10 +100,11 @@ export async function executeMultiImageGeneration(
           if (typeof imageUrl === "string" && imageUrl.length > 0) {
             const urlValidation = validateURL(imageUrl);
             if (!urlValidation.isValid) {
-              addGenerationLog(sid, TAG, `Invalid URL in response: ${urlValidation.errors.join(", ")}`, 'error');
+              const errorMsg = Object.values(urlValidation.errors).join(", ");
+              addGenerationLog(sid, TAG, `Invalid URL in response: ${errorMsg}`, 'error');
               return {
                 success: false,
-                error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`,
+                error: `Invalid image URL received: ${errorMsg}`,
                 logSessionId: sid,
               };
             }

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -54,7 +54,7 @@ export async function executeVideoFeature(
     if (!urlValidation.isValid) {
       return {
         success: false,
-        error: `Invalid video URL received: ${urlValidation.errors.join(", ")}`
+        error: `Invalid video URL received: ${Object.values(urlValidation.errors).join(", ")}`
       };
     }
 

package/src/infrastructure/validation/ai-validator.ts

@@ -26,7 +26,7 @@ export function validateAIPrompt(input: unknown): ValidationResult {
  */
 export function validateImageData(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Image data must be a string"] };
+    return { isValid: false, errors: { type: "Image data must be a string" } };
   }
 
   const trimmed = input.trim();
@@ -40,11 +40,11 @@ export function validateImageData(input: unknown): ValidationResult {
   if (trimmed.startsWith("data:image/")) {
     const parts = trimmed.split(",");
     if (parts.length !== 2) {
-      return { isValid: false, errors: ["Invalid data URI format"] };
+      return { isValid: false, errors: { format: "Invalid data URI format" } };
     }
     const base64Part = parts[1];
     if (!base64Part || base64Part.length === 0) {
-      return { isValid: false, errors: ["Invalid data URI: missing base64 data"] };
+      return { isValid: false, errors: { data: "Invalid data URI: missing base64 data" } };
     }
     return validateBase64(base64Part);
   }
@@ -57,7 +57,7 @@ export function validateImageData(input: unknown): ValidationResult {
 
   return {
     isValid: false,
-    errors: ["Image data must be a URL, base64 data URI, or valid base64 string"],
+    errors: { format: "Image data must be a URL, base64 data URI, or valid base64 string" },
   };
 }
 

package/src/infrastructure/validation/entity-validator.ts

@@ -14,7 +14,7 @@ export function validateUserId(input: unknown): ValidationResult {
     maxLength: 100,
     pattern: /^[a-zA-Z0-9_-]+$/,
   };
-  return validateString(input, options);
+  return validateString(typeof input === "string" ? input : String(input), options);
 }
 
 /**
@@ -25,6 +25,6 @@ export function validateCreationId(input: unknown): ValidationResult {
     minLength: 1,
     maxLength: 100,
   };
-  return validateString(input, options);
+  return validateString(typeof input === "string" ? input : String(input), options);
 }
 

package/src/infrastructure/validation/input-validator.ts

@@ -12,7 +12,7 @@ export {
   validateBase64,
   type ValidationResult,
   type StringValidationOptions,
-  type NumericValidationOptions,
+  type NumberValidationOptions,
 } from "./base-validator";
 
 // Sanitizers

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

@@ -88,7 +88,7 @@ export const useImageGeneration = <TInput extends ImageGenerationInput, TResult>
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onSuccess: onSuccess ? async (result) => onSuccess(result as TResult) : undefined,
     onError: async (error) => handleError(error),
   });
 };

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

@@ -103,7 +103,7 @@ export const useVideoGeneration = <TResult>(
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onSuccess: onSuccess ? async (result) => onSuccess(result as TResult) : undefined,
     onError: async (error) => handleError(error),
   });
 };