@umituz/react-native-ai-generation-content 1.10.2 → 1.10.4

package/package.json

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

package/src/index.ts

@@ -157,6 +157,7 @@ export {
   useGeneration,
   usePendingJobs,
   useBackgroundGeneration,
+  usePhotoGeneration,
 } from "./presentation/hooks";
 
 export type {
@@ -167,6 +168,13 @@ export type {
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,
   DirectExecutionResult,
+  UsePhotoGenerationReturn,
+  PhotoGenerationInput,
+  PhotoGenerationResult,
+  PhotoGenerationError,
+  PhotoGenerationConfig,
+  PhotoGenerationState,
+  PhotoGenerationStatus,
 } from "./presentation/hooks";
 
 // =============================================================================

package/src/presentation/hooks/index.ts

@@ -20,3 +20,17 @@ export type {
   UseBackgroundGenerationReturn,
   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";

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

@@ -0,0 +1,41 @@
+/**
+ * Photo Generation Types
+ * Generic types for photo-based AI generation workflows
+ */
+
+export interface PhotoGenerationInput<TMetadata = any> {
+  photos: Array<{ uri: string; base64: string }>;
+  metadata?: TMetadata;
+}
+
+export interface PhotoGenerationResult<TResult = any> {
+  success: boolean;
+  data?: TResult;
+  error?: PhotoGenerationError;
+}
+
+export interface PhotoGenerationError {
+  type: "timeout" | "policy_violation" | "save_failed" | "credit_failed" | "unknown";
+  message: string;
+  originalError?: Error;
+}
+
+export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
+  generate: (input: TInput) => Promise<TResult>;
+  save?: (result: TResult, input: TInput) => Promise<TSaveInput>;
+  checkCredits?: () => Promise<boolean>;
+  deductCredits?: () => Promise<void>;
+  timeout?: number;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: PhotoGenerationError) => void;
+  onSaveComplete?: (saveResult: TSaveInput) => void;
+}
+
+export interface PhotoGenerationState<TResult = any> {
+  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

@@ -0,0 +1,169 @@
+/**
+ * usePhotoGeneration Hook
+ * Generic hook for photo-based AI generation workflows
+ */
+
+import { useState, useCallback, useRef } from "react";
+import type {
+  PhotoGenerationConfig,
+  PhotoGenerationState,
+  PhotoGenerationError,
+  PhotoGenerationStatus,
+} from "./photo-generation.types";
+
+const DEFAULT_TIMEOUT = 60000;
+
+export interface UsePhotoGenerationReturn<TResult> extends PhotoGenerationState<TResult> {
+  generate: <TInput>(input: TInput) => Promise<void>;
+  reset: () => void;
+  status: PhotoGenerationStatus;
+}
+
+export const usePhotoGeneration = <TInput, TResult, TSaveInput = any>(
+  config: PhotoGenerationConfig<TInput, TResult, TSaveInput>,
+): UsePhotoGenerationReturn<TResult> => {
+  const {
+    generate: generateFn,
+    save: saveFn,
+    checkCredits,
+    deductCredits,
+    timeout = DEFAULT_TIMEOUT,
+    onSuccess,
+    onError,
+    onSaveComplete,
+  } = 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 createError = useCallback(
+    (
+      type: PhotoGenerationError["type"],
+      message: string,
+      originalError?: Error,
+    ): PhotoGenerationError => ({
+      type,
+      message,
+      originalError,
+    }),
+    [],
+  );
+
+  const generate = useCallback(
+    async (input: TInput) => {
+      if (isGeneratingRef.current) {
+        if (__DEV__) console.warn("[usePhotoGeneration] Generation already in progress");
+        return;
+      }
+
+      isGeneratingRef.current = true;
+      setState({ isGenerating: true, result: null, error: null, progress: 0 });
+      setStatus("validating");
+
+      try {
+        if (checkCredits) {
+          const hasCredits = await checkCredits();
+          if (!hasCredits) {
+            throw createError("credit_failed", "Insufficient credits");
+          }
+        }
+
+        setStatus("generating");
+        setState((prev) => ({ ...prev, progress: 20 }));
+
+        const timeoutPromise = new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error("Generation timeout")), timeout),
+        );
+
+        const result = await Promise.race([generateFn(input), timeoutPromise]);
+
+        setState((prev) => ({ ...prev, progress: 60 }));
+
+        if (saveFn) {
+          setStatus("saving");
+          try {
+            const saveResult = await saveFn(result, input);
+            onSaveComplete?.(saveResult);
+          } catch (saveError) {
+            throw createError(
+              "save_failed",
+              "Failed to save result",
+              saveError as Error,
+            );
+          }
+        }
+
+        setState((prev) => ({ ...prev, progress: 80 }));
+
+        if (deductCredits) {
+          try {
+            await deductCredits();
+          } catch (deductError) {
+            if (__DEV__)
+              console.error("[usePhotoGeneration] Credit deduction failed", deductError);
+          }
+        }
+
+        setState({
+          isGenerating: false,
+          result,
+          error: null,
+          progress: 100,
+        });
+        setStatus("success");
+        onSuccess?.(result);
+      } catch (error: any) {
+        const generationError =
+          error.type
+            ? error
+            : error.message === "Generation timeout"
+              ? createError("timeout", "Generation timed out", error)
+              : error.name === "ContentPolicyViolationError"
+                ? createError("policy_violation", "Content policy violation", error)
+                : createError("unknown", error.message || "Generation failed", error);
+
+        setState({
+          isGenerating: false,
+          result: null,
+          error: generationError,
+          progress: 0,
+        });
+        setStatus("error");
+        onError?.(generationError);
+      } finally {
+        isGeneratingRef.current = false;
+      }
+    },
+    [
+      generateFn,
+      saveFn,
+      checkCredits,
+      deductCredits,
+      timeout,
+      onSuccess,
+      onError,
+      onSaveComplete,
+      createError,
+    ],
+  );
+
+  const reset = useCallback(() => {
+    setState({ isGenerating: false, result: null, error: null, progress: 0 });
+    setStatus("idle");
+    isGeneratingRef.current = false;
+  }, []);
+
+  return {
+    ...state,
+    generate,
+    reset,
+    status,
+  };
+};