@umituz/react-native-ai-generation-content 1.17.204 → 1.17.205

package/package.json

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

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

@@ -12,3 +12,5 @@ export type {
   NanoBananaOutputFormat,
 } from "./domain/types";
 export { COUPLE_FUTURE_DEFAULTS } from "./domain/types";
+export { useCoupleFutureGeneration } from "./presentation/hooks/useCoupleFutureGeneration";
+export type { UseCoupleFutureGenerationConfig } from "./presentation/hooks/useCoupleFutureGeneration";

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

@@ -0,0 +1,76 @@
+import { useCallback } from "react";
+import { usePhotoGeneration } from "../../../presentation/hooks/usePhotoGeneration";
+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";
+
+export interface UseCoupleFutureGenerationConfig<TInput extends CoupleFutureInput, TResult> {
+  userId: string | undefined;
+  processResult: (imageUrl: string, input: TInput) => Promise<TResult> | TResult;
+  buildCreation?: (result: TResult, input: TInput) => any; // Type 'Creation' if known, otherwise any
+  deductCredits?: () => Promise<void>;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+  alertMessages: {
+    networkError: string;
+    policyViolation: string;
+    saveFailed: string;
+    creditFailed: string;
+    unknown: string;
+  };
+}
+
+export const useCoupleFutureGeneration = <TInput extends CoupleFutureInput, TResult>(
+  config: UseCoupleFutureGenerationConfig<TInput, TResult>
+) => {
+  const {
+    userId,
+    processResult,
+    buildCreation,
+    deductCredits,
+    onSuccess,
+    onError,
+    alertMessages,
+  } = config;
+
+  const repository = useCallback(() => 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");
+      }
+
+      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);
+      }
+    },
+
+    deductCredits,
+    onSuccess,
+    onError: (error: PhotoGenerationError) => {
+      onError?.(error.message);
+    },
+    alertMessages,
+  };
+
+  return usePhotoGeneration(generationConfig);
+};

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

@@ -29,7 +29,7 @@ export interface AlertMessages {
 }
 
 export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
-  generate: (input: TInput) => Promise<TResult>;
+  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>;

package/src/presentation/hooks/usePhotoGeneration.ts

@@ -86,7 +86,10 @@ export const usePhotoGeneration = <TInput, TResult, TSaveInput = unknown>(
         setState((prev) => ({ ...prev, progress: 20 }));
 
         // Generate without timeout - let AI provider handle its own timeout
-        const result = await generateFn(input);
+        // 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 }));