@umituz/react-native-ai-generation-content 1.26.28 → 1.26.29

package/package.json

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

package/src/infrastructure/constants/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Infrastructure Constants
+ */
+
+export {
+  IMAGE_PROGRESS,
+  VIDEO_PROGRESS,
+  POLLING_PROGRESS,
+  VIDEO_TIMEOUT_MS,
+  MAX_TRANSIENT_ERRORS,
+} from "./progress.constants";

package/src/infrastructure/constants/progress.constants.ts

@@ -0,0 +1,36 @@
+/**
+ * Progress Constants
+ * Standardized progress values for generation pipelines
+ */
+
+/** Image generation progress stages */
+export const IMAGE_PROGRESS = {
+  START: 10,
+  INPUT_PREPARED: 30,
+  REQUEST_SENT: 40,
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Video generation progress stages */
+export const VIDEO_PROGRESS = {
+  START: 5,
+  INPUT_PREPARED: 10,
+  REQUEST_SENT: 15,
+  IN_QUEUE: 20,
+  IN_PROGRESS: 50,
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Polling progress stages */
+export const POLLING_PROGRESS = {
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Video generation timeout in milliseconds (5 minutes) */
+export const VIDEO_TIMEOUT_MS = 300000;
+
+/** Maximum consecutive transient errors before failing */
+export const MAX_TRANSIENT_ERRORS = 5;

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

@@ -5,8 +5,9 @@
  */
 
 import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64 } from "../utils";
+import { cleanBase64, extractErrorMessage } from "../utils";
 import { extractImageResult } from "../utils/url-extractor";
+import { IMAGE_PROGRESS } from "../constants";
 import type { ImageResultExtractor } from "../utils/url-extractor";
 import type { ImageFeatureType, ImageFeatureInputData } from "../../domain/interfaces";
 
@@ -68,7 +69,7 @@ export async function executeImageFeature(
   }
 
   try {
-    onProgress?.(10);
+    onProgress?.(IMAGE_PROGRESS.START);
 
     const inputData: ImageFeatureInputData = {
       imageBase64: request.imageBase64 ? cleanBase64(request.imageBase64) : "",
@@ -79,20 +80,20 @@ export async function executeImageFeature(
       options: request.options,
     };
 
-    onProgress?.(30);
+    onProgress?.(IMAGE_PROGRESS.INPUT_PREPARED);
 
     const input = provider.buildImageFeatureInput(featureType, inputData);
 
-    onProgress?.(40);
+    onProgress?.(IMAGE_PROGRESS.REQUEST_SENT);
 
     const result = await provider.run(model, input);
 
-    onProgress?.(90);
+    onProgress?.(IMAGE_PROGRESS.RESULT_RECEIVED);
 
     const extractor = extractResult ?? extractImageResult;
     const imageUrl = extractor(result);
 
-    onProgress?.(100);
+    onProgress?.(IMAGE_PROGRESS.COMPLETE);
 
     if (!imageUrl) {
       return { success: false, error: "No image in response" };
@@ -104,26 +105,7 @@ export async function executeImageFeature(
       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>;
-      // FAL API error format: {detail: [{msg, type, loc}]} or {message}
-      if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
-        message = String(errObj.detail[0].msg);
-      } else if (errObj.detail) {
-        message = JSON.stringify(errObj.detail);
-      } else if (errObj.message) {
-        message = String(errObj.message);
-      } else if (errObj.msg) {
-        message = String(errObj.msg);
-      }
-    }
-    if (__DEV__) {
-      console.error(`[Image:${featureType}] Error:`, message, error);
-    }
+    const message = extractErrorMessage(error, "Processing failed", `Image:${featureType}`);
     return { success: false, error: message };
   }
 }

package/src/infrastructure/services/provider-validator.ts

@@ -9,44 +9,23 @@ import { providerRegistry } from "./provider-registry.service";
 declare const __DEV__: boolean;
 
 export class ProviderValidator {
-    getProvider(): IAIProvider {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            console.log("[ProviderValidator] getProvider() called");
-        }
-
-        const provider = providerRegistry.getActiveProvider();
-
-        if (!provider) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.error("[ProviderValidator] No active provider found!");
-            }
-            throw new Error(
-                "No active AI provider. Register and set a provider first.",
-            );
-        }
-
-        if (!provider.isInitialized()) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.error("[ProviderValidator] Provider not initialized:", provider.providerId);
-            }
-            throw new Error(
-                `Provider ${provider.providerId} is not initialized.`,
-            );
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            console.log("[ProviderValidator] getProvider() returning:", {
-                providerId: provider.providerId,
-                isInitialized: provider.isInitialized(),
-            });
-        }
+  getProvider(): IAIProvider {
+    const provider = providerRegistry.getActiveProvider();
+
+    if (!provider) {
+      if (__DEV__) {
+        console.error("[ProviderValidator] No active provider found");
+      }
+      throw new Error("No active AI provider. Register and set a provider first.");
+    }
 
-        return provider;
+    if (!provider.isInitialized()) {
+      if (__DEV__) {
+        console.error("[ProviderValidator] Provider not initialized:", provider.providerId);
+      }
+      throw new Error(`Provider ${provider.providerId} is not initialized.`);
     }
-}
 
