@umituz/react-native-ai-generation-content 1.17.308 → 1.17.310

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.308",
+  "version": "1.17.310",
   "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,46 +1,31 @@
 /**
  * useCoupleFutureGeneration Hook
- * Couple future generation with centralized credit management
+ * Couple future generation using centralized orchestrator
  */
 
-import { useCallback } from "react";
-import { usePhotoGeneration } from "../../../../presentation/hooks/usePhotoGeneration";
+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,
@@ -52,49 +37,54 @@ export const useCoupleFutureGeneration = <
     alertMessages,
   } = config;
 
-  const repository = useCallback(
+  const repository = useMemo(
     () => createCreationsRepository("creations"),
     [],
   );
 
-  const generationConfig: PhotoGenerationConfig<TInput, TResult, void> = {
-    userId,
-    creditCost: 1,
-    onCreditsExhausted,
-    generate: async (
-      input: TInput,
-      onProgress?: (progress: number) => void,
-    ) => {
-      const result = await executeCoupleFuture(
-        {
-          partnerABase64: input.partnerABase64,
-          partnerBBase64: input.partnerBBase64,
-          prompt: input.prompt,
-        },
-        { onProgress },
-      );
+  const strategy: GenerationStrategy<CoupleFutureInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        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");
-      }
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Generation failed");
+        }
 
-      return processResult(result.imageUrl, input);
-    },
-    save: async (result: TResult, input: TInput) => {
-      if (!userId || !buildCreation) {
-        return;
-      }
-      const creation = buildCreation(result, input);
-      if (creation) {
-        await repository().create(userId, creation);
-      }
-    },
-    onSuccess,
-    onError: (error: PhotoGenerationError) => {
+        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],
+  );
+
+  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,21 @@ export { enhancePromptWithLanguage, getSupportedLanguages, getLanguageName, Mode
 export type { ModerationResult, ModerationConfig, SynchronousGenerationInput, SynchronousGenerationConfig } from "./infrastructure/wrappers";
 
 export {
-  useGeneration, usePendingJobs, useBackgroundGeneration, usePhotoGeneration,
-  useGenerationFlow, useGenerationCallbacksBuilder, useAIFeatureCallbacks,
+  useGeneration, usePendingJobs, useBackgroundGeneration,
+  useGenerationFlow, useAIFeatureCallbacks,
+  useGenerationOrchestrator, useImageGeneration, useVideoGeneration,
+  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,
+  AIFeatureCallbacksConfig, AIFeatureCallbacks, AIFeatureGenerationResult,
+  GenerationStrategy, GenerationConfig, GenerationState, OrchestratorStatus,
+  GenerationError, GenerationErrorType, AlertMessages, UseGenerationOrchestratorReturn,
+  SingleImageInput, DualImageInput, ImageGenerationInput, ImageGenerationConfig,
+  DualImageVideoInput, VideoGenerationConfig,
 } 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,42 @@
+/**
+ * Generation Module
+ * Feature-agnostic AI generation orchestration
+ */
+
+// Core orchestrator
+export { useGenerationOrchestrator } from "./orchestrator";
+
+// Generic feature hooks
+export { useImageGeneration } from "./useImageGeneration";
+export { useVideoGeneration } from "./useVideoGeneration";
+
+// Types
+export type {
+  GenerationStrategy,
+  GenerationConfig,
+  GenerationState,
+  OrchestratorStatus,
+  GenerationError,
+  GenerationErrorType,
+  AlertMessages,
+  UseGenerationOrchestratorReturn,
+} from "./types";
+
+export type {
+  SingleImageInput,
+  DualImageInput,
+  ImageGenerationInput,
+  ImageGenerationConfig,
+} from "./useImageGeneration";
+
+export type {
+  DualImageVideoInput,
+  VideoGenerationConfig,
+} from "./useVideoGeneration";
+
+// Error utilities
+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/generation/useImageGeneration.ts

@@ -0,0 +1,157 @@
+/**
+ * useImageGeneration Hook
+ * Generic image generation hook for ANY image feature
+ * Uses centralized orchestrator for credit/error handling
+ */
+
+import { useMemo, useCallback } from "react";
+import { useGenerationOrchestrator } from "./orchestrator";
+import type { GenerationStrategy, AlertMessages } from "./types";
+import { executeImageFeature } from "../../../infrastructure/services";
+import type { ImageFeatureType } from "../../../domain/interfaces";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import type { Creation } from "../../../domains/creations/domain/entities/Creation";
+
+/**
+ * Generic input for single image features
+ */
+export interface SingleImageInput {
+  imageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Generic input for dual image features (face-swap, etc.)
+ */
+export interface DualImageInput {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  options?: Record<string, unknown>;
+}
+
+export type ImageGenerationInput = SingleImageInput | DualImageInput;
+
+export interface ImageGenerationConfig<TInput extends ImageGenerationInput, TResult> {
+  /** Feature type (face-swap, upscale, remove-background, etc.) */
+  featureType: ImageFeatureType;
+  /** User ID for credit operations */
+  userId: string | undefined;
+  /** Transform image URL to result type */
+  processResult: (imageUrl: string, input: TInput) => TResult;
+  /** Build input for executor from generic input */
+  buildExecutorInput?: (input: TInput) => {
+    imageBase64?: string;
+    targetImageBase64?: string;
+    prompt?: string;
+    options?: Record<string, unknown>;
+  };
+  /** Optional: Build creation for saving */
+  buildCreation?: (result: TResult, input: TInput) => Creation | null;
+  /** Credit cost (default: 1) */
+  creditCost?: number;
+  /** Alert messages for errors */
+  alertMessages: AlertMessages;
+  /** Callbacks */
+  onCreditsExhausted?: () => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Default input builder for single image
+ */
+const defaultSingleImageBuilder = (input: SingleImageInput) => ({
+  imageBase64: input.imageBase64,
+  prompt: input.prompt,
+  options: input.options,
+});
+
+/**
+ * Default input builder for dual image
+ */
+const defaultDualImageBuilder = (input: DualImageInput) => ({
+  imageBase64: input.sourceImageBase64,
+  targetImageBase64: input.targetImageBase64,
+  options: input.options,
+});
+
+/**
+ * Check if input is dual image type
+ */
+const isDualImageInput = (input: ImageGenerationInput): input is DualImageInput => {
+  return "sourceImageBase64" in input && "targetImageBase64" in input;
+};
+
+export const useImageGeneration = <
+  TInput extends ImageGenerationInput,
+  TResult,
+>(config: ImageGenerationConfig<TInput, TResult>) => {
+  const {
+    featureType,
+    userId,
+    processResult,
+    buildExecutorInput,
+    buildCreation,
+    creditCost = 1,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess,
+    onError,
+  } = config;
+
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+
+  const strategy: GenerationStrategy<TInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        // Build executor input
+        const executorInput = buildExecutorInput
+          ? buildExecutorInput(input)
+          : isDualImageInput(input)
+            ? defaultDualImageBuilder(input)
+            : defaultSingleImageBuilder(input as SingleImageInput);
+
+        const result = await executeImageFeature(
+          featureType,
+          executorInput,
+          { onProgress },
+        );
+
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Image generation failed");
+        }
+
+        return processResult(result.imageUrl, input);
+      },
+      getCreditCost: () => creditCost,
+      save: buildCreation
+        ? async (result, uid) => {
+            const creation = buildCreation(result, {} as TInput);
+            if (creation) {
+              await repository.create(uid, creation);
+            }
+          }
+        : undefined,
+    }),
+    [featureType, processResult, buildExecutorInput, buildCreation, repository, creditCost],
+  );
+
+  const handleError = useCallback(
+    (error: { message: string }) => {
+      onError?.(error.message);
+    },
+    [onError],
+  );
+
+  return useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: onSuccess as (result: unknown) => void,
+    onError: handleError,
+  });
+};