@umituz/react-native-ai-generation-content 1.17.307 → 1.17.309

package/package.json

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

package/src/features/couple-future/index.ts

@@ -15,7 +15,7 @@ export type {
 } from "./domain/types";
 export { COUPLE_FUTURE_DEFAULTS } from "./domain/types";
 export { useCoupleFutureGeneration } from "./presentation/hooks/useCoupleFutureGeneration";
-export type { UseCoupleFutureGenerationConfig } from "./presentation/hooks/useCoupleFutureGeneration";
+export type { CoupleFutureConfig as UseCoupleFutureGenerationConfig } from "./presentation/hooks/useCoupleFutureGeneration";
 export {
   RomanticMoodSelector,
   ArtStyleSelector,

package/src/features/couple-future/presentation/hooks/useCoupleFutureGeneration.ts

@@ -1,93 +1,90 @@
-import { useCallback } from "react";
-import { useDeductCredit } from "@umituz/react-native-subscription";
-import { usePhotoGeneration } from "../../../../presentation/hooks/usePhotoGeneration";
+/**
+ * useCoupleFutureGeneration Hook
+ * Couple future generation using centralized orchestrator
+ */
+
+import { useMemo, useCallback } from "react";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
 import { executeCoupleFuture } from "../../infrastructure/executor";
 import type { CoupleFutureInput } from "../../domain/types";
-import type {
-  PhotoGenerationConfig,
-  PhotoGenerationError,
-} from "../../../../presentation/hooks/photo-generation.types";
 import { createCreationsRepository } from "../../../../domains/creations/infrastructure/adapters";
 import type { Creation } from "../../../../domains/creations/domain/entities/Creation";
 
-export interface UseCoupleFutureGenerationConfig<
-  TInput extends CoupleFutureInput,
-  TResult,
-> {
+export interface CoupleFutureConfig<TResult> {
   userId: string | undefined;
-  processResult: (
-    imageUrl: string,
-    input: TInput,
-  ) => Promise<TResult> | TResult;
-  buildCreation?: (result: TResult, input: TInput) => Creation | null;
+  processResult: (imageUrl: string, input: CoupleFutureInput) => TResult;
+  buildCreation?: (result: TResult, input: CoupleFutureInput) => Creation | null;
+  onCreditsExhausted?: () => void;
   onSuccess?: (result: TResult) => void;
   onError?: (error: string) => void;
-  alertMessages: {
-    networkError: string;
-    policyViolation: string;
-    saveFailed: string;
-    creditFailed: string;
-    unknown: string;
-  };
+  alertMessages: AlertMessages;
 }
 
-export const useCoupleFutureGeneration = <
-  TInput extends CoupleFutureInput,
-  TResult,
->(
-  config: UseCoupleFutureGenerationConfig<TInput, TResult>,
+export const useCoupleFutureGeneration = <TResult>(
+  config: CoupleFutureConfig<TResult>,
 ) => {
   const {
     userId,
     processResult,
     buildCreation,
+    onCreditsExhausted,
     onSuccess,
     onError,
     alertMessages,
   } = config;
 
-  const { checkCredits, deductCredit } = useDeductCredit({ userId });
-  const repository = useCallback(
+  const repository = useMemo(
     () => createCreationsRepository("creations"),
     [],
   );
 
-  const generationConfig: PhotoGenerationConfig<TInput, TResult, void> = {
-    generate: async (input: TInput, onProgress?: (progress: number) => void) => {
-      const result = await executeCoupleFuture(
-        {
-          partnerABase64: input.partnerABase64,
-          partnerBBase64: input.partnerBBase64,
-          prompt: input.prompt,
-        },
-        { onProgress },
-      );
-
-      if (!result.success || !result.imageUrl) {
-        throw new Error(result.error || "Generation failed");
-      }
+  const strategy: GenerationStrategy<CoupleFutureInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        const result = await executeCoupleFuture(
+          {
+            partnerABase64: input.partnerABase64,
+            partnerBBase64: input.partnerBBase64,
+            prompt: input.prompt,
+          },
+          { onProgress },
+        );
 
-      return processResult(result.imageUrl, input);
-    },
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Generation failed");
+        }
 
-    save: async (result: TResult, input: TInput) => {
-      if (!userId || !buildCreation) {
-        return;
-      }
-      const creation = buildCreation(result, input);
-      if (creation) {
-        await repository().create(userId, creation);
-      }
-    },
+        return processResult(result.imageUrl, input);
+      },
+      getCreditCost: () => 1,
+      save: buildCreation
+        ? async (result, uid) => {
+            const creation = buildCreation(result, {} as CoupleFutureInput);
+            if (creation) {
+              await repository.create(uid, creation);
+            }
+          }
+        : undefined,
+    }),
+    [processResult, buildCreation, repository],
+  );
 
-    checkCredits: () => checkCredits(1),
-    deductCredits: () => deductCredit(1).then(() => {}),
-    onSuccess,
-    onError: (error: PhotoGenerationError) => {
+  const handleError = useCallback(
+    (error: { message: string }) => {
       onError?.(error.message);
     },
-    alertMessages,
-  };
+    [onError],
+  );
 
-  return usePhotoGeneration(generationConfig);
+  return useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: onSuccess as (result: unknown) => void,
+    onError: handleError,
+  });
 };

