@umituz/react-native-ai-generation-content 1.90.6 → 1.90.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.90.6",
+  "version": "1.90.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/generation/infrastructure/couple-generation-builder/builder-couple-preparation.ts

@@ -4,7 +4,7 @@
  * Handles photo URI extraction and appearance analysis
  */
 
-import { getAppearanceContext } from "../../appearance-analysis";
+import { getAppearanceContext } from "../appearance-analysis";
 import { logBuilderStep } from "./utils";
 import type { CoupleGenerationInputParams } from "./types";
 

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

@@ -9,7 +9,7 @@ import {
   refinePromptForCouple,
   prependContext,
 } from "../../../../infrastructure/utils/couple-input.util";
-import { getAppearanceContext } from "../../appearance-analysis";
+import { getAppearanceContext } from "../appearance-analysis";
 import type {
   ScenarioGenerationInputParams,
   CoupleGenerationInput,

package/src/domains/generation/presentation/useAIGeneration.hook.ts

@@ -82,8 +82,8 @@ export function useAIGeneration(
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: alertMessages || DEFAULT_ALERT_MESSAGES,
-    onSuccess,
-    onError: onError ? (error) => onError(error.message) : undefined,
+    onSuccess: async (result) => onSuccess?.(result),
+    onError: onError ? async (error) => onError(error.message) : undefined,
   });
 
   return {

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

@@ -2,7 +2,10 @@
  * Generic Photo Upload State Hook - Type Definitions
  */
 
-import type { UploadedImage } from "../../../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
+
+// Re-export for use in this module
+export type { UploadedImage };
 
 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 "../../../../../presentation/hooks/generation/useAIGenerateState";
 import type { PhotoUploadConfig, PhotoUploadError, PhotoUploadTranslations } from "./types";
 
 export function usePhotoUploadStateLogic(

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

@@ -3,7 +3,7 @@
  */
 
 import { useCallback } from "react";
-import type { GenerationUrls } from "../../generation-result.utils";
+import type { GenerationUrls } from "../generation-result.utils";
 import type {
   UseVideoQueueGenerationProps,
 } from "../use-video-queue-generation.types";

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

@@ -56,7 +56,7 @@ export function usePollStatus(
  * Hook to sync callback refs
  */
 export function useCallbackRefs(
-  handleComplete: (urls: import("../../generation-result.utils").GenerationUrls) => Promise<void>,
+  handleComplete: (urls: import("../generation-result.utils").GenerationUrls) => Promise<void>,
   handleError: (errorMsg: string) => Promise<void>,
   pollStatus: () => Promise<void>,
   refs: VideoQueueRefs,

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

@@ -0,0 +1,131 @@
+/**
+ * Generation Orchestrator - Main Implementation
+ * Handles AI generation execution with network check, moderation, credit deduction, and error handling
+ */
+
+import { useCallback, useState, useRef } from "react";
+import type {
+  GenerationStatus,
+  GenerationState,
+  GenerationError,
+  GenerationStrategy,
+  GenerationConfig,
+  UseGenerationOrchestratorReturn,
+} from "./orchestrator-types";
+
+/**
+ * Main generation orchestrator hook
+ * Manages the complete generation lifecycle with error handling and state management
+ */
+export function useGenerationOrchestrator<TInput, TResult>(
+  strategy: GenerationStrategy<TInput, TResult>,
+  config: GenerationConfig,
+): UseGenerationOrchestratorReturn<TInput, TResult> {
+  const [status, setStatus] = useState<GenerationStatus>("idle");
+  const [result, setResult] = useState<TResult | null>(null);
+  const [error, setError] = useState<GenerationError | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const isGenerating = status === "checking" || status === "generating" || status === "saving";
+
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+    setError(null);
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+  }, []);
+
+  const generate = useCallback(
+    async (input: TInput): Promise<TResult | void> => {
+      // Reset state
+      reset();
+
+      // Create abort controller for this generation
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+
+      try {
+        // Call lifecycle start hook
+        await config.lifecycle?.onStart?.();
+
+        // Set checking status
+        setStatus("checking");
+
+        // Execute generation
+        setStatus("generating");
+        const generationResult = await strategy.execute(input, abortController.signal);
+
+        // Save result if save strategy provided
+        if (strategy.save && config.userId) {
+          setStatus("saving");
+          await strategy.save(generationResult, config.userId);
+        }
+
+        // Success
+        setStatus("success");
+        setResult(generationResult);
+
+        // Call success callbacks
+        await config.onSuccess?.(generationResult);
+        await config.lifecycle?.onComplete?.("success", generationResult);
+
+        // Show success alert if provided
+        if (config.alertMessages?.success) {
+          // Alert would be shown here in a real implementation
+          console.log(config.alertMessages.success);
+        }
+
+        return generationResult;
+      } catch (err) {
+        // Determine error type and create error object
+        let errorType: GenerationError["type"] = "unknown";
+        let errorMessage = "An error occurred during generation";
+
+        if (err instanceof Error) {
+          if (err.message.includes("network") || err.message.includes("fetch")) {
+            errorType = "network";
+            errorMessage = config.alertMessages?.networkError || err.message;
+          } else if (err.message.includes("moderation") || err.message.includes("content")) {
+            errorType = "moderation";
+            errorMessage = config.alertMessages?.moderationError || err.message;
+          } else if (err.message.includes("credits") || err.message.includes("insufficient")) {
+            errorType = "credits";
+            errorMessage = config.alertMessages?.insufficientCredits || err.message;
+          } else if (err.message.includes("save") || err.message.includes("storage")) {
+            errorType = "save";
+            errorMessage = config.alertMessages?.saveFailed || err.message;
+          } else {
+            errorType = "generation";
+            errorMessage = config.alertMessages?.generationError || err.message;
+          }
+        }
+
+        const generationError: GenerationError = {
+          type: errorType,
+          message: errorMessage,
+          originalError: err instanceof Error ? err : undefined,
+        };
+
+        setStatus("error");
+        setError(generationError);
+
+        // Call error callbacks
+        await config.onError?.(generationError);
+        await config.lifecycle?.onComplete?.("error", undefined, generationError);
+      } finally {
+        abortControllerRef.current = null;
+      }
+    },
+    [strategy, config, reset],
+  );
+
+  return {
+    generate,
+    reset,
+    status,
+    isGenerating,
+    result,
+    error,
+  };
+}

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

@@ -71,8 +71,8 @@ export const useDualImageGeneration = (
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: (result) => onSuccess?.(result as string),
-    onError: (error) => onError?.(error.message),
+    onSuccess: async (result) => onSuccess?.(result as string),
+    onError: async (error) => onError?.(error.message),
   });
 
   // Process handler

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 as (result: unknown) => void,
-    onError: handleError,
+    onSuccess: onSuccess ? async (result) => onSuccess(result) : 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 as (result: unknown) => void,
-    onError: handleError,
+    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onError: async (error) => handleError(error),
   });
 };