-export const providerValidator = new ProviderValidator();
+    return provider;
+  }
+}

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

@@ -5,8 +5,9 @@
  */
 
 import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64 } from "../utils";
+import { cleanBase64, extractErrorMessage } from "../utils";
 import { extractVideoResult } from "../utils/url-extractor";
+import { VIDEO_PROGRESS, VIDEO_TIMEOUT_MS } from "../constants";
 import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
 import type {
   ExecuteVideoFeatureOptions,
@@ -44,7 +45,7 @@ export async function executeVideoFeature(
   }
 
   try {
-    onProgress?.(5);
+    onProgress?.(VIDEO_PROGRESS.START);
 
     const inputData: VideoFeatureInputData = {
       sourceImageBase64: cleanBase64(request.sourceImageBase64),
@@ -53,34 +54,32 @@ export async function executeVideoFeature(
       options: request.options,
     };
 
-    onProgress?.(10);
+    onProgress?.(VIDEO_PROGRESS.INPUT_PREPARED);
 
     const input = provider.buildVideoFeatureInput(featureType, inputData);
 
-    onProgress?.(15);
+    onProgress?.(VIDEO_PROGRESS.REQUEST_SENT);
 
-    // Use subscribe for video features - provides queue updates and handles long-running tasks
     const result = await provider.subscribe(model, input, {
-      timeoutMs: 300000, // 5 minutes timeout for video generation
+      timeoutMs: VIDEO_TIMEOUT_MS,
       onQueueUpdate: (status) => {
         if (__DEV__) {
           console.log(`[Video:${featureType}] Queue update:`, status.status);
         }
-        // Map queue status to progress percentage
         if (status.status === "IN_QUEUE") {
-          onProgress?.(20);
+          onProgress?.(VIDEO_PROGRESS.IN_QUEUE);
         } else if (status.status === "IN_PROGRESS") {
-          onProgress?.(50);
+          onProgress?.(VIDEO_PROGRESS.IN_PROGRESS);
         }
       },
     });
 
-    onProgress?.(90);
+    onProgress?.(VIDEO_PROGRESS.RESULT_RECEIVED);
 
     const extractor = extractResult ?? extractVideoResult;
     const videoUrl = extractor(result);
 
-    onProgress?.(100);
+    onProgress?.(VIDEO_PROGRESS.COMPLETE);
 
     if (!videoUrl) {
       if (__DEV__) {
@@ -95,35 +94,11 @@ export async function executeVideoFeature(
       requestId: (result as { requestId?: string })?.requestId,
     };
   } catch (error) {
-    const message = extractErrorMessage(error, featureType);
+    const message = extractErrorMessage(error, "Processing failed", `Video:${featureType}`);
     return { success: false, error: message };
   }
 }
 
-/**
- * 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);
-    }
-  }
-
-  if (__DEV__) {
-    console.error(`[Video:${featureType}] Error:`, message, error);
-  }
-
-  return message;
-}
-
 /**
  * Check if video features are supported
  */

package/src/infrastructure/utils/error-message-extractor.util.ts

@@ -0,0 +1,41 @@
+/**
+ * Error Message Extractor
+ * Extracts error messages from various API error formats
+ */
+
+declare const __DEV__: boolean;
+
+/**
+ * Extract error message from FAL API and other error formats
+ * Supports: Error instances, FAL API errors, generic objects
+ */
+export function extractErrorMessage(
+  error: unknown,
+  defaultMessage = "Processing failed",
+  debugPrefix?: string,
+): string {
+  let message = defaultMessage;
+
+  if (error instanceof Error) {
+    message = error.message;
+  } else if (typeof error === "object" && error !== null) {
+    const errObj = error as Record<string, unknown>;
+
+    // FAL API error format: {detail: [{msg, type, loc}]}
+    if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
+      message = String(errObj.detail[0].msg);
+    } else if (errObj.detail) {
+      message = JSON.stringify(errObj.detail);
+    } else if (errObj.message) {
+      message = String(errObj.message);
+    } else if (errObj.msg) {
+      message = String(errObj.msg);
+    }
+  }
+
+  if (__DEV__ && debugPrefix) {
+    console.error(`[${debugPrefix}] Error:`, message, error);
+  }
+
+  return message;
+}

package/src/infrastructure/utils/index.ts

@@ -3,6 +3,7 @@
  */
 
 export * from "./error-classifier.util";
+export * from "./error-message-extractor.util";
 export * from "./polling-interval.util";
 export * from "./progress-calculator.util";
 export * from "./status-checker.util";