@umituz/react-native-ai-gemini-provider 3.0.40 → 3.0.42

package/src/presentation/hooks/useGemini.ts

@@ -1,125 +0,0 @@
-import { useState, useCallback, useMemo } from "react";
-import type { GeminiGenerationConfig } from "../../domain/entities";
-import { DEFAULT_MODELS } from "../../domain/entities";
-import { textGeneration } from "../../infrastructure/services/TextGeneration";
-import { structuredText } from "../../infrastructure/services/StructuredText";
-import { executeWithState, type AsyncStateSetters } from "../../infrastructure/utils/async/execute-state.util";
-import { useOperationManager } from "./useOperationManager";
-
-export interface UseGeminiOptions {
-  model?: string;
-  generationConfig?: GeminiGenerationConfig;
-  onSuccess?: (result: string) => void;
-  onError?: (error: string) => void;
-}
-
-export interface UseGeminiReturn {
-  generate: (prompt: string) => Promise<void>;
-  generateJSON: <T>(prompt: string, schema: Record<string, unknown>) => Promise<T | null>;
-  result: string | null;
-  jsonResult: unknown;
-  isGenerating: boolean;
-  error: string | null;
-  reset: () => void;
-}
-
-export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
-  const [result, setResult] = useState<string | null>(null);
-  const [jsonResult, setJsonResult] = useState<unknown>(null);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const { executeOperation, abort } = useOperationManager();
-
-  const setters: AsyncStateSetters<string, unknown> = useMemo(
-    () => ({
-      setIsLoading: setIsGenerating,
-      setError,
-      setResult,
-      setSecondaryResult: setJsonResult,
-    }),
-    []
-  );
-
-  const callbacks = useMemo(
-    () => ({ onSuccess: options.onSuccess, onError: options.onError }),
-    [options.onSuccess, options.onError]
-  );
-
-  const model = options.model ?? DEFAULT_MODELS.TEXT;
-
-  const generate = useCallback(
-    async (prompt: string) => {
-      await executeOperation(async (signal, _operationId) => {
-        await executeWithState(
-          setters,
-          callbacks,
-          async () => {
-            return textGeneration.generateText(
-              model,
-              prompt,
-              options.generationConfig,
-              signal
-            );
-          },
-          (text: string) => {
-            setResult(text);
-          }
-        );
-      });
-    },
-    [model, options.generationConfig, setters, callbacks, executeOperation]
-  );
-
-  const generateJSON = useCallback(
-    async <T>(prompt: string, schema: Record<string, unknown>): Promise<T | null> => {
-      return executeOperation(async (signal, _operationId) => {
-        const jsonSetters: AsyncStateSetters<unknown, unknown> = {
-          setIsLoading: setIsGenerating,
-          setError,
-          setResult: setJsonResult,
-          setSecondaryResult: (value) =>
-            setResult(typeof value === "string" ? value : JSON.stringify(value)),
-        };
-
-        const jsonCallbacks = {
-          onSuccess: options.onSuccess
-            ? (result: unknown) => options.onSuccess?.(JSON.stringify(result))
-            : undefined,
-          onError: options.onError,
-        };
-
-        const operationResult = await executeWithState<unknown>(
-          jsonSetters,
-          jsonCallbacks,
-          async () => {
-            return structuredText.generateStructuredText<T>(
-              model,
-              prompt,
-              schema,
-              options.generationConfig,
-              signal
-            );
-          },
-          (parsed: unknown) => {
-            setJsonResult(parsed);
-            setResult(JSON.stringify(parsed, null, 2));
-          }
-        );
-
-        return operationResult as T | null;
-      });
-    },
-    [model, options.generationConfig, callbacks, executeOperation]
-  );
-
-  const reset = useCallback(() => {
-    abort();
-    setResult(null);
-    setJsonResult(null);
-    setIsGenerating(false);
-    setError(null);
-  }, [abort]);
-
-  return { generate, generateJSON, result, jsonResult, isGenerating, error, reset };
-}

package/src/presentation/hooks/useOperationManager.ts

@@ -1,88 +0,0 @@
-/**
- * Operation Manager Hook
- * Reusable abort controller and operation ID management
- * Eliminates code duplication in hooks
- */
-
-import { useRef, useCallback, useEffect } from "react";
-
-export interface OperationManager {
-  /**
-   * Execute an operation with abort support and operation ID tracking
-   */
-  executeOperation: <T>(
-    operation: (signal: AbortSignal, operationId: number) => Promise<T>
-  ) => Promise<T>;
-
-  /**
-   * Abort current operation
-   */
-  abort: () => void;
-
-  /**
-   * Check if current operation is active
-   */
-  isOperationActive: (operationId: number) => boolean;
-}
-
-/**
- * Hook for managing operations with abort control
- */
-export function useOperationManager(): OperationManager {
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const operationIdRef = useRef(0);
-
-  const abort = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-    operationIdRef.current++;
-  }, []);
-
-  const isOperationActive = useCallback((operationId: number): boolean => {
-    return operationId === operationIdRef.current;
-  }, []);
-
-  const executeOperation = useCallback(
-    async <T>(
-      operation: (signal: AbortSignal, operationId: number) => Promise<T>
-    ): Promise<T> => {
-      // Abort any existing operation
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      // Create new controller and increment operation ID
-      const controller = new AbortController();
-      abortControllerRef.current = controller;
-      const currentOpId = ++operationIdRef.current;
-
-      try {
-        return await operation(controller.signal, currentOpId);
-      } finally {
-        // Clean up only if this is still the current operation
-        if (currentOpId === operationIdRef.current) {
-          abortControllerRef.current = null;
-        }
-      }
-    },
-    []
-  );
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-      operationIdRef.current++;
-    };
-  }, []);
-
-  return {
-    executeOperation,
-    abort,
-    isOperationActive,
-  };
-}

