@umituz/react-native-ai-generation-content 1.90.2 → 1.90.4

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

@@ -1,276 +0,0 @@
-/**
- * Generation Orchestrator
- * Handles AI generation execution with network check, moderation, credit deduction, and error handling
- */
-
-import { useState, useCallback, useRef, useEffect } from "react";
-import { useAlert } from "@umituz/react-native-design-system/molecules";
-import { useOfflineStore } from "@umituz/react-native-design-system/offline";
-import { createGenerationError, getAlertMessage, parseError } from "./errors";
-import { handleModeration } from "./moderation-handler";
-import type {
-  GenerationStrategy,
-  GenerationConfig,
-  GenerationState,
-  GenerationError,
-  UseGenerationOrchestratorReturn,
-} from "./types";
-
-const getInitialState = <T>(): GenerationState<T> => ({
-  status: "idle",
-  isGenerating: false,
-  result: null,
-  error: null,
-});
-
-export const useGenerationOrchestrator = <TInput, TResult>(
-  strategy: GenerationStrategy<TInput, TResult>,
-  config: GenerationConfig,
-): UseGenerationOrchestratorReturn<TInput, TResult> => {
-  const { userId, alertMessages, onSuccess, onError, moderation, lifecycle } = config;
-
-  const [state, setState] = useState<GenerationState<TResult>>(getInitialState<TResult>());
-  const isGeneratingRef = useRef(false);
-  const isMountedRef = useRef(true);
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const cleanupTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  // Stable refs for callbacks — prevents useCallback deps from thrashing when
-  // callers pass inline functions (which create new references every render).
-  const onSuccessRef = useRef(onSuccess);
-  const onErrorRef = useRef(onError);
-  // Update refs in render body (not useEffect) so they're always in sync — no 1-frame delay
-  onSuccessRef.current = onSuccess;
-  onErrorRef.current = onError;
-
-  const offlineStore = useOfflineStore();
-  const { showError, showSuccess } = useAlert();
-
-  useEffect(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-      abortControllerRef.current?.abort();
-      // Clear any pending lifecycle complete timeout
-      if (cleanupTimeoutRef.current) {
-        clearTimeout(cleanupTimeoutRef.current);
-        cleanupTimeoutRef.current = null;
-      }
-    };
-  }, []);
-
-  const handleLifecycleComplete = useCallback(
-    (status: "success" | "error", result?: TResult, error?: GenerationError) => {
-      if (!lifecycle?.onComplete) return;
-
-      // Clear any existing timeout first
-      if (cleanupTimeoutRef.current) {
-        clearTimeout(cleanupTimeoutRef.current);
-        cleanupTimeoutRef.current = null;
-      }
-
-      const delay = lifecycle.completeDelay ?? 500;
-      cleanupTimeoutRef.current = setTimeout(() => {
-        if (isMountedRef.current) {
-          lifecycle.onComplete?.(status, result, error);
-        }
-        cleanupTimeoutRef.current = null;
-      }, delay);
-    },
-    [lifecycle],
-  );
-
-  const executeGeneration = useCallback(
-    async (input: TInput) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ----------------------------------------");
-        console.log("[Orchestrator] executeGeneration() called");
-      }
-
-      // Check abort signal before starting
-      if (abortControllerRef.current?.signal.aborted) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Aborted before generation started");
-        }
-        throw new Error("Generation aborted");
-      }
-
-      setState((prev) => ({ ...prev, status: "generating" }));
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] State: generating - calling strategy.execute()");
-      }
-
-      const result = await strategy.execute(input);
-
-      // Check abort signal after execution
-      if (abortControllerRef.current?.signal.aborted) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Aborted after generation completed");
-        }
-        throw new Error("Generation aborted");
-      }
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] strategy.execute() completed");
-      }
-
-      if (strategy.save && userId) {
-        // Check abort signal before save
-        if (abortControllerRef.current?.signal.aborted) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] Aborted before save");
-          }
-          throw new Error("Generation aborted");
-        }
-
-        if (isMountedRef.current) setState((prev) => ({ ...prev, status: "saving" }));
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Saving result to Firestore");
-        }
-        try {
-          await strategy.save(result, userId);
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] Result saved successfully");
-          }
-        } catch (saveErr) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ERROR: Save failed:", saveErr);
-          }
-          // Update state to error on save failure
-          if (isMountedRef.current) {
-            setState((prev) => ({ ...prev, status: "error", isGenerating: false }));
-          }
-          throw createGenerationError("save", alertMessages.saveFailed, saveErr instanceof Error ? saveErr : undefined);
-        }
-      }
-
-      // Final abort check before success
-      if (abortControllerRef.current?.signal.aborted) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Aborted before success callback");
-        }
-        throw new Error("Generation aborted");
-      }
-
-      if (isMountedRef.current) setState({ status: "success", isGenerating: false, result, error: null });
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ✅ Generation SUCCESS");
-        console.log("[Orchestrator] ========================================");
-      }
-
-      if (alertMessages.success) showSuccess("Success", alertMessages.success);
-      await onSuccessRef.current?.(result);
-      handleLifecycleComplete("success", result);
-      return result;
-    },
-    [strategy, userId, alertMessages, showSuccess, handleLifecycleComplete],
-  );
-
-  const generate = useCallback(
-    async (input: TInput): Promise<TResult | void> => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ========================================");
-        console.log("[Orchestrator] generate() called with input:", JSON.stringify(input).substring(0, 200));
-        console.log("[Orchestrator] isGenerating:", isGeneratingRef.current);
-        console.log("[Orchestrator] userId:", userId);
-      }
-
-      if (isGeneratingRef.current) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] BLOCKED: Already generating");
-        }
-        return;
-      }
-
-      // Create new AbortController for this generation
-      abortControllerRef.current = new AbortController();
-      isGeneratingRef.current = true;
-      let moderationPending = false;
-      setState({ ...getInitialState<TResult>(), status: "checking", isGenerating: true });
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] State set to 'checking', isGenerating: true");
-      }
-
-      try {
-        // Check online status inside the try block to avoid dependency on offlineStore.isOnline
-        if (!offlineStore.isOnline) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ERROR: User is offline");
-          }
-          throw createGenerationError("network", alertMessages.networkError);
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Online check passed");
-        }
-
-        // Check if aborted before moderation
-        if (abortControllerRef.current.signal.aborted) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ERROR: Generation aborted (2)");
-          }
-          throw new Error("Generation aborted");
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Starting moderation check");
-        }
-
-        const result = await handleModeration({
-          input,
-          moderation,
-          alertMessages,
-          isMountedRef,
-          isGeneratingRef,
-          setState: (s) => setState(s as GenerationState<TResult>),
-          resetState: () => setState(getInitialState<TResult>()),
-          executeGeneration,
-          showError,
-          onError,
-          handleLifecycleComplete,
-        });
-
-        // If handleModeration returned undefined, the warning dialog was shown.
-        // The dialog's proceed/cancel callbacks now own isGeneratingRef — don't reset in finally.
-        if (result === undefined && moderation) {
-          moderationPending = true;
-        }
-
-        return result;
-      } catch (err) {
-        // Don't show error if aborted
-        if (abortControllerRef.current?.signal.aborted) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] Generation aborted");
-          }
-          return;
-        }
-
-        const error = parseError(err);
-        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Error:", error);
-        if (isMountedRef.current) setState({ status: "error", isGenerating: false, result: null, error });
-        showError("Error", getAlertMessage(error, alertMessages));
-        await onErrorRef.current?.(error);
-        handleLifecycleComplete("error", undefined, error);
-        throw error;
-      } finally {
-        // Only reset if moderation dialog did not take ownership
-        if (!moderationPending) {
-          isGeneratingRef.current = false;
-        }
-        abortControllerRef.current = null;
-      }
-    },
-    [offlineStore, moderation, alertMessages, strategy, executeGeneration, showError, handleLifecycleComplete],
-  );
-
-  const reset = useCallback(() => {
-    abortControllerRef.current?.abort();
-    abortControllerRef.current = null;
-    setState(getInitialState<TResult>());
-    isGeneratingRef.current = false;
-  }, []);
-
-  return { generate, reset, status: state.status, isGenerating: state.isGenerating, result: state.result, error: state.error };
-};

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

