@umituz/react-native-ai-generation-content 1.17.221 → 1.17.223

package/package.json

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

package/src/features/image-to-video/presentation/hooks/useGenerationExecution.ts

@@ -10,6 +10,7 @@ import type {
   ImageToVideoFeatureCallbacks,
   ImageToVideoResult,
   ImageToVideoGenerateParams,
+  ImageToVideoFeatureState,
 } from "../../domain/types";
 
 declare const __DEV__: boolean;
@@ -18,7 +19,7 @@ interface UseGenerationExecutionParams {
   userId: string;
   config: ImageToVideoFeatureConfig;
   callbacks?: ImageToVideoFeatureCallbacks;
-  setState: React.Dispatch<React.SetStateAction<any>>;
+  setState: React.Dispatch<React.SetStateAction<ImageToVideoFeatureState>>;
 }
 
 export function useGenerationExecution({
@@ -35,7 +36,7 @@ export function useGenerationExecution({
     ): Promise<ImageToVideoResult> => {
       const creationId = `image-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 
-      setState((prev: any) => ({
+      setState((prev) => ({
         ...prev,
         imageUri,
         isProcessing: true,
@@ -82,14 +83,14 @@ export function useGenerationExecution({
             buildInput: config.buildInput,
             extractResult: config.extractResult,
             onProgress: (progress) => {
-              setState((prev: any) => ({ ...prev, progress }));
+              setState((prev) => ({ ...prev, progress }));
               callbacks?.onProgress?.(progress);
             },
           },
         );
 
         if (result.success && result.videoUrl) {
-          setState((prev: any) => ({
+          setState((prev) => ({
             ...prev,
             videoUrl: result.videoUrl ?? null,
             thumbnailUrl: result.thumbnailUrl ?? null,
@@ -115,7 +116,7 @@ export function useGenerationExecution({
           callbacks?.onGenerate?.(result);
         } else {
           const error = result.error || "Generation failed";
-          setState((prev: any) => ({ ...prev, isProcessing: false, error }));
+          setState((prev) => ({ ...prev, isProcessing: false, error }));
           config.onError?.(error);
           callbacks?.onError?.(error);
         }
@@ -127,7 +128,7 @@ export function useGenerationExecution({
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error("[ImageToVideoFeature] Generation error:", errorMessage);
         }
-        setState((prev: any) => ({
+        setState((prev) => ({
           ...prev,
           isProcessing: false,
           error: errorMessage,

package/src/features/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -68,7 +68,11 @@ export function useImageToVideoFeature(
         return validation;
       }
 
-      return executeGeneration(effectiveImageUri, effectiveMotionPrompt, options);
+      return executeGeneration(
+        effectiveImageUri!,
+        effectiveMotionPrompt,
+        options
+      );
     },
     [state.imageUri, state.motionPrompt, callbacks, config.creditCost, executeGeneration],
   );

package/src/features/image-to-video/presentation/hooks/useImageToVideoValidation.ts

@@ -2,7 +2,7 @@
  * Image-to-Video Validation Utilities
  */
 
-import type { ImageToVideoFeatureCallbacks, ImageToVideoGenerateParams, ImageToVideoResult } from "../../domain/types";
+import type { ImageToVideoFeatureCallbacks, ImageToVideoResult } from "../../domain/types";
 
 declare const __DEV__: boolean;
 

package/src/infrastructure/services/job-poller-factory.ts

@@ -0,0 +1,16 @@
+/**
+ * Job Poller Factory
+ * Creates pre-configured job poller instances
+ */
+
+import type { PollingConfig } from "../../domain/entities";
+import type { PollJobOptions } from "./job-poller.types";
+import { pollJob } from "./job-poller.service";
+
+export function createJobPoller(defaultConfig?: Partial<PollingConfig>) {
+  return {
+    poll<T = unknown>(options: Omit<PollJobOptions, "config">) {
+      return pollJob<T>({ ...options, config: defaultConfig });
+    },
+  };
+}

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

@@ -3,33 +3,21 @@
  * Provider-agnostic job polling with exponential backoff
  */
 
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import type { PollingConfig } from "../../domain/entities";
+import type { IAIProvider } from "../../domain/interfaces"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import type { PollingConfig } from "../../domain/entities"; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
 import { calculatePollingInterval } from "../utils/polling-interval.util";
 import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
 import { validateResult } from "../utils/result-validator.util";
 import { isTransientError } from "../utils/error-classifier.util";
+import { calculateProgressFromJobStatus } from "../utils/progress-calculator.util";
+import type { PollJobOptions, PollJobResult } from "./job-poller.types";
+import { createJobPoller } from "./job-poller-factory"; // eslint-disable-line @typescript-eslint/no-unused-vars
 
-declare const __DEV__: boolean;
-
-export interface PollJobOptions {
-  provider: IAIProvider;
-  model: string;
-  requestId: string;
-  config?: Partial<PollingConfig>;
-  onProgress?: (progress: number) => void;
-  onStatusChange?: (status: JobStatus) => void;
-  signal?: AbortSignal;
-}
+// IAIProvider and PollingConfig are used indirectly through provider methods
+// createJobPoller is re-exported
 
-export interface PollJobResult<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: Error;
-  attempts: number;
-  elapsedMs: number;
-}
+declare const __DEV__: boolean;
 
 const MAX_CONSECUTIVE_TRANSIENT_ERRORS = 5;
 
@@ -57,7 +45,6 @@ export async function pollJob<T = unknown>(
   let lastProgress = 0;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    // Check for abort
     if (signal?.aborted) {
       return {
         success: false,
@@ -67,18 +54,15 @@ export async function pollJob<T = unknown>(
       };
     }
 
-    // Wait for polling interval (skip first attempt)
     if (attempt > 0) {
       const interval = calculatePollingInterval({ attempt, config: pollingConfig });
       await new Promise<void>((resolve) => setTimeout(() => resolve(), interval));
     }
 
     try {
-      // Get job status
       const status = await provider.getJobStatus(model, requestId);
       onStatusChange?.(status);
 
-      // Check for errors in status
       const statusCheck = checkStatusForErrors(status);
 
       if (statusCheck.shouldStop && statusCheck.hasError) {
@@ -90,24 +74,19 @@ export async function pollJob<T = unknown>(
         };
       }
 
-      // Reset transient error counter on success
       consecutiveTransientErrors = 0;
 
-      // Update progress
-      const progress = calculateProgressFromStatus(status, attempt, maxAttempts);
+      const progress = calculateProgressFromJobStatus(status, attempt, maxAttempts);
       if (progress > lastProgress) {
         lastProgress = progress;
         onProgress?.(progress);
       }
 
-      // Check if complete
       if (isJobComplete(status)) {
         onProgress?.(90);
 
-        // Fetch result
         const result = await provider.getJobResult<T>(model, requestId);
 
-        // Validate result
         const validation = validateResult(result);
         if (!validation.isValid) {
           return {
@@ -131,7 +110,6 @@ export async function pollJob<T = unknown>(
       if (isTransientError(error)) {
         consecutiveTransientErrors++;
 
-        // Too many consecutive transient errors
         if (consecutiveTransientErrors >= MAX_CONSECUTIVE_TRANSIENT_ERRORS) {
           return {
             success: false,
@@ -141,10 +119,8 @@ export async function pollJob<T = unknown>(
           };
         }
 
-        // Continue retrying
         if (attempt < maxAttempts - 1) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
             console.log(
               `[JobPoller] Transient error, retrying (${attempt + 1}/${maxAttempts})`,
             );
@@ -153,7 +129,6 @@ export async function pollJob<T = unknown>(
         }
       }
 
-      // Permanent error or max retries reached
       return {
         success: false,
         error: error instanceof Error ? error : new Error(String(error)),
@@ -163,7 +138,6 @@ export async function pollJob<T = unknown>(
     }
   }
 
-  // Max attempts reached
   return {
     success: false,
     error: new Error(`Polling timeout after ${maxAttempts} attempts`),
@@ -172,37 +146,5 @@ export async function pollJob<T = unknown>(
   };
 }
 
-/**
- * Calculate progress percentage from job status
- */
-function calculateProgressFromStatus(
-  status: JobStatus,
-  attempt: number,
-  maxAttempts: number,
-): number {
-  const statusString = String(status.status).toUpperCase();
-
-  switch (statusString) {
-    case "IN_QUEUE":
-      return 30 + Math.min(attempt * 2, 10);
-    case "IN_PROGRESS":
-      return 50 + Math.min(attempt * 3, 30);
-    case "COMPLETED":
-      return 90;
-    case "FAILED":
-      return 0;
-    default:
-      return 20 + Math.min((attempt / maxAttempts) * 30, 30);
-  }
-}
-
-/**
- * Create a job poller with preset configuration
- */
-export function createJobPoller(defaultConfig?: Partial<PollingConfig>) {
-  return {
-    poll<T = unknown>(options: Omit<PollJobOptions, "config">) {
-      return pollJob<T>({ ...options, config: defaultConfig });
-    },
-  };
-}
+export { createJobPoller } from "./job-poller-factory";
+export type { PollJobOptions, PollJobResult } from "./job-poller.types";

package/src/infrastructure/services/job-poller.types.ts

@@ -0,0 +1,24 @@
+/**
+ * Job Poller Type Definitions
+ */
+
+import type { IAIProvider, JobStatus } from "../../domain/interfaces";
+import type { PollingConfig } from "../../domain/entities";
+
+export interface PollJobOptions {
+  provider: IAIProvider;
+  model: string;
+  requestId: string;
+  config?: Partial<PollingConfig>;
+  onProgress?: (progress: number) => void;
+  onStatusChange?: (status: JobStatus) => void;
+  signal?: AbortSignal;
+}
+
+export interface PollJobResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: Error;
+  attempts: number;
+  elapsedMs: number;
+}

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

@@ -6,94 +6,16 @@
 
 import { providerRegistry } from "./provider-registry.service";
 import { cleanBase64 } from "../utils";
+import { defaultExtractVideoResult } from "../utils/video-result-extractor.util";
 import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
+import type {
+  ExecuteVideoFeatureOptions,
+  VideoFeatureResult,
+  VideoFeatureRequest,
+} from "./video-feature-executor.types";
 
 declare const __DEV__: boolean;
 
-/**
- * Result extractor function type
- */
-export type VideoResultExtractor = (result: unknown) => string | undefined;
-
-/**
- * Execution options
- */
-export interface ExecuteVideoFeatureOptions {
-  extractResult?: VideoResultExtractor;
-  onProgress?: (progress: number) => void;
-}
-
-/**
- * Execution result
- */
-export interface VideoFeatureResult {
-  success: boolean;
-  videoUrl?: string;
-  error?: string;
-  requestId?: string;
-}
-
-/**
- * Request data for video features
- */
-export interface VideoFeatureRequest {
-  sourceImageBase64: string;
-  targetImageBase64: string;
-  prompt?: string;
-  options?: Record<string, unknown>;
-}
-
-/**
- * Default result extractor - handles common response formats
- * Supports FAL data wrapper and nested object formats
- */
-function defaultExtractVideoResult(result: unknown): string | undefined {
-  if (typeof result !== "object" || result === null) return undefined;
-
-  const r = result as Record<string, unknown>;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoExtractor] Result keys:", Object.keys(r));
-  }
-
-  // Handle fal.ai data wrapper
-  const data = (r.data as Record<string, unknown>) ?? r;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoExtractor] Data keys:", Object.keys(data));
-  }
-
-  // Direct string values
-  if (typeof data.video === "string") return data.video;
-  if (typeof data.videoUrl === "string") return data.videoUrl;
-  if (typeof data.video_url === "string") return data.video_url;
-  if (typeof data.output === "string") return data.output;
-  if (typeof data.url === "string") return data.url;
-
-  // Object with url property (e.g., { video: { url: "..." } })
-  const videoObj = data.video as Record<string, unknown> | undefined;
-  if (videoObj && typeof videoObj === "object" && typeof videoObj.url === "string") {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoExtractor] Found data.video.url:", videoObj.url);
-    }
-    return videoObj.url;
-  }
-
-  // Array format (e.g., { videos: [{ url: "..." }] })
-  if (Array.isArray(data.videos) && typeof data.videos[0]?.url === "string") {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoExtractor] Found videos[0].url:", data.videos[0].url);
-    }
-    return data.videos[0].url;
-  }
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoExtractor] No video URL found in result");
-  }
-
-  return undefined;
-}
-
 /**
  * Execute any video feature using the active provider
  * Uses subscribe for video features to handle long-running generation with progress updates
@@ -173,24 +95,33 @@ export async function executeVideoFeature(
       requestId: (result as { requestId?: string })?.requestId,
     };
   } catch (error) {
-    // Extract detailed error message from FAL API errors
-    let message = "Processing failed";
-    if (error instanceof Error) {
-      message = error.message;
-    } else if (typeof error === "object" && error !== null) {
-      const errObj = error as Record<string, unknown>;
-      if (errObj.detail) {
-        message = JSON.stringify(errObj.detail);
-      } else if (errObj.message) {
-        message = String(errObj.message);
-      }
-    }
+    const message = extractErrorMessage(error, featureType);
+    return { success: false, error: message };
+  }
+}
 
-    if (__DEV__) {
-      console.error(`[Video:${featureType}] Error:`, message, error);
+/**
+ * Extract error message from various error formats
+ */
+function extractErrorMessage(error: unknown, featureType: VideoFeatureType): string {
+  let message = "Processing failed";
+
+  if (error instanceof Error) {
+    message = error.message;
+  } else if (typeof error === "object" && error !== null) {
+    const errObj = error as Record<string, unknown>;
+    if (errObj.detail) {
+      message = JSON.stringify(errObj.detail);
+    } else if (errObj.message) {
+      message = String(errObj.message);
     }
-    return { success: false, error: message };
   }
+
+  if (__DEV__) {
+    console.error(`[Video:${featureType}] Error:`, message, error);
+  }
+
+  return message;
 }
 
 /**
@@ -200,3 +131,9 @@ export function hasVideoFeatureSupport(): boolean {
   const provider = providerRegistry.getActiveProvider();
   return provider !== null && provider.isInitialized();
 }
+
+export type {
+  ExecuteVideoFeatureOptions,
+  VideoFeatureResult,
+  VideoFeatureRequest,
+} from "./video-feature-executor.types";

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

@@ -0,0 +1,36 @@
+/**
+ * Video Feature Executor Type Definitions
+ */
+
+/**
+ * Result extractor function type
+ */
+export type VideoResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Execution options
+ */
+export interface ExecuteVideoFeatureOptions {
+  extractResult?: VideoResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+/**
+ * Execution result
+ */
+export interface VideoFeatureResult {
+  success: boolean;
+  videoUrl?: string;
+  error?: string;
+  requestId?: string;
+}
+
+/**
+ * Request data for video features
+ */
+export interface VideoFeatureRequest {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}

package/src/infrastructure/utils/progress-calculator.util.ts

@@ -10,6 +10,7 @@ import {
   type ProgressStageConfig,
 } from "../../domain/entities";
 import type { AIJobStatusType } from "../../domain/interfaces/ai-provider.interface";
+import type { JobStatus } from "../../domain/interfaces";
 
 export interface ProgressOptions {
   status: GenerationStatus;
@@ -126,3 +127,28 @@ export function getProgressFromJobStatus(
   const generationStatus = mapJobStatusToGenerationStatus(jobStatus);
   return getProgressForStatus({ status: generationStatus, stages });
 }
+
+/**
+ * Calculate progress percentage from job status and attempt number
+ * Used by job poller for granular progress reporting during polling
+ */
+export function calculateProgressFromJobStatus(
+  status: JobStatus,
+  attempt: number,
+  maxAttempts: number,
+): number {
+  const statusString = String(status.status).toUpperCase();
+
+  switch (statusString) {
+    case "IN_QUEUE":
+      return 30 + Math.min(attempt * 2, 10);
+    case "IN_PROGRESS":
+      return 50 + Math.min(attempt * 3, 30);
+    case "COMPLETED":
+      return 90;
+    case "FAILED":
+      return 0;
+    default:
+      return 20 + Math.min((attempt / maxAttempts) * 30, 30);
+  }
+}

package/src/infrastructure/utils/video-result-extractor.util.ts

@@ -0,0 +1,59 @@
+/**
+ * Video Result Extractor Utility
+ * Extracts video URL from various provider response formats
+ */
+
+import type { VideoResultExtractor } from "../services/video-feature-executor.types";
+
+declare const __DEV__: boolean;
+
+/**
+ * Default result extractor - handles common response formats
+ * Supports FAL data wrapper and nested object formats
+ */
+export const defaultExtractVideoResult: VideoResultExtractor = (result) => {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoExtractor] Result keys:", Object.keys(r));
+  }
+
+  // Handle fal.ai data wrapper
+  const data = (r.data as Record<string, unknown>) ?? r;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoExtractor] Data keys:", Object.keys(data));
+  }
+
+  // Direct string values
+  if (typeof data.video === "string") return data.video;
+  if (typeof data.videoUrl === "string") return data.videoUrl;
+  if (typeof data.video_url === "string") return data.video_url;
+  if (typeof data.output === "string") return data.output;
+  if (typeof data.url === "string") return data.url;
+
+  // Object with url property (e.g., { video: { url: "..." } })
+  const videoObj = data.video as Record<string, unknown> | undefined;
+  if (videoObj && typeof videoObj === "object" && typeof videoObj.url === "string") {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExtractor] Found data.video.url:", videoObj.url);
+    }
+    return videoObj.url;
+  }
+
+  // Array format (e.g., { videos: [{ url: "..." }] })
+  if (Array.isArray(data.videos) && typeof data.videos[0]?.url === "string") {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExtractor] Found videos[0].url:", data.videos[0].url);
+    }
+    return data.videos[0].url;
+  }
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoExtractor] No video URL found in result");
+  }
+
+  return undefined;
+};