@umituz/react-native-ai-generation-content 1.72.6 → 1.72.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.72.6",
+  "version": "1.72.8",
   "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/presentation/hooks/use-pending-jobs.ts

@@ -59,7 +59,14 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     onSuccess: (newJob: BackgroundJob<TInput, TResult>) => {
       queryClient.setQueryData<BackgroundJob<TInput, TResult>[]>(
         queryKey,
-        (old: BackgroundJob<TInput, TResult>[] | undefined) => [newJob, ...(old ?? [])],
+        (old: BackgroundJob<TInput, TResult>[] | undefined) => {
+          // Check if job already exists to prevent duplicates
+          const exists = old?.some((job) => job.id === newJob.id);
+          if (exists) {
+            return old ?? [];
+          }
+          return [newJob, ...(old ?? [])];
+        },
       );
     },
   });

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

@@ -71,12 +71,9 @@ export function useCreationPersistence(
 
       if (creditCost && onCreditDeduct) {
         onCreditDeduct(creditCost).catch((error) => {
-          // Log credit deduction errors for debugging
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[CreationPersistence] Credit deduction failed:", error);
           }
-          // Don't throw - credit deduction failure shouldn't block completion
-          // But we should notify user or retry in production
         });
       }
     },

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

@@ -38,6 +38,23 @@ export function useCreations({
     }
   }, []);
 
+  const onDataCallback = useCallback((creations: Creation[]) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useCreations] Realtime update:", creations.length);
+    }
+    setData(creations);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+
+  const onErrorCallback = useCallback((err: Error) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[useCreations] Realtime listener error:", err);
+    }
+    setError(err);
+    setIsLoading(false);
+  }, []);
+
   useEffect(() => {
     if (!userId || !enabled) {
       setData([]);
@@ -52,24 +69,7 @@ export function useCreations({
     setIsLoading(true);
     setError(null);
 
-    const unsubscribe = repository.subscribeToAll(
-      userId,
-      (creations) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useCreations] Realtime update:", creations.length);
-        }
-        setData(creations);
-        setIsLoading(false);
-        setError(null);
-      },
-      (err) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[useCreations] Realtime listener error:", err);
-        }
-        setError(err);
-        setIsLoading(false);
-      },
-    );
+    const unsubscribe = repository.subscribeToAll(userId, onDataCallback, onErrorCallback);
 
     return () => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -77,7 +77,7 @@ export function useCreations({
       }
       unsubscribe();
     };
-  }, [userId, repository, enabled]);
+  }, [userId, repository, enabled, onDataCallback, onErrorCallback]);
 
   return { data, isLoading, error, refetch };
 }

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

