@umituz/react-native-ai-gemini-provider 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Google Gemini AI text generation provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/generation-executor.ts

@@ -50,7 +50,7 @@ export class GenerationExecutor {
       console.log("[GenerationExecutor] executeStructuredGeneration() called", { model });
     }
 
-    return geminiStructuredTextService.generateStructuredContent<T>(
+    return geminiStructuredTextService.generateStructuredText<T>(
       model ?? "gemini-2.0-flash",
       prompt,
       schema,

package/src/infrastructure/utils/async-state.util.ts

@@ -0,0 +1,52 @@
+/**
+ * Async State Utility
+ * Common async execution pattern with state management
+ */
+
+export interface AsyncStateCallbacks {
+  onSuccess?: (result: string) => void;
+  onError?: (error: string) => void;
+}
+
+export interface AsyncStateSetters {
+  setIsGenerating: (value: boolean) => void;
+  setError: (value: string | null) => void;
+  setResult: (value: string | null) => void;
+  setJsonResult: (value: unknown | null) => void;
+}
+
+/**
+ * Execute an async operation with common state management
+ */
+export async function executeWithState<T>(
+  abortRef: React.MutableRefObject<boolean>,
+  setters: AsyncStateSetters,
+  callbacks: AsyncStateCallbacks,
+  execute: () => Promise<T>,
+  onResult: (result: T) => void,
+): Promise<T | null> {
+  abortRef.current = false;
+  setters.setIsGenerating(true);
+  setters.setError(null);
+  setters.setResult(null);
+  setters.setJsonResult(null);
+
+  try {
+    const result = await execute();
+    if (abortRef.current) return null;
+
+    onResult(result);
+    return result;
+  } catch (err) {
+    if (abortRef.current) return null;
+
+    const errorMessage = err instanceof Error ? err.message : "Generation failed";
+    setters.setError(errorMessage);
+    callbacks.onError?.(errorMessage);
+    return null;
+  } finally {
+    if (!abortRef.current) {
+      setters.setIsGenerating(false);
+    }
+  }
+}

package/src/infrastructure/utils/index.ts

@@ -40,3 +40,6 @@ export {
   rateLimiter,
 } from "./rate-limiter.util";
 export type { RateLimiterOptions } from "./rate-limiter.util";
+
+export { executeWithState } from "./async-state.util";
+export type { AsyncStateCallbacks, AsyncStateSetters } from "./async-state.util";

package/src/presentation/hooks/use-gemini.ts

@@ -4,196 +4,86 @@
  * Supports text, structured JSON, and multimodal generation
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useMemo } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
 import { DEFAULT_MODELS } from "../../domain/entities";
-import { geminiTextGenerationService } from "../../infrastructure/services";
-import { geminiStructuredTextService } from "../../infrastructure/services";
+import { geminiTextGenerationService, geminiStructuredTextService } from "../../infrastructure/services";
+import { executeWithState } from "../../infrastructure/utils";
 
 export interface UseGeminiOptions {
-  /** Model to use (default: gemini-2.5-flash-lite) */
   model?: string;
-  /** Generation configuration */
   generationConfig?: GeminiGenerationConfig;
-  /** Called on successful generation */
   onSuccess?: (result: string) => void;
-  /** Called on error */
   onError?: (error: string) => void;
 }
 
 export interface UseGeminiReturn {
-  /** Generate text from prompt */
   generate: (prompt: string) => Promise<void>;
-  /** Generate text with image input */
-  generateWithImage: (
-    prompt: string,
-    imageBase64: string,
-    mimeType: string,
-  ) => Promise<void>;
-  /** Generate structured JSON response */
+  generateWithImage: (prompt: string, imageBase64: string, mimeType: string) => Promise<void>;
   generateJSON: <T>(prompt: string, schema?: Record<string, unknown>) => Promise<T | null>;
-  /** Current result */
   result: string | null;
-  /** JSON result (when using generateJSON) */
   jsonResult: unknown | null;
-  /** Loading state */
   isGenerating: boolean;
-  /** Error message */
   error: string | null;
-  /** Reset state */
   reset: () => void;
 }
 
+function cleanJsonResponse(text: string): string {
+  return text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+}
+
+function extractTextFromParts(parts: unknown[]): string {
+  return parts
+    .filter((p): p is { text: string } => typeof p === "object" && p !== null && "text" in p)
+    .map((p) => p.text)
+    .join("");
+}
+
 export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const [result, setResult] = useState<string | null>(null);
   const [jsonResult, setJsonResult] = useState<unknown | null>(null);
   const [isGenerating, setIsGenerating] = useState(false);
   const [error, setError] = useState<string | null>(null);
-
   const abortRef = useRef(false);
 
-  const generate = useCallback(
-    async (prompt: string) => {
-      abortRef.current = false;
-      setIsGenerating(true);
-      setError(null);
-      setResult(null);
-      setJsonResult(null);
-
-      try {
-        const model = options.model ?? DEFAULT_MODELS.TEXT;
-        const text = await geminiTextGenerationService.generateText(
-          model,
-          prompt,
-          options.generationConfig,
-        );
-
-        if (abortRef.current) return;
-
-        setResult(text);
-        options.onSuccess?.(text);
-      } catch (err) {
-        if (abortRef.current) return;
-
-        const errorMessage =
-          err instanceof Error ? err.message : "Generation failed";
-        setError(errorMessage);
-        options.onError?.(errorMessage);
-      } finally {
-        if (!abortRef.current) {
-          setIsGenerating(false);
-        }
-      }
-    },
-    [options],
-  );
-
-  const generateJSON = useCallback(
-    async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
-      abortRef.current = false;
-      setIsGenerating(true);
-      setError(null);
-      setResult(null);
-      setJsonResult(null);
+  const setters = useMemo(() => ({ setIsGenerating, setError, setResult, setJsonResult }), []);
+  const callbacks = useMemo(() => ({ onSuccess: options.onSuccess, onError: options.onError }), [options.onSuccess, options.onError]);
+  const model = options.model ?? DEFAULT_MODELS.TEXT;
 
-      try {
-        const model = options.model ?? DEFAULT_MODELS.TEXT;
-
-        let parsed: T;
+  const generate = useCallback(async (prompt: string) => {
+    await executeWithState(abortRef, setters, callbacks,
+      () => geminiTextGenerationService.generateText(model, prompt, options.generationConfig),
+      (text) => { setResult(text); options.onSuccess?.(text); }
+    );
+  }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
 
+  const generateJSON = useCallback(async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
+    return executeWithState(abortRef, setters, callbacks,
+      async () => {
         if (schema) {
-          // Use structured text service with schema
-          parsed = await geminiStructuredTextService.generateStructuredText<T>(
-            model,
-            prompt,
-            schema,
-            options.generationConfig,
-          );
-        } else {
-          // Generate text and parse JSON manually
-          const text = await geminiTextGenerationService.generateText(
-            model,
-            prompt,
-            {
-              ...options.generationConfig,
-              responseMimeType: "application/json",
-            },
-          );
-
-          // Clean and parse JSON
-          const cleanedText = text
-            .replace(/```json\n?/g, "")
-            .replace(/```\n?/g, "")
-            .trim();
-          parsed = JSON.parse(cleanedText) as T;
+          return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema, options.generationConfig);
         }
-
-        if (abortRef.current) return null;
-
+        const text = await geminiTextGenerationService.generateText(model, prompt, { ...options.generationConfig, responseMimeType: "application/json" });
+        return JSON.parse(cleanJsonResponse(text)) as T;
+      },
+      (parsed) => {
         setJsonResult(parsed);
         setResult(JSON.stringify(parsed, null, 2));
         options.onSuccess?.(JSON.stringify(parsed));
-        return parsed;
-      } catch (err) {
-        if (abortRef.current) return null;
-
-        const errorMessage =
-          err instanceof Error ? err.message : "JSON generation failed";
-        setError(errorMessage);
-        options.onError?.(errorMessage);
-        return null;
-      } finally {
-        if (!abortRef.current) {
-          setIsGenerating(false);
-        }
       }
-    },
-    [options],
-  );
-
-  const generateWithImage = useCallback(
-    async (prompt: string, imageBase64: string, mimeType: string) => {
-      abortRef.current = false;
-      setIsGenerating(true);
-      setError(null);
-      setResult(null);
-      setJsonResult(null);
-
-      try {
-        const model = options.model ?? DEFAULT_MODELS.TEXT;
-        const response = await geminiTextGenerationService.generateWithImages(
-          model,
-          prompt,
-          [{ base64: imageBase64, mimeType }],
-          options.generationConfig,
-        );
-
-        if (abortRef.current) return;
-
-        // Extract text from response
-        const text =
-          response.candidates?.[0]?.content.parts
-            .filter((p): p is { text: string } => "text" in p)
-            .map((p: { text: string }) => p.text)
-            .join("") || "";
-
+    );
+  }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
+
+  const generateWithImage = useCallback(async (prompt: string, imageBase64: string, mimeType: string) => {
+    await executeWithState(abortRef, setters, callbacks,
+      () => geminiTextGenerationService.generateWithImages(model, prompt, [{ base64: imageBase64, mimeType }], options.generationConfig),
+      (response) => {
+        const text = extractTextFromParts(response.candidates?.[0]?.content.parts ?? []);
         setResult(text);
         options.onSuccess?.(text);
-      } catch (err) {
-        if (abortRef.current) return;
-
-        const errorMessage =
-          err instanceof Error ? err.message : "Generation failed";
-        setError(errorMessage);
-        options.onError?.(errorMessage);
-      } finally {
-        if (!abortRef.current) {
-          setIsGenerating(false);
-        }
       }
-    },
-    [options],
-  );
+    );
+  }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
 
   const reset = useCallback(() => {
     abortRef.current = true;
@@ -203,14 +93,5 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
     setError(null);
   }, []);
 
-  return {
-    generate,
-    generateWithImage,
-    generateJSON,
-    result,
-    jsonResult,
-    isGenerating,
-    error,
-    reset,
-  };
+  return { generate, generateWithImage, generateJSON, result, jsonResult, isGenerating, error, reset };
 }