@umituz/react-native-ai-gemini-provider 1.10.1 → 1.10.4

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.10.1",
+  "version": "1.10.4",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
-    "typecheck": "echo 'TypeScript validation passed'",
-    "lint": "echo 'Lint passed'",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
     "version:major": "npm version major -m 'chore: release v%s'"
@@ -33,10 +34,13 @@
   },
   "devDependencies": {
     "@google/generative-ai": "^0.21.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
     "@types/react": "~19.1.10",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "~5.9.2"
+    "typescript": "^5.3.0"
   },
   "publishConfig": {
     "access": "public"

package/src/infrastructure/services/gemini-provider.ts

@@ -4,31 +4,17 @@
  */
 
 import type {
-  GeminiConfig,
   GeminiImageInput,
   GeminiImageGenerationResult,
 } from "../../domain/entities";
-import { geminiClientCoreService } from "./gemini-client-core.service";
-import { geminiTextGenerationService } from "./gemini-text-generation.service";
 import { geminiImageGenerationService } from "./gemini-image-generation.service";
 import { geminiImageEditService } from "./gemini-image-edit.service";
-import { JobManager } from "../job/JobManager";
-import { ContentBuilder } from "../content/ContentBuilder";
-import { ResponseFormatter } from "../response/ResponseFormatter";
+import { providerInitializer, type AIProviderConfig } from "./provider-initializer";
+import { jobProcessor } from "./job-processor";
+import { generationExecutor } from "./generation-executor";
 import type { JobSubmission, JobStatus } from "../job/JobManager";
 
-declare const __DEV__: boolean;
-
-export interface AIProviderConfig {
-  apiKey: string;
-  maxRetries?: number;
-  baseDelay?: number;
-  maxDelay?: number;
-  defaultTimeoutMs?: number;
-  textModel?: string;
-  textToImageModel?: string;
-  imageEditModel?: string;
-}
+export type { AIProviderConfig, JobSubmission, JobStatus };
 
 export interface SubscribeOptions<T = unknown> {
   timeoutMs?: number;
@@ -41,59 +27,24 @@ export class GeminiProvider {
   readonly providerId = "gemini";
   readonly providerName = "Google Gemini";
 
-  private jobManager = new JobManager();
-  private contentBuilder = new ContentBuilder();
-  private responseFormatter = new ResponseFormatter();
-
   initialize(config: AIProviderConfig): void {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Initializing...");
-    }
-
-    const geminiConfig: GeminiConfig = {
-      apiKey: config.apiKey,
-      maxRetries: config.maxRetries,
-      baseDelay: config.baseDelay,
-      maxDelay: config.maxDelay,
-      defaultTimeoutMs: config.defaultTimeoutMs,
-      textModel: config.textModel,
-      textToImageModel: config.textToImageModel,
-      imageEditModel: config.imageEditModel,
-    };
-
-    geminiClientCoreService.initialize(geminiConfig);
+    providerInitializer.initialize(config);
   }
 
   isInitialized(): boolean {
-    return geminiClientCoreService.isInitialized();
+    return providerInitializer.isInitialized();
   }
 
   submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
-    const submission = this.jobManager.submitJob(model, input);
-
-    this.processJobAsync(submission.requestId).catch((error) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[GeminiProvider] Job failed:", error);
-      }
-    });
-
-    return Promise.resolve(submission);
+    return jobProcessor.submitJob(model, input);
   }
 
   getJobStatus(_model: string, requestId: string): Promise<JobStatus> {
-    const status = this.jobManager.getJobStatus(requestId);
-    return Promise.resolve(status);
+    return jobProcessor.getJobStatus(_model, requestId);
   }
 
   getJobResult<T = unknown>(_model: string, requestId: string): Promise<T> {
-    try {
-      const result = this.jobManager.getJobResult<T>(requestId);
-      return Promise.resolve(result);
-    } catch (error) {
-      return Promise.reject(error);
-    }
+    return jobProcessor.getJobResult<T>(_model, requestId);
   }
 
   async subscribe<T = unknown>(
@@ -104,7 +55,7 @@ export class GeminiProvider {
     options?.onQueueUpdate?.({ status: "IN_QUEUE" });
     options?.onProgress?.(10);
 
-    const result = await this.executeGeneration<T>(model, input);
+    const result = await generationExecutor.executeGeneration<T>(model, input);
 
     options?.onProgress?.(100);
     options?.onQueueUpdate?.({ status: "COMPLETED" });
@@ -117,7 +68,7 @@ export class GeminiProvider {
     model: string,
     input: Record<string, unknown>,
   ): Promise<T> {
-    return this.executeGeneration<T>(model, input);
+    return generationExecutor.executeGeneration<T>(model, input);
   }
 
   async generateImage(prompt: string): Promise<GeminiImageGenerationResult> {
@@ -136,61 +87,12 @@ export class GeminiProvider {
     prompt: string,
     images: GeminiImageInput[],
   ): Promise<{ text: string; response: unknown }> {
-    const response = await geminiTextGenerationService.generateWithImages(
-      model,
-      prompt,
-      images,
-    );
-
-    const text = response.candidates?.[0]?.content.parts
-      .filter((p): p is { text: string } => "text" in p)
-      .map((p) => p.text)
-      .join("") || "";
-
-    return { text, response };
+    return generationExecutor.generateWithImages(model, prompt, images);
   }
 
   reset(): void {
-    geminiClientCoreService.reset();
-    this.jobManager.clear();
-  }
-
-  private async processJobAsync(requestId: string): Promise<void> {
-    const job = this.jobManager.getJob(requestId);
-    if (!job) return;
-
-    this.jobManager.updateJobStatus(requestId, "IN_PROGRESS");
-
-    try {
-      const result = await this.executeGeneration(job.model, job.input);
-      this.jobManager.setJobResult(requestId, result);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.jobManager.setJobError(requestId, errorMessage);
-    }
-  }
-
-  private async executeGeneration<T>(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<T> {
-    const isImageGeneration = input.generateImage === true || input.type === "image";
-
-    if (isImageGeneration) {
-      const prompt = String(input.prompt || "");
-      const images = input.images as GeminiImageInput[] | undefined;
-      const result = await geminiImageGenerationService.generateImage(prompt, images);
-      return result as T;
-    }
-
-    const contents = this.contentBuilder.buildContents(input);
-    const response = await geminiTextGenerationService.generateContent(
-      model,
-      contents,
-      input.generationConfig as undefined,
-    );
-
-    return this.responseFormatter.formatResponse<T>(response, input);
+    providerInitializer.reset();
+    jobProcessor.clear();
   }
 }
 

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

@@ -0,0 +1,61 @@
+/**
+ * Generation Executor
+ * Handles execution of different generation types
+ */
+
+import type {
+    GeminiImageInput,
+} from "../../domain/entities";
+import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { geminiImageGenerationService } from "./gemini-image-generation.service";
+import { ContentBuilder } from "../content/ContentBuilder";
+import { ResponseFormatter } from "../response/ResponseFormatter";
+
+export class GenerationExecutor {
+    private contentBuilder = new ContentBuilder();
+    private responseFormatter = new ResponseFormatter();
+
+    async executeGeneration<T>(
+        model: string,
+        input: Record<string, unknown>,
+    ): Promise<T> {
+        const isImageGeneration = input.generateImage === true || input.type === "image";
+
+        if (isImageGeneration) {
+            const prompt = String(input.prompt || "");
+            const images = input.images as GeminiImageInput[] | undefined;
+            const result = await geminiImageGenerationService.generateImage(prompt, images);
+            return result as T;
+        }
+
+        const contents = this.contentBuilder.buildContents(input);
+        const response = await geminiTextGenerationService.generateContent(
+            model,
+            contents,
+            input.generationConfig as undefined,
+        );
+
+        return this.responseFormatter.formatResponse<T>(response, input);
+    }
+
+    async generateWithImages(
+        model: string,
+        prompt: string,
+        images: GeminiImageInput[],
+    ): Promise<{ text: string; response: unknown }> {
+        const response = await geminiTextGenerationService.generateWithImages(
+            model,
+            prompt,
+            images,
+        );
+
+        const text = response.candidates?.[0]?.content.parts
+            .filter((p): p is { text: string } => "text" in p)
+            .map((p) => p.text)
+            .join("") || "";
+
+        return { text, response };
+    }
+}
+
+export const generationExecutor = new GenerationExecutor();

package/src/infrastructure/services/index.ts

@@ -10,6 +10,11 @@ export { geminiImageGenerationService } from "./gemini-image-generation.service"
 export { geminiImageEditService } from "./gemini-image-edit.service";
 export { geminiStreamingService } from "./gemini-streaming.service";
 
+// Modular services
+export { providerInitializer } from "./provider-initializer";
+export { jobProcessor } from "./job-processor";
+export { generationExecutor } from "./generation-executor";
+
 // Public provider API
 export {
   geminiProviderService,

package/src/infrastructure/services/job-processor.ts

@@ -0,0 +1,62 @@
+/**
+ * Job Processor
+ * Handles async job processing
+ */
+
+import { JobManager } from "../job/JobManager";
+import type { JobSubmission, JobStatus } from "../job/JobManager";
+import { generationExecutor } from "./generation-executor";
+
+declare const __DEV__: boolean;
+
+export class JobProcessor {
+    private jobManager = new JobManager();
+
+    submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+        const submission = this.jobManager.submitJob(model, input);
+
+        this.processJobAsync(submission.requestId).catch((error) => {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+                // eslint-disable-next-line no-console
+                console.error("[GeminiProvider] Job failed:", error);
+            }
+        });
+
+        return Promise.resolve(submission);
+    }
+
+    getJobStatus(_model: string, requestId: string): Promise<JobStatus> {
+        const status = this.jobManager.getJobStatus(requestId);
+        return Promise.resolve(status);
+    }
+
+    getJobResult<T = unknown>(_model: string, requestId: string): Promise<T> {
+        try {
+            const result = this.jobManager.getJobResult<T>(requestId);
+            return Promise.resolve(result);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    }
+
+    clear(): void {
+        this.jobManager.clear();
+    }
+
+    private async processJobAsync(requestId: string): Promise<void> {
+        const job = this.jobManager.getJob(requestId);
+        if (!job) return;
+
+        this.jobManager.updateJobStatus(requestId, "IN_PROGRESS");
+
+        try {
+            const result = await generationExecutor.executeGeneration(job.model, job.input);
+            this.jobManager.setJobResult(requestId, result);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.jobManager.setJobError(requestId, errorMessage);
+        }
+    }
+}
+
+export const jobProcessor = new JobProcessor();

package/src/infrastructure/services/provider-initializer.ts

@@ -0,0 +1,52 @@
+/**
+ * Provider Initializer
+ * Handles initialization logic for Gemini Provider
+ */
+
+import type { GeminiConfig } from "../../domain/entities";
+import { geminiClientCoreService } from "./gemini-client-core.service";
+
+declare const __DEV__: boolean;
+
+export interface AIProviderConfig {
+    apiKey: string;
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    defaultTimeoutMs?: number;
+    textModel?: string;
+    textToImageModel?: string;
+    imageEditModel?: string;
+}
+
+export class ProviderInitializer {
+    initialize(config: AIProviderConfig): void {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[GeminiProvider] Initializing...");
+        }
+
+        const geminiConfig: GeminiConfig = {
+            apiKey: config.apiKey,
+            maxRetries: config.maxRetries,
+            baseDelay: config.baseDelay,
+            maxDelay: config.maxDelay,
+            defaultTimeoutMs: config.defaultTimeoutMs,
+            textModel: config.textModel,
+            textToImageModel: config.textToImageModel,
+            imageEditModel: config.imageEditModel,
+        };
+
+        geminiClientCoreService.initialize(geminiConfig);
+    }
+
+    isInitialized(): boolean {
+        return geminiClientCoreService.isInitialized();
+    }
+
+    reset(): void {
+        geminiClientCoreService.reset();
+    }
+}
+
+export const providerInitializer = new ProviderInitializer();

package/src/providers/ProviderFactory.ts

@@ -15,7 +15,6 @@ import {
   getQualityOptimizedConfig,
 } from "./ProviderConfig";
 
-declare const __DEV__: boolean;
 
 export type OptimizationStrategy = "cost" | "quality" | "balanced";
 
@@ -49,15 +48,7 @@ class ProviderFactory {
 
     this.currentConfig = config;
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ProviderFactory] Initializing with config:", {
-        tier: config.subscriptionTier,
-        strategy: options.strategy || "balanced",
-        textModel: config.textModel,
-        imageEditModel: config.imageEditModel,
-        maxRetries: config.maxRetries,
-      });
-    }
+    this.currentConfig = config;
 
     // Initialize Gemini client with resolved config
     const geminiConfig: GeminiConfig = {
@@ -72,9 +63,7 @@ class ProviderFactory {
 
     geminiClientCoreService.initialize(geminiConfig);
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ProviderFactory] Provider initialized successfully");
-    }
+    geminiClientCoreService.initialize(geminiConfig);
   }
 
   /**