@umituz/react-native-ai-fal-provider 2.0.29 → 2.0.30

package/src/infrastructure/utils/string-format.util.ts

@@ -0,0 +1,73 @@
+/**
+ * String Formatting Utilities
+ * Functions for formatting and manipulating strings
+ */
+
+/**
+ * Truncate text with ellipsis
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 3) + "...";
+}
+
+/**
+ * Capitalize first letter of string
+ */
+export function capitalize(text: string): string {
+  if (!text) return text;
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+/**
+ * Convert string to title case
+ */
+export function toTitleCase(text: string): string {
+  return text
+    .toLowerCase()
+    .split(" ")
+    .map((word) => capitalize(word))
+    .join(" ");
+}
+
+/**
+ * Convert string to slug
+ */
+export function toSlug(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Format list of items with conjunction
+ */
+export function formatList(items: readonly string[], conjunction: string = "and"): string {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0] ?? "";
+  if (items.length === 2) return items.join(` ${conjunction} `);
+
+  const allButLast = items.slice(0, -1);
+  const last = items[items.length - 1];
+  return `${allButLast.join(", ")}, ${conjunction} ${last}`;
+}
+
+/**
+ * Pluralize word based on count
+ */
+export function pluralize(word: string, count: number): string {
+  if (count === 1) return word;
+  return `${word}s`;
+}
+
+/**
+ * Format count with plural word
+ */
+export function formatCount(word: string, count: number): string {
+  return `${count} ${pluralize(word, count)}`;
+}

package/src/presentation/hooks/use-fal-generation.ts

@@ -6,8 +6,10 @@
 import { useState, useCallback, useRef, useEffect } from "react";
 import { falProvider } from "../../infrastructure/services/fal-provider";
 import { mapFalError } from "../../infrastructure/utils/error-mapper";
-import type { FalJobInput, FalQueueStatus, FalLogEntry } from "../../domain/entities/fal.types";
+import { FalGenerationStateManager } from "../../infrastructure/utils/fal-generation-state-manager.util";
+import type { FalJobInput, FalQueueStatus } from "../../domain/entities/fal.types";
 import type { FalErrorInfo } from "../../domain/entities/error.types";
+import type { JobStatus } from "../../domain/types";
 
 export interface UseFalGenerationOptions {
   timeoutMs?: number;
@@ -28,6 +30,19 @@ export interface UseFalGenerationResult<T> {
   reset: () => void;
 }
 
+function convertJobStatusToFalQueueStatus(status: JobStatus, currentRequestId: string | null): FalQueueStatus {
+  return {
+    status: status.status as FalQueueStatus["status"],
+    requestId: status.requestId ?? currentRequestId ?? "",
+    logs: status.logs?.map((log) => ({
+      message: log.message,
+      level: log.level,
+      timestamp: log.timestamp,
+    })),
+    queuePosition: status.queuePosition,
+  };
+}
+
 export function useFalGeneration<T = unknown>(
   options?: UseFalGenerationOptions
 ): UseFalGenerationResult<T> {
@@ -36,76 +51,82 @@ export function useFalGeneration<T = unknown>(
   const [isLoading, setIsLoading] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
 
-  const lastRequestRef = useRef<{ endpoint: string; input: FalJobInput } | null>(null);
-  const currentRequestIdRef = useRef<string | null>(null);
-  const isMountedRef = useRef(true);
+  const stateManagerRef = useRef<FalGenerationStateManager<T> | null>(null);
+  const optionsRef = useRef(options);
+
+  // Keep optionsRef updated without causing effect re-runs
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
 
-  // Cleanup on unmount
   useEffect(() => {
-    isMountedRef.current = true;
+    stateManagerRef.current = new FalGenerationStateManager<T>({
+      onProgress: (status) => {
+        optionsRef.current?.onProgress?.(status);
+      },
+    });
+
+    stateManagerRef.current.setIsMounted(true);
+
     return () => {
-      isMountedRef.current = false;
+      stateManagerRef.current?.setIsMounted(false);
       if (falProvider.hasRunningRequest()) {
         falProvider.cancelCurrentRequest();
       }
     };
-  }, []);
+  }, []); // Empty deps - only run on mount/unmount
 
   const generate = useCallback(
     async (modelEndpoint: string, input: FalJobInput): Promise<T | null> => {
-      if (!isMountedRef.current) return null;
+      const stateManager = stateManagerRef.current;
+      if (!stateManager || !stateManager.checkMounted()) return null;
 
-      lastRequestRef.current = { endpoint: modelEndpoint, input };
+      stateManager.setLastRequest(modelEndpoint, input);
       setIsLoading(true);
       setError(null);
       setData(null);
-      currentRequestIdRef.current = null;
+      stateManager.setCurrentRequestId(null);
       setIsCancelling(false);
 
       try {
         const result = await falProvider.subscribe<T>(modelEndpoint, input, {
-          timeoutMs: options?.timeoutMs,
-          onQueueUpdate: (status) => {
-            if (!isMountedRef.current) return;
-            if (status.requestId) {
-              currentRequestIdRef.current = status.requestId;
-            }
-            options?.onProgress?.({
-              status: status.status,
-              requestId: status.requestId ?? currentRequestIdRef.current ?? "",
-              logs: status.logs?.map((log: FalLogEntry) => ({
-                message: log.message,
-                level: log.level,
-                timestamp: log.timestamp,
-              })),
-              queuePosition: status.queuePosition,
-            });
+          timeoutMs: optionsRef.current?.timeoutMs,
+          onQueueUpdate: (status: JobStatus) => {
+            const falStatus = convertJobStatusToFalQueueStatus(
+              status,
+              stateManager.getCurrentRequestId()
+            );
+            stateManager.handleQueueUpdate(falStatus);
           },
         });
 
-        if (!isMountedRef.current) return null;
+        if (!stateManager.checkMounted()) return null;
         setData(result);
         return result;
       } catch (err) {
-        if (!isMountedRef.current) return null;
+        if (!stateManager.checkMounted()) return null;
         const errorInfo = mapFalError(err);
         setError(errorInfo);
-        options?.onError?.(errorInfo);
+        optionsRef.current?.onError?.(errorInfo);
         return null;
       } finally {
-        if (isMountedRef.current) {
+        if (stateManager.checkMounted()) {
           setIsLoading(false);
           setIsCancelling(false);
         }
       }
     },
-    [options]
+    [] // No deps - we use optionsRef.current inside
   );
 
   const retry = useCallback(async (): Promise<T | null> => {
-    if (!lastRequestRef.current) return null;
-    const { endpoint, input } = lastRequestRef.current;
-    return generate(endpoint, input);
+    const stateManager = stateManagerRef.current;
+    if (!stateManager) return null;
+
+    const lastRequest = stateManager.getLastRequest();
+    if (!lastRequest) return null;
+
+    return generate(lastRequest.endpoint, lastRequest.input);
   }, [generate]);
 
   const cancel = useCallback(() => {
@@ -121,16 +142,17 @@ export function useFalGeneration<T = unknown>(
     setError(null);
     setIsLoading(false);
     setIsCancelling(false);
-    lastRequestRef.current = null;
-    currentRequestIdRef.current = null;
+    stateManagerRef.current?.clearLastRequest();
   }, [cancel]);
 
+  const requestId = stateManagerRef.current?.getCurrentRequestId() ?? null;
+
   return {
     data,
     error,
     isLoading,
     isRetryable: error?.retryable ?? false,
-    requestId: currentRequestIdRef.current,
+    requestId,
     isCancelling,
     generate,
     retry,

package/src/presentation/hooks/use-models.ts

@@ -12,7 +12,6 @@
 import { useState, useEffect, useCallback, useMemo } from "react";
 import { falModelsService } from "../../infrastructure/services/fal-models.service";
 import type { FalModelConfig } from "../../domain/constants/default-models.constants";
-import { DEFAULT_CREDIT_COSTS, DEFAULT_MODEL_IDS } from "../../domain/constants/default-models.constants";
 import type {
   ModelType,
   ModelSelectionConfig,
@@ -36,28 +35,16 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
-  const defaultCreditCost = config?.defaultCreditCost ?? DEFAULT_CREDIT_COSTS[type];
-  const defaultModelId = config?.defaultModelId ?? DEFAULT_MODEL_IDS[type];
-
   const loadModels = useCallback(() => {
     setIsLoading(true);
     setError(null);
 
-    const fetchedModels = falModelsService.getModels(type);
-    setModels(fetchedModels);
-
-    const targetId = config?.initialModelId ?? defaultModelId;
-    const initial =
-      fetchedModels.find((m) => m.id === targetId) ||
-      fetchedModels.find((m) => m.isDefault) ||
-      fetchedModels[0];
-
-    if (initial) {
-      setSelectedModel(initial);
-    }
+    const selectionData = falModelsService.getModelSelectionData(type, config);
+    setModels(selectionData.models);
+    setSelectedModel(selectionData.selectedModel);
 
     setIsLoading(false);
-  }, [type, config?.initialModelId, defaultModelId]);
+  }, [type, config]);
 
   useEffect(() => {
     loadModels();
@@ -68,24 +55,21 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
       const model = models.find((m) => m.id === modelId);
       if (model) {
         setSelectedModel(model);
-      } else {
-        // eslint-disable-next-line no-console
-        console.warn(`Model not found: ${modelId}. Available models:`, models.map(m => m.id));
       }
     },
     [models],
   );
 
   const creditCost = useMemo(() => {
-    if (selectedModel?.pricing?.freeUserCost) {
-      return selectedModel.pricing.freeUserCost;
-    }
-    return defaultCreditCost;
-  }, [selectedModel, defaultCreditCost]);
+    return falModelsService.getModelCreditCost(
+      selectedModel?.id ?? falModelsService.getDefaultModelId(type),
+      type
+    );
+  }, [selectedModel, type]);
 
   const modelId = useMemo(() => {
-    return selectedModel?.id ?? defaultModelId;
-  }, [selectedModel, defaultModelId]);
+    return selectedModel?.id ?? falModelsService.getDefaultModelId(type);
+  }, [selectedModel, type]);
 
   return {
     models,