@umituz/react-native-ai-gemini-provider 2.0.32 → 2.1.0

package/package.json

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

package/src/infrastructure/utils/content-mapper.util.ts

@@ -9,8 +9,44 @@ import type {
   GeminiFinishReason,
   GeminiSafetyRating,
   GeminiResponse,
+  GeminiHarmCategory,
 } from "../../domain/entities";
 
+const VALID_FINISH_REASONS: readonly string[] = [
+  "FINISH_REASON_UNSPECIFIED",
+  "STOP",
+  "MAX_TOKENS",
+  "SAFETY",
+  "RECITATION",
+  "OTHER",
+] as const;
+
+const VALID_HARM_CATEGORIES: readonly string[] = [
+  "HARM_CATEGORY_HARASSMENT",
+  "HARM_CATEGORY_HATE_SPEECH",
+  "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+  "HARM_CATEGORY_DANGEROUS_CONTENT",
+] as const;
+
+const VALID_PROBABILITIES: readonly string[] = [
+  "NEGLIGIBLE",
+  "LOW",
+  "MEDIUM",
+  "HIGH",
+] as const;
+
+function isValidFinishReason(value: string): value is GeminiFinishReason {
+  return VALID_FINISH_REASONS.includes(value);
+}
+
+function isValidHarmCategory(value: string): value is GeminiHarmCategory {
+  return VALID_HARM_CATEGORIES.includes(value);
+}
+
+function isValidProbability(value: string): value is GeminiSafetyRating["probability"] {
+  return VALID_PROBABILITIES.includes(value);
+}
+
 /**
  * Convert domain content to SDK format
  */
@@ -62,21 +98,28 @@ export function transformCandidate(
     }
   }
 
-  const finishReason: GeminiFinishReason | undefined = candidate.finishReason
-    ? (candidate.finishReason as GeminiFinishReason)
-    : undefined;
+  const finishReason: GeminiFinishReason | undefined =
+    candidate.finishReason && isValidFinishReason(candidate.finishReason)
+      ? candidate.finishReason
+      : undefined;
 
   const safetyRatings: GeminiSafetyRating[] | undefined = candidate.safetyRatings
-    ? candidate.safetyRatings.map((rating) => ({
-        category: rating.category as GeminiSafetyRating["category"],
-        probability: rating.probability as GeminiSafetyRating["probability"],
-      }))
+    ? candidate.safetyRatings
+        .filter((rating) => isValidHarmCategory(rating.category) && isValidProbability(rating.probability))
+        .map((rating) => ({
+          category: rating.category as GeminiHarmCategory,
+          probability: rating.probability as GeminiSafetyRating["probability"],
+        }))
     : undefined;
 
+  const role = candidate.content.role === "user" || candidate.content.role === "model"
+    ? candidate.content.role
+    : "model";
+
   return {
     content: {
       parts: transformedParts,
-      role: (candidate.content.role || "model") as "user" | "model",
+      role,
     },
     finishReason,
     safetyRatings,

package/src/infrastructure/utils/performance.util.ts

@@ -71,12 +71,18 @@ export function measureSync<T>(
   }
 }
 
+interface DebouncedFunction<T extends (...args: never[]) => unknown> {
+  (...args: Parameters<T>): void;
+  cancel: () => void;
+}
+
 export function debounce<T extends (...args: never[]) => unknown>(
   func: T,
   wait: number,
-): (...args: Parameters<T>) => void {
+): DebouncedFunction<T> {
   let timeout: ReturnType<typeof setTimeout> | undefined;
-  return (...args: Parameters<T>) => {
+
+  const debounced = (...args: Parameters<T>) => {
     const later = () => {
       timeout = undefined;
       func(...args);
@@ -86,19 +92,48 @@ export function debounce<T extends (...args: never[]) => unknown>(
     }
     timeout = setTimeout(later, wait);
   };
+
+  debounced.cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+    }
+  };
+
+  return debounced;
+}
+
+interface ThrottledFunction<T extends (...args: never[]) => unknown> {
+  (...args: Parameters<T>): void;
+  cancel: () => void;
 }
 
 export function throttle<T extends (...args: never[]) => unknown>(
   func: T,
   limit: number,
-): (...args: Parameters<T>) => void {
-  let inThrottle: boolean;
-  return (...args: Parameters<T>) => {
+): ThrottledFunction<T> {
+  let inThrottle = false;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+
+  const throttled = (...args: Parameters<T>) => {
     if (!inThrottle) {
       func(...args);
       inThrottle = true;
-      setTimeout(() => (inThrottle = false), limit);
+      timeout = setTimeout(() => {
+        inThrottle = false;
+        timeout = undefined;
+      }, limit);
+    }
+  };
+
+  throttled.cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+      inThrottle = false;
     }
   };
+
+  return throttled;
 }