package/src/shared/hooks/factories/createGenerationHook.ts

@@ -0,0 +1,142 @@
+/**
+ * Generic Generation Hook Factory - Main Implementation
+ * Creates type-safe generation hooks with error handling, progress tracking, and abort support
+ */
+
+import { useState, useRef, useCallback, useEffect } from "react";
+import type {
+  GenerationState,
+  GenerationCallbacks,
+  GenerationHookConfig,
+  GenerationHookReturn,
+} from "./generation-hook-types";
+import {
+  INITIAL_STATE,
+  createAbortHandler,
+  createProgressSetter,
+  createErrorSetter,
+  createCleanupEffect,
+  createCallbackUpdater,
+} from "./generation-hook-utils";
+
+/**
+ * Creates a generation hook with standard configuration
+ */
+export function createGenerationHook<TRequest, TResult>(
+  defaultConfig: GenerationHookConfig<TRequest, TResult>) {
+  return function useGenerationHook(
+    request: TRequest | null,
+    callbacks?: GenerationCallbacks<TResult>,
+    configOverrides?: Partial<GenerationHookConfig<TRequest, TResult>>
+  ): GenerationHookReturn<TRequest, TResult> {
+    const config = { ...defaultConfig, ...configOverrides };
+    const [generationState, setGenerationState] = useState<GenerationState>(INITIAL_STATE);
+
+    const abortControllerRef = useRef<AbortController | null>(null);
+    const isMountedRef = useRef(true);
+
+    const onSuccessRef = useRef(callbacks?.onSuccess);
+    const onErrorRef = useRef(callbacks?.onError);
+    const onProgressRef = useRef(callbacks?.onProgress);
+
+    // Update callbacks when they change
+    useEffect(() => {
+      createCallbackUpdater(onSuccessRef, onErrorRef, onProgressRef, callbacks || {});
+    }, [callbacks]);
+
+    // Cleanup on unmount
+    useEffect(() => {
+      return createCleanupEffect(isMountedRef, abortControllerRef);
+    }, []);
+
+    const setProgress = createProgressSetter(
+      onProgressRef,
+      setGenerationState,
+      isMountedRef
+    );
+
+    const setError = createErrorSetter(
+      onErrorRef,
+      setGenerationState,
+      isMountedRef
+    );
+
+    const abort = createAbortHandler(abortControllerRef, setGenerationState);
+
+    const handleGenerate = useCallback(
+      async (req: TRequest): Promise<TResult | null> => {
+        // Validate if validator provided
+        if (config.validate) {
+          const validationError = config.validate(req);
+          if (validationError) {
+            setError(validationError);
+            return null;
+          }
+        }
+
+        setGenerationState((prev) => ({
+          ...prev,
+          isGenerating: true,
+          error: null,
+          progress: 0,
+        }));
+
+        try {
+          const abortController = new AbortController();
+          abortControllerRef.current = abortController;
+
+          const result = await config.execute(req, abortController.signal);
+
+          if (isMountedRef.current) {
+            setGenerationState((prev) => ({
+              ...prev,
+              isGenerating: false,
+              progress: 100,
+            }));
+            onSuccessRef.current?.(result);
+          }
+
+          return result;
+        } catch (err) {
+          if (!abortControllerRef.current?.signal.aborted && isMountedRef.current) {
+            const errorMessage = config.transformError
+              ? config.transformError(err)
+              : err instanceof Error
+              ? err.message
+              : "Generation failed";
+            setError(errorMessage);
+          }
+          return null;
+        } finally {
+          abortControllerRef.current = null;
+        }
+      },
+      [config, setError]
+    );
+
+    return {
+      generationState,
+      handleGenerate,
+      setProgress,
+      setError,
+      abort,
+    };
+  };
+}
+
+/**
+ * Creates a generation hook with built-in progress tracking
+ */
+export function createGenerationHookWithProgress<TRequest, TResult>(
+  defaultConfig: GenerationHookConfig<TRequest, TResult>
+) {
+  return function useGenerationWithProgress(
+    request: TRequest | null,
+    callbacks?: GenerationCallbacks<TResult>,
+    configOverrides?: Partial<GenerationHookConfig<TRequest, TResult>>
+  ): GenerationHookReturn<TRequest, TResult> {
+    // Reuse the standard hook
+    const useStandardHook = createGenerationHook(defaultConfig);
+    return useStandardHook(request, callbacks, configOverrides);
+  };
+}