@@ -1,253 +0,0 @@
-/**
- * Generic Generation Hook Factory
- * Creates type-safe generation hooks with error handling, progress tracking, and abort support
- */
-
-import { useState, useCallback, useRef, useEffect } from "react";
-
-/**
- * Generation state
- */
-export interface GenerationState {
-  isGenerating: boolean;
-  progress: number;
-  error: string | null;
-}
-
-/**
- * Generation callbacks
- */
-export interface GenerationCallbacks<TResult> {
-  /** Called when generation succeeds */
-  onSuccess?: (result: TResult) => void;
-  /** Called when generation fails */
-  onError?: (error: string) => void;
-  /** Called on progress update */
-  onProgress?: (progress: number) => void;
-}
-
-/**
- * Generation hook configuration
- */
-export interface GenerationHookConfig<TRequest, TResult> {
-  /** Execute the generation request */
-  execute: (request: TRequest, signal?: AbortSignal) => Promise<TResult>;
-  /** Optional validation before execution */
-  validate?: (request: TRequest) => string | null;
-  /** Optional transform for errors */
-  transformError?: (error: unknown) => string;
-}
-
-/**
- * Generation hook return type
- */
-export interface GenerationHookReturn<TRequest, TResult> {
-  generationState: GenerationState;
-  handleGenerate: (request: TRequest) => Promise<TResult | null>;
-  setProgress: (progress: number) => void;
-  setError: (error: string | null) => void;
-  abort: () => void;
-}
-
-const INITIAL_STATE: GenerationState = {
-  isGenerating: false,
-  progress: 0,
-  error: null,
-};
-
-/**
- * Creates a type-safe generation hook
- * @param config - Generation hook configuration
- * @param callbacks - Generation callbacks
- * @returns Generation hook
- *
- * @example
- * ```ts
- * const useMyGeneration = createGenerationHook({
- *   execute: async (request) => {
- *     return await api.generate(request);
- *   },
- *   validate: (request) => {
- *     if (!request.prompt) return "Prompt is required";
- *     return null;
- *   },
- * });
- *
- * // Usage
- * const { generationState, handleGenerate } = useMyGeneration({
- *   onSuccess: (result) => console.log("Success!", result),
- *   onError: (error) => console.error("Error:", error),
- * });
- * ```
- */
-export function createGenerationHook<TRequest, TResult>(
-  config: GenerationHookConfig<TRequest, TResult>
-) {
-  return function useGeneration(
-    callbacks: GenerationCallbacks<TResult> = {}
-  ): GenerationHookReturn<TRequest, TResult> {
-    const [generationState, setGenerationState] = useState<GenerationState>(INITIAL_STATE);
-
-    const abortControllerRef = useRef<AbortController | null>(null);
-    const isMountedRef = useRef(true);
-
-    // Stabilize callbacks
-    const onSuccessRef = useRef(callbacks.onSuccess);
-    const onErrorRef = useRef(callbacks.onError);
-    const onProgressRef = useRef(callbacks.onProgress);
-
-    useEffect(() => {
-      onSuccessRef.current = callbacks.onSuccess;
-      onErrorRef.current = callbacks.onError;
-      onProgressRef.current = callbacks.onProgress;
-    }, [callbacks.onSuccess, callbacks.onError, callbacks.onProgress]);
-
-    // Cleanup on unmount
-    useEffect(() => {
-      isMountedRef.current = true;
-      return () => {
-        isMountedRef.current = false;
-        abortControllerRef.current?.abort();
-      };
-    }, []);
-
-    const setProgress = useCallback((progress: number) => {
-      if (!isMountedRef.current) return;
-      setGenerationState((prev) => ({ ...prev, progress }));
-      onProgressRef.current?.(progress);
-    }, []);
-
-    const setError = useCallback((error: string | null) => {
-      if (!isMountedRef.current) return;
-      setGenerationState((prev) => ({ ...prev, error, isGenerating: false }));
-      if (error) {
-        onErrorRef.current?.(error);
-      }
-    }, []);
-
-    const abort = useCallback(() => {
-      abortControllerRef.current?.abort();
-      if (isMountedRef.current) {
-        setGenerationState((prev) => ({
-          ...prev,
-          isGenerating: false,
-          error: "Generation aborted",
-        }));
-      }
-    }, []);
-
-    const handleGenerate = useCallback(
-      async (request: TRequest): Promise<TResult | null> => {
-        // Validate request
-        if (config.validate) {
-          const validationError = config.validate(request);
-          if (validationError) {
-            setError(validationError);
-            return null;
-          }
-        }
-
-        // Create new AbortController
-        abortControllerRef.current = new AbortController();
-
-        setGenerationState({
-          isGenerating: true,
-          progress: 0,
-          error: null,
-        });
-
-        try {
-          const result = await config.execute(
-            request,
-            abortControllerRef.current.signal
-          );
-
-          if (!isMountedRef.current || abortControllerRef.current.signal.aborted) {
-            return null;
-          }
-
-          setGenerationState((prev) => ({
-            ...prev,
-            isGenerating: false,
-            progress: 100
-          }));
-
-          onSuccessRef.current?.(result);
-          return result;
-        } catch (error) {
-          if (!isMountedRef.current || abortControllerRef.current.signal.aborted) {
-            return null;
-          }
-
-          const errorMessage = config.transformError
-            ? config.transformError(error)
-            : error instanceof Error
-            ? error.message
-            : String(error);
-
-          setError(errorMessage);
-          return null;
-        } finally {
-          abortControllerRef.current = null;
-        }
-      },
-      [config, setError]
-    );
-
-    return {
-      generationState,
-      handleGenerate,
-      setProgress,
-      setError,
-      abort,
-    };
-  };
-}
-
-/**
- * Creates a generation hook with progress updates
- * Useful when the generation API supports progress callbacks
- */
-export function createGenerationHookWithProgress<TRequest, TResult>(
-  config: GenerationHookConfig<TRequest, TResult> & {
-    /** Get progress stream or polling function */
-    subscribeToProgress?: (
-      request: TRequest,
-      onProgress: (progress: number) => void
-    ) => () => void;
-  }
-) {
-  const baseHook = createGenerationHook(config);
-
-  return function useGenerationWithProgress(
-    callbacks: GenerationCallbacks<TResult> = {}
-  ): GenerationHookReturn<TRequest, TResult> {
-    const hookResult = baseHook(callbacks);
-    const unsubscribeRef = useRef<(() => void) | null>(null);
-
-    const handleGenerateWithProgress = useCallback(
-      async (request: TRequest): Promise<TResult | null> => {
-        // Subscribe to progress if available
-        if (config.subscribeToProgress) {
-          unsubscribeRef.current = config.subscribeToProgress(
-            request,
-            hookResult.setProgress
-          );
-        }
-
-        try {
-          return await hookResult.handleGenerate(request);
-        } finally {
-          unsubscribeRef.current?.();
-          unsubscribeRef.current = null;
-        }
-      },
-      [hookResult, config.subscribeToProgress]
-    );
-
-    return {
-      ...hookResult,
-      handleGenerate: handleGenerateWithProgress,
-    };
-  };
-}