package/src/providers/ConfigBuilder.ts

@@ -1,112 +0,0 @@
-/**
- * Config Builder Pattern
- * Fluent API for building provider configuration
- */
-
-import { DEFAULT_MODELS } from "../domain/entities";
-import type { GeminiConfig } from "../domain/entities";
-
-export interface ProviderConfig {
-  apiKey: string;
-  textModel: string;
-  timeout: number;
-  strategy?: "cost" | "quality";
-}
-
-/**
- * Builder for constructing provider configuration
- * Provides a fluent API with validation and defaults
- */
-export class ConfigBuilder {
-  private config: Omit<Partial<ProviderConfig>, 'textModel' | 'timeout'> & {
-    textModel: string;
-    timeout: number;
-  } = {
-    textModel: DEFAULT_MODELS.TEXT,
-    timeout: 30000,
-  };
-
-  /**
-   * Set API key (required)
-   */
-  withApiKey(apiKey: string): this {
-    if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
-      throw new Error("API key must be a non-empty string");
-    }
-    this.config.apiKey = apiKey.trim();
-    return this;
-  }
-
-  /**
-   * Set text model
-   */
-  withTextModel(model: string): this {
-    if (!model || !model.startsWith("gemini-")) {
-      throw new Error("Invalid model name");
-    }
-    this.config.textModel = model;
-    return this;
-  }
-
-  /**
-   * Set request timeout (ms)
-   */
-  withTimeout(timeout: number): this {
-    if (timeout <= 0 || timeout > 300000) {
-      throw new Error("Timeout must be between 1ms and 300000ms (5 minutes)");
-    }
-    this.config.timeout = timeout;
-    return this;
-  }
-
-  /**
-   * Set strategy (applies preset timeout)
-   */
-  withStrategy(strategy: "cost" | "quality"): this {
-    this.config.strategy = strategy;
-
-    // Apply strategy-based defaults
-    if (strategy === "quality") {
-      this.config.timeout = 60000;
-    } else {
-      this.config.timeout = 30000;
-    }
-
-    return this;
-  }
-
-  /**
-   * Build final configuration
-   */
-  build(): ProviderConfig {
-    if (!this.config.apiKey) {
-      throw new Error("API key is required. Call withApiKey() before build()");
-    }
-
-    return {
-      apiKey: this.config.apiKey,
-      textModel: this.config.textModel,
-      timeout: this.config.timeout,
-      strategy: this.config.strategy,
-    };
-  }
-
-  /**
-   * Convert to GeminiConfig format
-   */
-  toGeminiConfig(): GeminiConfig {
-    const config = this.build();
-    return {
-      apiKey: config.apiKey,
-      textModel: config.textModel,
-      defaultTimeoutMs: config.timeout,
-    };
-  }
-
-  /**
-   * Create a new builder instance
-   */
-  static create(): ConfigBuilder {
-    return new ConfigBuilder();
-  }
-}

package/src/providers/ProviderFactory.ts

@@ -1,65 +0,0 @@
-import { geminiClient } from "../infrastructure/services/GeminiClient";
-import { ConfigBuilder, type ProviderConfig } from "./ConfigBuilder";
-
-// Re-export for public API
-export { ConfigBuilder } from "./ConfigBuilder";
-export type { ProviderConfig } from "./ConfigBuilder";
-
-export interface ProviderFactoryOptions {
-  apiKey: string;
-  timeout?: number;
-  textModel?: string;
-  strategy?: "cost" | "quality";
-}
-
-class ProviderFactory {
-  private currentConfig: ProviderConfig | null = null;
-
-  /**
-   * Initialize provider with configuration
-   */
-  initialize(options: ProviderFactoryOptions): void {
-    // Build configuration using builder pattern (inline, no state needed)
-    const builder = ConfigBuilder.create().withApiKey(options.apiKey);
-
-    if (options.strategy) {
-      builder.withStrategy(options.strategy);
-    }
-
-    if (options.textModel) {
-      builder.withTextModel(options.textModel);
-    }
-
-    if (options.timeout) {
-      builder.withTimeout(options.timeout);
-    }
-
-    this.currentConfig = builder.build();
-
-    // Initialize Gemini client
-    const geminiConfig = builder.toGeminiConfig();
-    geminiClient.initialize(geminiConfig);
-  }
-
-  /**
-   * Check if provider is initialized
-   */
-  isInitialized(): boolean {
-    return this.currentConfig !== null;
-  }
-
-  /**
-   * Update configuration
-   * API key changes require re-initialization
-   */
-  updateConfig(updates: Partial<ProviderFactoryOptions>): void {
-    if (!this.currentConfig) {
-      throw new Error("Provider not initialized. Call initialize() first.");
-    }
-
-    // Re-initialize with merged config to ensure GeminiClient is updated
-    this.initialize({ ...this.currentConfig, ...updates });
-  }
-}
-
-export const providerFactory = new ProviderFactory();