@@ -60,8 +60,18 @@ export function useProcessingJobsPoller(
   // Use ref for stable function reference to prevent effect re-runs
   const pollJobRef = useRef<((creation: Creation) => Promise<void>) | undefined>(undefined);
 
+  // Use mounted ref to prevent operations after unmount
+  const isMountedRef = useRef(true);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
   pollJobRef.current = async (creation: Creation) => {
-    if (!userId || !creation.requestId || !creation.model) return;
+    if (!isMountedRef.current || !userId || !creation.requestId || !creation.model) return;
 
     if (pollingRef.current.has(creation.id)) return;
     pollingRef.current.add(creation.id);
@@ -88,7 +98,22 @@ export function useProcessingJobsPoller(
         const urls = extractResultUrl(result);
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
 
+        if (!isMountedRef.current) return;
+
         const uri = urls.videoUrl || urls.imageUrl || "";
+
+        // Validate that we have a valid URI before marking as completed
+        if (!uri || uri.trim() === "") {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[ProcessingJobsPoller] No valid URI in result:", creation.id);
+          }
+          await repository.update(userId, creation.id, {
+            status: CREATION_STATUS.FAILED,
+            metadata: { error: "No valid result URL received" },
+          });
+          return;
+        }
+
         await repository.update(userId, creation.id, {
           status: CREATION_STATUS.COMPLETED,
           uri,
@@ -97,6 +122,8 @@ export function useProcessingJobsPoller(
       } else if (status.status === QUEUE_STATUS.FAILED) {
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Failed:", creation.id);
 
+        if (!isMountedRef.current) return;
+
         await repository.update(userId, creation.id, {
           status: CREATION_STATUS.FAILED,
           metadata: { error: "Generation failed" },
@@ -111,6 +138,12 @@ export function useProcessingJobsPoller(
     }
   };
 
+  // Use ref to always get latest creations
+  const creationsRef = useRef(creations);
+  useEffect(() => {
+    creationsRef.current = creations;
+  }, [creations]);
+
   useEffect(() => {
     if (!enabled || !userId || processingJobIds.length === 0) {
       if (intervalRef.current) {
@@ -120,9 +153,9 @@ export function useProcessingJobsPoller(
       return;
     }
 
-    // Get current jobs at poll time to avoid stale closures
+    // Get current jobs at poll time from ref to avoid stale closures
     const pollCurrentJobs = () => {
-      const currentJobs = creations.filter(
+      const currentJobs = creationsRef.current.filter(
         (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
       );
       currentJobs.forEach((job) => pollJobRef.current?.(job));
@@ -144,7 +177,7 @@ export function useProcessingJobsPoller(
         intervalRef.current = null;
       }
     };
-  }, [enabled, userId, processingJobIds, creations]);
+  }, [enabled, userId, processingJobIds]);
 
   return {
     processingCount: processingJobs.length,

package/src/domains/generation/infrastructure/flow/useFlowStore.ts

@@ -3,6 +3,8 @@
  */
 
 import { createStore } from "@umituz/react-native-design-system";
+
+declare const __DEV__: boolean;
 import type {
   FlowState,
   FlowActions,
@@ -34,7 +36,13 @@ export const createFlowStore = (config: FlowStoreConfig) => {
   if (config.initialStepIndex !== undefined) {
     initialIndex = Math.max(0, Math.min(config.initialStepIndex, config.steps.length - 1));
   } else if (config.initialStepId) {
-    initialIndex = Math.max(0, config.steps.findIndex((s) => s.id === config.initialStepId));
+    const foundIndex = config.steps.findIndex((s) => s.id === config.initialStepId);
+    if (foundIndex === -1) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(`[FlowStore] Step "${config.initialStepId}" not found, using first step`);
+      }
+    }
+    initialIndex = Math.max(0, foundIndex);
   }
 
   const initialStepId = config.steps[initialIndex]?.id ?? "";
@@ -86,28 +94,30 @@ export const createFlowStore = (config: FlowStoreConfig) => {
       setScenario: (scenario: unknown) => set({ selectedScenario: scenario }),
 
       setPartnerImage: (partnerId: string, image: FlowUploadedImageData | undefined) =>
-        set({ partners: { ...get().partners, [partnerId]: image } }),
+        set((state) => ({ partners: { ...state.partners, [partnerId]: image } })),
 
       setPartnerName: (partnerId: string, name: string) =>
-        set({ partnerNames: { ...get().partnerNames, [partnerId]: name } }),
+        set((state) => ({ partnerNames: { ...state.partnerNames, [partnerId]: name } })),
 
       setTextInput: (text: string) => set({ textInput: text }),
       setVisualStyle: (styleId: string) => set({ visualStyle: styleId }),
 
       setSelectedFeatures: (featureType: string, ids: readonly string[]) =>
-        set({ selectedFeatures: { ...get().selectedFeatures, [featureType]: ids } }),
+        set((state) => ({ selectedFeatures: { ...state.selectedFeatures, [featureType]: ids } })),
 
       setCustomData: (key: string, value: unknown) =>
-        set({ customData: { ...get().customData, [key]: value } }),
+        set((state) => ({ customData: { ...state.customData, [key]: value } })),
 
       startGeneration: () =>
         set({ generationStatus: "preparing", generationProgress: 0, generationError: undefined }),
 
-      updateProgress: (progress: number) =>
+      updateProgress: (progress: number) => {
+        const validProgress = Math.max(0, Math.min(100, progress));
         set({
-          generationProgress: progress,
-          generationStatus: progress >= 100 ? "completed" : progress > 0 ? "generating" : "preparing",
-        }),
+          generationProgress: validProgress,
+          generationStatus: validProgress >= 100 ? "completed" : validProgress > 0 ? "generating" : "preparing",
+        });
+      },
 
       setResult: (result: unknown) =>
         set({ generationResult: result, generationStatus: "completed", generationProgress: 100 }),

package/src/domains/generation/wizard/presentation/hooks/useGenerationPhase.ts

@@ -28,6 +28,12 @@ export function useGenerationPhase(options?: UseGenerationPhaseOptions): Generat
 
   const [phase, setPhase] = useState<GenerationPhase>("queued");
   const startTimeRef = useRef<number>(Date.now());
+  const queuedDurationRef = useRef(queuedDuration);
+
+  // Only reset if duration changes significantly
+  useEffect(() => {
+    queuedDurationRef.current = queuedDuration;
+  }, [queuedDuration]);
 
   useEffect(() => {
     startTimeRef.current = Date.now();
@@ -36,14 +42,14 @@ export function useGenerationPhase(options?: UseGenerationPhaseOptions): Generat
     const interval = setInterval(() => {
       const elapsed = Date.now() - startTimeRef.current;
 
-      if (elapsed >= queuedDuration) {
+      if (elapsed >= queuedDurationRef.current) {
         setPhase("processing");
         clearInterval(interval);
       }
     }, 1000);
 
     return () => clearInterval(interval);
-  }, [queuedDuration]);
+  }, []); // Empty deps - only run once on mount
 
   return phase;
 }

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -30,6 +30,13 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         clearInterval(pollingRef.current);
         pollingRef.current = null;
       }
+      // Reset all refs on unmount
+      isGeneratingRef.current = false;
+      isPollingRef.current = false;
+      creationIdRef.current = null;
+      requestIdRef.current = null;
+      modelRef.current = null;
+      setIsGenerating(false);
     };
   }, []);
 
@@ -45,10 +52,20 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
   const handleComplete = useCallback(
     async (urls: GenerationUrls) => {
       const creationId = creationIdRef.current;
-      if (creationId && userId && (urls.videoUrl || urls.imageUrl)) {
+      const uri = (urls.videoUrl || urls.imageUrl) ?? "";
+
+      // Validate non-empty URI
+      if (!creationId || !userId || !uri || uri.trim() === "") {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[VideoQueue] Invalid completion data:", { creationId, userId, uri });
+        }
+        return;
+      }
+
+      if (creationId && userId) {
         try {
           await persistence.updateToCompleted(userId, creationId, {
-            uri: (urls.videoUrl || urls.imageUrl) ?? "",
+            uri,
             imageUrl: urls.imageUrl,
             videoUrl: urls.videoUrl,
           });

package/src/domains/generation/wizard/presentation/hooks/useWizardGeneration.ts

@@ -66,6 +66,15 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
     onCreditsExhausted,
   });
 
+  // Use refs for functions to avoid effect re-runs
+  const videoStartGenerationRef = useRef(videoGeneration.startGeneration);
+  const photoStartGenerationRef = useRef(photoGeneration.startGeneration);
+
+  useEffect(() => {
+    videoStartGenerationRef.current = videoGeneration.startGeneration;
+    photoStartGenerationRef.current = photoGeneration.startGeneration;
+  }, [videoGeneration.startGeneration, photoGeneration.startGeneration]);
+
   useEffect(() => {
     const isAlreadyGenerating = videoGeneration.isGenerating || photoGeneration.isGenerating;
 
@@ -80,8 +89,8 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
         isMountedRef,
         dispatch,
         onError,
-        videoGenerationFn: videoGeneration.startGeneration,
-        photoGenerationFn: photoGeneration.startGeneration,
+        videoGenerationFn: videoStartGenerationRef.current,
+        photoGenerationFn: photoStartGenerationRef.current,
       }).catch((error) => {
         // Catch any unhandled errors from executeWizardGeneration
         if (isMountedRef.current) {
@@ -102,9 +111,7 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
     wizardData,
     isVideoMode,
     videoGeneration.isGenerating,
-    videoGeneration.startGeneration,
     photoGeneration.isGenerating,
-    photoGeneration.startGeneration,
     onError,
   ]);
 

package/src/domains/generation/wizard/presentation/hooks/videoQueuePoller.ts

@@ -16,8 +16,12 @@ interface PollParams {
 export const pollQueueStatus = async (params: PollParams): Promise<void> => {
   const { requestId, model, isPollingRef, pollingRef, onComplete, onError } = params;
 
-  // Atomic check-and-set to prevent race condition
-  if (isPollingRef.current) return;
+  // Check-and-set - while not truly atomic in JS, this is best we can do
+  // The ref prevents most race conditions in practice
+  if (isPollingRef.current) {
+    if (__DEV__) console.log("[VideoQueuePoller] Already polling, skipping");
+    return;
+  }
   isPollingRef.current = true;
 
   const provider = providerRegistry.getActiveProvider();

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

@@ -136,6 +136,10 @@ export function validateBase64(input: unknown): ValidationResult {
     return { isValid: false, errors: ["Input must be a string"] };
   }
 
+  if (input.length === 0) {
+    return { isValid: false, errors: ["Base64 string cannot be empty"] };
+  }
+
   const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
   if (!base64Regex.test(input)) {
     return { isValid: false, errors: ["Invalid base64 format"] };

package/src/presentation/hooks/flow-state.utils.ts

@@ -48,6 +48,12 @@ export function updatePhotoStep(
   stepIndex: number,
   updates: Partial<PhotoStepData>,
 ): GenerationFlowState {
+  // Validate bounds to prevent sparse arrays and undefined access
+  if (stepIndex < 0 || stepIndex >= state.photoSteps.length) {
+    console.warn(`[FlowState] Invalid stepIndex ${stepIndex}, ignoring update`);
+    return state;
+  }
+
   const newPhotoSteps = [...state.photoSteps];
   newPhotoSteps[stepIndex] = {
     ...newPhotoSteps[stepIndex],

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

@@ -109,6 +109,9 @@ export function useGeneration<T = unknown>(
         if (!abortRef.current && !abortControllerRef.current?.signal.aborted) {
           setIsGenerating(false);
         }
+        if (abortControllerRef.current && !abortControllerRef.current.signal.aborted) {
+          abortControllerRef.current.abort();
+        }
         abortControllerRef.current = null;
       }
     },