package/src/index.ts

@@ -67,18 +67,19 @@ export { enhancePromptWithLanguage, getSupportedLanguages, getLanguageName, Mode
 export type { ModerationResult, ModerationConfig, SynchronousGenerationInput, SynchronousGenerationConfig } from "./infrastructure/wrappers";
 
 export {
-  useGeneration, usePendingJobs, useBackgroundGeneration, usePhotoGeneration,
+  useGeneration, usePendingJobs, useBackgroundGeneration,
   useGenerationFlow, useGenerationCallbacksBuilder, useAIFeatureCallbacks,
+  useGenerationOrchestrator, createGenerationError, getAlertMessage, parseError,
 } from "./presentation/hooks";
 
 export type {
   UseGenerationOptions, UseGenerationReturn, UsePendingJobsOptions, UsePendingJobsReturn,
   UseBackgroundGenerationOptions, UseBackgroundGenerationReturn, DirectExecutionResult,
-  UsePhotoGenerationReturn, PhotoGenerationInput, PhotoGenerationResult, PhotoGenerationError,
-  PhotoGenerationConfig, PhotoGenerationState, PhotoGenerationStatus, UseGenerationFlowOptions,
-  UseGenerationFlowReturn, CreditType, GenerationExecutionResult, GenerationCallbacksConfig,
-  GenerationCallbacks, UseGenerationCallbacksBuilderOptions, AIFeatureCallbacksConfig,
-  AIFeatureCallbacks, AIFeatureGenerationResult,
+  UseGenerationFlowOptions, UseGenerationFlowReturn, CreditType, GenerationExecutionResult,
+  GenerationCallbacksConfig, GenerationCallbacks, UseGenerationCallbacksBuilderOptions,
+  AIFeatureCallbacksConfig, AIFeatureCallbacks, AIFeatureGenerationResult,
+  GenerationStrategy, GenerationConfig, GenerationState, OrchestratorStatus,
+  GenerationError, GenerationErrorType, AlertMessages, UseGenerationOrchestratorReturn,
 } from "./presentation/hooks";
 
 export {

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

@@ -0,0 +1,58 @@
+/**
+ * Generation Errors
+ * Centralized error handling for generation orchestration
+ */
+
+import type { GenerationError, GenerationErrorType, AlertMessages } from "./types";
+
+export const createGenerationError = (
+  type: GenerationErrorType,
+  message: string,
+  originalError?: Error,
+): GenerationError => ({
+  type,
+  message,
+  originalError,
+});
+
+export const getAlertMessage = (
+  error: GenerationError,
+  messages: AlertMessages,
+): string => {
+  switch (error.type) {
+    case "network":
+      return messages.networkError;
+    case "credits":
+      return messages.creditFailed;
+    case "policy":
+      return messages.policyViolation;
+    case "save":
+      return messages.saveFailed;
+    default:
+      return messages.unknown;
+  }
+};
+
+export const parseError = (err: unknown): GenerationError => {
+  if (isGenerationError(err)) {
+    return err;
+  }
+
+  if (err instanceof Error) {
+    if (err.name === "ContentPolicyViolationError") {
+      return createGenerationError("policy", err.message, err);
+    }
+    return createGenerationError("unknown", err.message, err);
+  }
+
+  return createGenerationError("unknown", "Generation failed");
+};
+
+const isGenerationError = (err: unknown): err is GenerationError => {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "type" in err &&
+    "message" in err
+  );
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Generation Module
+ * Feature-agnostic AI generation orchestration
+ */
+
+export { useGenerationOrchestrator } from "./orchestrator";
+
+export type {
+  GenerationStrategy,
+  GenerationConfig,
+  GenerationState,
+  OrchestratorStatus,
+  GenerationError,
+  GenerationErrorType,
+  AlertMessages,
+  UseGenerationOrchestratorReturn,
+} from "./types";
+
+export {
+  createGenerationError,
+  getAlertMessage,
+  parseError,
+} from "./errors";

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

@@ -0,0 +1,146 @@
+/**
+ * Generation Orchestrator
+ * Feature-agnostic hook for AI generation with centralized:
+ * - Credit management
+ * - Error handling
+ * - Alert display
+ * - Progress tracking
+ */
+
+import { useState, useCallback, useRef } from "react";
+import { useOfflineStore, useAlert } from "@umituz/react-native-design-system";
+import { useDeductCredit } from "@umituz/react-native-subscription";
+import { createGenerationError, getAlertMessage, parseError } from "./errors";
+import type {
+  GenerationStrategy,
+  GenerationConfig,
+  GenerationState,
+  UseGenerationOrchestratorReturn,
+} from "./types";
+
+const INITIAL_STATE = {
+  status: "idle" as const,
+  isGenerating: false,
+  progress: 0,
+  result: null,
+  error: null,
+};
+
+export const useGenerationOrchestrator = <TInput, TResult>(
+  strategy: GenerationStrategy<TInput, TResult>,
+  config: GenerationConfig,
+): UseGenerationOrchestratorReturn<TInput, TResult> => {
+  const { userId, alertMessages, onCreditsExhausted, onSuccess, onError } =
+    config;
+
+  const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
+  const isGeneratingRef = useRef(false);
+  const offlineStore = useOfflineStore();
+  const { showError, showSuccess } = useAlert();
+  const { checkCredits, deductCredit } = useDeductCredit({
+    userId,
+    onCreditsExhausted,
+  });
+
+  const generate = useCallback(
+    async (input: TInput) => {
+      if (isGeneratingRef.current) return;
+
+      isGeneratingRef.current = true;
+      setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
+
+      try {
+        if (!offlineStore.isOnline) {
+          throw createGenerationError("network", "No internet connection");
+        }
+
+        const creditCost = strategy.getCreditCost();
+        const hasCredits = await checkCredits(creditCost);
+        if (!hasCredits) {
+          throw createGenerationError("credits", "Insufficient credits");
+        }
+
+        setState((prev) => ({ ...prev, status: "generating", progress: 10 }));
+
+        const result = await strategy.execute(input, (progress) => {
+          setState((prev) => ({ ...prev, progress }));
+        });
+
+        setState((prev) => ({ ...prev, progress: 70 }));
+
+        if (strategy.save && userId) {
+          setState((prev) => ({ ...prev, status: "saving" }));
+          try {
+            await strategy.save(result, userId);
+          } catch (saveErr) {
+            throw createGenerationError(
+              "save",
+              "Failed to save",
+              saveErr instanceof Error ? saveErr : undefined,
+            );
+          }
+        }
+
+        setState((prev) => ({ ...prev, progress: 90 }));
+
+        await deductCredit(creditCost);
+
+        setState({
+          status: "success",
+          isGenerating: false,
+          progress: 100,
+          result,
+          error: null,
+        });
+
+        if (alertMessages.success) {
+          void showSuccess("Success", alertMessages.success);
+        }
+
+        onSuccess?.(result);
+      } catch (err) {
+        const error = parseError(err);
+
+        setState({
+          status: "error",
+          isGenerating: false,
+          progress: 0,
+          result: null,
+          error,
+        });
+
+        void showError("Error", getAlertMessage(error, alertMessages));
+        onError?.(error);
+      } finally {
+        isGeneratingRef.current = false;
+      }
+    },
+    [
+      strategy,
+      userId,
+      alertMessages,
+      offlineStore.isOnline,
+      checkCredits,
+      deductCredit,
+      showError,
+      showSuccess,
+      onSuccess,
+      onError,
+    ],
+  );
+
+  const reset = useCallback(() => {
+    setState(INITIAL_STATE);
+    isGeneratingRef.current = false;
+  }, []);
+
+  return {
+    generate,
+    reset,
+    status: state.status,
+    isGenerating: state.isGenerating,
+    progress: state.progress,
+    result: state.result,
+    error: state.error,
+  };
+};

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

@@ -0,0 +1,72 @@
+/**
+ * Generation Types
+ * Type definitions for feature-agnostic generation orchestration
+ */
+
+export type OrchestratorStatus =
+  | "idle"
+  | "checking"
+  | "generating"
+  | "saving"
+  | "success"
+  | "error";
+
+export interface GenerationStrategy<TInput, TResult> {
+  /** Execute the generation */
+  execute: (
+    input: TInput,
+    onProgress?: (progress: number) => void,
+  ) => Promise<TResult>;
+  /** Credit cost for this generation */
+  getCreditCost: () => number;
+  /** Optional: Save result to storage */
+  save?: (result: TResult, userId: string) => Promise<void>;
+}
+
+export interface AlertMessages {
+  networkError: string;
+  policyViolation: string;
+  saveFailed: string;
+  creditFailed: string;
+  unknown: string;
+  success?: string;
+}
+
+export interface GenerationConfig {
+  userId: string | undefined;
+  alertMessages: AlertMessages;
+  onCreditsExhausted?: () => void;
+  onSuccess?: (result: unknown) => void;
+  onError?: (error: GenerationError) => void;
+}
+
+export interface GenerationState<TResult> {
+  status: OrchestratorStatus;
+  isGenerating: boolean;
+  progress: number;
+  result: TResult | null;
+  error: GenerationError | null;
+}
+
+export interface GenerationError {
+  type: GenerationErrorType;
+  message: string;
+  originalError?: Error;
+}
+
+export type GenerationErrorType =
+  | "network"
+  | "credits"
+  | "policy"
+  | "save"
+  | "unknown";
+
+export interface UseGenerationOrchestratorReturn<TInput, TResult> {
+  generate: (input: TInput) => Promise<void>;
+  reset: () => void;
+  status: OrchestratorStatus;
+  isGenerating: boolean;
+  progress: number;
+  result: TResult | null;
+  error: GenerationError | null;
+}

package/src/presentation/hooks/index.ts

@@ -5,6 +5,24 @@
 // Base Feature Hooks (Provider-Agnostic)
 export * from "./base";
 
+// Generation Orchestrator (Centralized)
+export {
+  useGenerationOrchestrator,
+  createGenerationError,
+  getAlertMessage,
+  parseError,
+} from "./generation";
+export type {
+  GenerationStrategy,
+  GenerationConfig,
+  GenerationState,
+  OrchestratorStatus,
+  GenerationError,
+  GenerationErrorType,
+  AlertMessages,
+  UseGenerationOrchestratorReturn,
+} from "./generation";
+
 export { useGeneration } from "./use-generation";
 export type {
   UseGenerationOptions,
@@ -24,20 +42,6 @@ export type {
   DirectExecutionResult,
 } from "./use-background-generation";
 
-export { usePhotoGeneration } from "./usePhotoGeneration";
-export type {
-  UsePhotoGenerationReturn,
-} from "./usePhotoGeneration";
-
-export type {
-  PhotoGenerationInput,
-  PhotoGenerationResult,
-  PhotoGenerationError,
-  PhotoGenerationConfig,
-  PhotoGenerationState,
-  PhotoGenerationStatus,
-} from "./photo-generation.types";
-
 export { useGenerationFlow } from "./useGenerationFlow";
 export type {
   UseGenerationFlowOptions,

package/src/presentation/hooks/photo-generation.types.ts

@@ -1,50 +0,0 @@
-/**
- * Photo Generation Types
- * Generic types for photo-based AI generation workflows
- */
-
-export interface PhotoGenerationInput<TMetadata = unknown> {
-  photos: Array<{ uri: string; base64: string }>;
-  metadata?: TMetadata;
-}
-
-export interface PhotoGenerationResult<TResult = unknown> {
-  success: boolean;
-  data?: TResult;
-  error?: PhotoGenerationError;
-}
-
-export interface PhotoGenerationError {
-  type: "network_error" | "policy_violation" | "save_failed" | "credit_failed" | "unknown";
-  message: string;
-  originalError?: Error;
-}
-
-export interface AlertMessages {
-  networkError: string;
-  policyViolation: string;
-  saveFailed: string;
-  creditFailed: string;
-  unknown: string;
-}
-
-export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
-  generate: (input: TInput, onProgress?: (progress: number) => void) => Promise<TResult>;
-  save?: (result: TResult, input: TInput) => Promise<TSaveInput>;
-  buildMetadata?: (input: TInput) => Record<string, unknown>;
-  checkCredits?: () => Promise<boolean>;
-  deductCredits?: () => Promise<void>;
-  onSuccess?: (result: TResult) => void;
-  onError?: (error: PhotoGenerationError) => void;
-  onSaveComplete?: (saveResult: TSaveInput) => void;
-  alertMessages: AlertMessages;
-}
-
-export interface PhotoGenerationState<TResult = unknown> {
-  isGenerating: boolean;
-  result: TResult | null;
-  error: PhotoGenerationError | null;
-  progress: number;
-}
-
-export type PhotoGenerationStatus = "idle" | "validating" | "generating" | "saving" | "success" | "error";

package/src/presentation/hooks/usePhotoGeneration.ts

@@ -1,192 +0,0 @@
-/**
- * usePhotoGeneration Hook
- * Generic hook for photo-based AI generation workflows
- */
-
-import { useState, useCallback, useRef } from "react";
-import { useOfflineStore, useAlert } from "@umituz/react-native-design-system";
-import type {
-  PhotoGenerationConfig,
-  PhotoGenerationState,
-  PhotoGenerationError,
-  PhotoGenerationStatus,
-} from "./photo-generation.types";
-
-export interface UsePhotoGenerationReturn<TInput, TResult> extends PhotoGenerationState<TResult> {
-  generate: (input: TInput) => Promise<void>;
-  reset: () => void;
-  status: PhotoGenerationStatus;
-}
-
-export const usePhotoGeneration = <TInput, TResult, TSaveInput = unknown>(
-  config: PhotoGenerationConfig<TInput, TResult, TSaveInput>,
-): UsePhotoGenerationReturn<TInput, TResult> => {
-  const {
-    generate: generateFn,
-    save: saveFn,
-    checkCredits,
-    deductCredits,
-    onSuccess,
-    onError,
-    onSaveComplete,
-    alertMessages,
-  } = config;
-
-  const [state, setState] = useState<PhotoGenerationState<TResult>>({
-    isGenerating: false,
-    result: null,
-    error: null,
-    progress: 0,
-  });
-
-  const [status, setStatus] = useState<PhotoGenerationStatus>("idle");
-  const isGeneratingRef = useRef(false);
-  const offlineStore = useOfflineStore();
-  const { showError } = useAlert();
-
-  const createError = useCallback(
-    (
-      type: PhotoGenerationError["type"],
-      message: string,
-      originalError?: Error,
-    ): PhotoGenerationError => ({
-      type,
-      message,
-      originalError,
-    }),
-    [],
-  );
-
-  const generate = useCallback(
-    async (input: TInput) => {
-      if (isGeneratingRef.current) {
-        return;
-      }
-
-      isGeneratingRef.current = true;
-      setState({ isGenerating: true, result: null, error: null, progress: 0 });
-      setStatus("validating");
-
-      try {
-        // Check network connectivity
-        if (!offlineStore.isOnline) {
-          throw createError("network_error", "No internet connection");
-        }
-
-        // Check credits
-        if (checkCredits) {
-          const hasCredits = await checkCredits();
-          if (!hasCredits) {
-            throw createError("credit_failed", "Insufficient credits");
-          }
-        }
-
-        setStatus("generating");
-        setState((prev) => ({ ...prev, progress: 20 }));
-
-        // Generate without timeout - let AI provider handle its own timeout
-        // Pass progress callback to allow provider to report real progress
-        const result = await generateFn(input, (newProgress) => {
-          setState((prev) => ({ ...prev, progress: newProgress }));
-        });
-
-        setState((prev) => ({ ...prev, progress: 60 }));
-
-        // Save result
-        if (saveFn) {
-          setStatus("saving");
-          try {
-            const saveResult = await saveFn(result, input);
-            onSaveComplete?.(saveResult);
-          } catch (saveError) {
-            throw createError(
-              "save_failed",
-              "Failed to save result",
-              saveError instanceof Error ? saveError : new Error(String(saveError)),
-            );
-          }
-        }
-
-        setState((prev) => ({ ...prev, progress: 80 }));
-
-        // Deduct credits after successful generation
-        if (deductCredits) {
-          try {
-            await deductCredits();
-          } catch {
-            // Silently fail credit deduction as generation succeeded
-          }
-        }
-
-        setState({
-          isGenerating: false,
-          result,
-          error: null,
-          progress: 100,
-        });
-        setStatus("success");
-        onSuccess?.(result);
-      } catch (err: unknown) {
-        let generationError: PhotoGenerationError;
-
-        if (err && typeof err === "object" && "type" in err && "message" in err) {
-          generationError = err as PhotoGenerationError;
-        } else if (err instanceof Error) {
-          if (err.name === "ContentPolicyViolationError") {
-            generationError = createError("policy_violation", "Content policy violation", err);
-          } else {
-            generationError = createError("unknown", err.message || "Generation failed", err);
-          }
-        } else {
-          generationError = createError("unknown", "Generation failed");
-        }
-
-        setState({
-          isGenerating: false,
-          result: null,
-          error: generationError,
-          progress: 0,
-        });
-        setStatus("error");
-
-        const errorMessage =
-          generationError.type === "network_error" ? alertMessages.networkError :
-            generationError.type === "policy_violation" ? alertMessages.policyViolation :
-              generationError.type === "save_failed" ? alertMessages.saveFailed :
-                generationError.type === "credit_failed" ? alertMessages.creditFailed :
-                  alertMessages.unknown;
-
-        void showError("Error", errorMessage);
-        onError?.(generationError);
-      } finally {
-        isGeneratingRef.current = false;
-      }
-    },
-    [
-      generateFn,
-      saveFn,
-      checkCredits,
-      deductCredits,
-      onSuccess,
-      onError,
-      onSaveComplete,
-      createError,
-      offlineStore,
-      alertMessages,
-      showError
-    ],
-  );
-
-  const reset = useCallback(() => {
-    setState({ isGenerating: false, result: null, error: null, progress: 0 });
-    setStatus("idle");
-    isGeneratingRef.current = false;
-  }, []);
-
-  return {
-    ...state,
-    generate,
-    reset,
-    status,
-  };
-};