@umituz/react-native-ai-fal-provider 1.0.96 → 1.0.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.96",
+  "version": "1.0.98",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/utils/cost-tracker-queries.ts

@@ -0,0 +1,67 @@
+/**
+ * Cost Tracker Queries
+ * Query functions for cost history analysis
+ */
+
+import type { GenerationCost, CostSummary } from "../../domain/entities/cost-tracking.types";
+
+/**
+ * Calculate cost summary from history
+ */
+export function calculateCostSummary(
+  costHistory: readonly GenerationCost[],
+  currency: string
+): CostSummary {
+  const completedCosts = costHistory.filter((c) => c.actualCost > 0);
+  const totalCost = completedCosts.reduce((sum, c) => sum + c.actualCost, 0);
+  const totalGenerations = completedCosts.length;
+  const averageCost = totalGenerations > 0 ? totalCost / totalGenerations : 0;
+
+  const modelBreakdown: Record<string, number> = {};
+  const operationBreakdown: Record<string, number> = {};
+
+  for (const cost of completedCosts) {
+    modelBreakdown[cost.model] = (modelBreakdown[cost.model] ?? 0) + cost.actualCost;
+    operationBreakdown[cost.operation] = (operationBreakdown[cost.operation] ?? 0) + cost.actualCost;
+  }
+
+  return {
+    totalCost,
+    totalGenerations,
+    averageCost,
+    currency,
+    modelBreakdown,
+    operationBreakdown,
+  };
+}
+
+/**
+ * Filter costs by model
+ */
+export function filterCostsByModel(
+  costHistory: readonly GenerationCost[],
+  modelId: string
+): GenerationCost[] {
+  return costHistory.filter((c) => c.model === modelId);
+}
+
+/**
+ * Filter costs by operation type
+ */
+export function filterCostsByOperation(
+  costHistory: readonly GenerationCost[],
+  operation: string
+): GenerationCost[] {
+  return costHistory.filter((c) => c.operation === operation);
+}
+
+/**
+ * Filter costs by time range
+ */
+export function filterCostsByTimeRange(
+  costHistory: readonly GenerationCost[],
+  startTime: number,
+  endTime: number
+): GenerationCost[] {
+  return costHistory.filter((c) => c.timestamp >= startTime && c.timestamp <= endTime);
+}

package/src/infrastructure/utils/cost-tracker.ts

@@ -10,6 +10,12 @@ import type {
   ModelCostInfo,
 } from "../../domain/entities/cost-tracking.types";
 import { findModelById } from "../../domain/constants/default-models.constants";
+import {
+  calculateCostSummary,
+  filterCostsByModel,
+  filterCostsByOperation,
+  filterCostsByTimeRange,
+} from "./cost-tracker-queries";
 
 declare const __DEV__: boolean | undefined;
 
@@ -27,9 +33,6 @@ export class CostTracker {
     };
   }
 
-  /**
-   * Get cost information for a model
-   */
   getModelCostInfo(modelId: string): ModelCostInfo {
     const model = findModelById(modelId);
 
@@ -52,17 +55,11 @@ export class CostTracker {
     };
   }
 
-  /**
-   * Calculate estimated cost for a generation
-   */
   calculateEstimatedCost(modelId: string): number {
     const costInfo = this.getModelCostInfo(modelId);
     return costInfo.costPerRequest;
   }
 
-  /**
-   * Start tracking a generation operation
-   */
   startOperation(modelId: string, operation: string): string {
     const operationId = `${Date.now()}-${operation}`;
     const estimatedCost = this.calculateEstimatedCost(modelId);
@@ -86,9 +83,6 @@ export class CostTracker {
     return operationId;
   }
 
-  /**
-   * Complete tracking for a generation operation
-   */
   completeOperation(
     operationId: string,
     modelId: string,
@@ -120,70 +114,28 @@ export class CostTracker {
     return cost;
   }
 
-  /**
-   * Get cost summary for all tracked operations
-   */
   getCostSummary(): CostSummary {
-    const completedCosts = this.costHistory.filter((c) => c.actualCost > 0);
-    const totalCost = completedCosts.reduce((sum, c) => sum + c.actualCost, 0);
-    const totalGenerations = completedCosts.length;
-    const averageCost = totalGenerations > 0 ? totalCost / totalGenerations : 0;
-
-    const modelBreakdown: Record<string, number> = {};
-    const operationBreakdown: Record<string, number> = {};
-
-    for (const cost of completedCosts) {
-      modelBreakdown[cost.model] =
-        (modelBreakdown[cost.model] ?? 0) + cost.actualCost;
-      operationBreakdown[cost.operation] =
-        (operationBreakdown[cost.operation] ?? 0) + cost.actualCost;
-    }
-
-    return {
-      totalCost,
-      totalGenerations,
-      averageCost,
-      currency: this.config.currency,
-      modelBreakdown,
-      operationBreakdown,
-    };
+    return calculateCostSummary(this.costHistory, this.config.currency);
   }
 
-  /**
-   * Get cost history
-   */
   getCostHistory(): readonly GenerationCost[] {
     return this.costHistory;
   }
 
-  /**
-   * Clear cost history
-   */
   clearHistory(): void {
     this.costHistory = [];
     this.currentOperationCosts.clear();
   }
 
-  /**
-   * Get costs for a specific model
-   */
   getCostsByModel(modelId: string): GenerationCost[] {
-    return this.costHistory.filter((c) => c.model === modelId);
+    return filterCostsByModel(this.costHistory, modelId);
   }
 
-  /**
-   * Get costs for a specific operation type
-   */
   getCostsByOperation(operation: string): GenerationCost[] {
-    return this.costHistory.filter((c) => c.operation === operation);
+    return filterCostsByOperation(this.costHistory, operation);
   }
 
-  /**
-   * Get costs for a specific time range
-   */
   getCostsByTimeRange(startTime: number, endTime: number): GenerationCost[] {
-    return this.costHistory.filter(
-      (c) => c.timestamp >= startTime && c.timestamp <= endTime,
-    );
+    return filterCostsByTimeRange(this.costHistory, startTime, endTime);
   }
 }

package/src/infrastructure/utils/general-helpers.util.ts

@@ -0,0 +1,45 @@
+/**
+ * General Helper Utilities
+ * Common utility functions
+ */
+
+/**
+ * Format credit cost for display
+ */
+export function formatCreditCost(cost: number): string {
+  if (cost % 1 === 0) {
+    return cost.toString();
+  }
+  return cost.toFixed(2);
+}
+
+/**
+ * Build error message with context
+ */
+export function buildErrorMessage(
+  type: string,
+  context: Record<string, unknown>
+): string {
+  const contextStr = Object.entries(context)
+    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+    .join(", ");
+  return `${type}${contextStr ? ` (${contextStr})` : ""}`;
+}
+
+/**
+ * Check if value is defined (not null or undefined)
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Filter out null and undefined values from object
+ */
+export function removeNullish<T extends Record<string, unknown>>(
+  obj: T
+): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, value]) => isDefined(value))
+  ) as Partial<T>;
+}

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

@@ -1,151 +1,29 @@
 /**
- * Helper Utilities
- * Common helper functions for FAL operations
- */
-
-/**
- * Format image as data URI if not already formatted
- */
-export function formatImageDataUri(base64: string): string {
-  if (base64.startsWith("data:")) {
-    return base64;
-  }
-  return `data:image/jpeg;base64,${base64}`;
-}
-
-/**
- * Extract base64 from data URI
- */
-export function extractBase64(dataUri: string): string {
-  if (!dataUri.startsWith("data:")) {
-    return dataUri;
-  }
-
-  const parts = dataUri.split(",");
-  return parts.length > 1 ? parts[1] : dataUri;
-}
-
-/**
- * Get file extension from data URI
- */
-export function getDataUriExtension(dataUri: string): string | null {
-  const match = dataUri.match(/^data:image\/(\w+);base64/);
-  return match ? match[1] : null;
-}
-
-/**
- * Check if data URI is an image
- */
-export function isImageDataUri(value: string): boolean {
-  return value.startsWith("data:image/");
-}
-
-/**
- * Calculate timeout with jitter to avoid thundering herd
- */
-export function calculateTimeoutWithJitter(
-  baseTimeout: number,
-  jitterPercent: number = 0.1
-): number {
-  const jitter = baseTimeout * jitterPercent;
-  const randomJitter = Math.random() * jitter - jitter / 2;
-  return Math.max(1000, baseTimeout + randomJitter);
-}
-
-/**
- * Format credit cost for display
- */
-export function formatCreditCost(cost: number): string {
-  if (cost % 1 === 0) {
-    return cost.toString();
-  }
-  return cost.toFixed(2);
-}
-
-/**
- * Truncate prompt to maximum length
- */
-export function truncatePrompt(prompt: string, maxLength: number = 5000): string {
-  if (prompt.length <= maxLength) {
-    return prompt;
-  }
-  return prompt.slice(0, maxLength - 3) + "...";
-}
-
-/**
- * Sanitize prompt by removing excessive whitespace
- */
-export function sanitizePrompt(prompt: string): string {
-  return prompt.trim().replace(/\s+/g, " ");
-}
-
-/**
- * Build error message with context
- */
-export function buildErrorMessage(
-  type: string,
-  context: Record<string, unknown>
-): string {
-  const contextStr = Object.entries(context)
-    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
-    .join(", ");
-  return `${type}${contextStr ? ` (${contextStr})` : ""}`;
-}
-
-/**
- * Check if value is defined (not null or undefined)
- */
-export function isDefined<T>(value: T | null | undefined): value is T {
-  return value !== null && value !== undefined;
-}
-
-/**
- * Filter out null and undefined values from object
- */
-export function removeNullish<T extends Record<string, unknown>>(
-  obj: T
-): Partial<T> {
-  return Object.fromEntries(
-    Object.entries(obj).filter(([_, value]) => isDefined(value))
-  ) as Partial<T>;
-}
-
-/**
- * Debounce function (for rate limiting)
- */
-export function debounce<T extends (...args: never[]) => unknown>(
-  func: T,
-  wait: number
-): (...args: Parameters<T>) => void {
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-
-  return function executedFunction(...args: Parameters<T>) {
-    const later = () => {
-      timeout = null;
-      func(...args);
-    };
-
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(later, wait);
-  };
-}
-
-/**
- * Simple throttle function
- */
-export function throttle<T extends (...args: never[]) => unknown>(
-  func: T,
-  limit: number
-): (...args: Parameters<T>) => void {
-  let inThrottle = false;
-
-  return function executedFunction(...args: Parameters<T>) {
-    if (!inThrottle) {
-      func(...args);
-      inThrottle = true;
-      setTimeout(() => (inThrottle = false), limit);
-    }
-  };
-}
+ * Helper Utilities - Re-exports
+ * Backward compatibility barrel file
+ */
+
+export {
+  formatImageDataUri,
+  extractBase64,
+  getDataUriExtension,
+  isImageDataUri,
+} from "./image-helpers.util";
+
+export {
+  truncatePrompt,
+  sanitizePrompt,
+} from "./prompt-helpers.util";
+
+export {
+  calculateTimeoutWithJitter,
+  debounce,
+  throttle,
+} from "./timing-helpers.util";
+
+export {
+  formatCreditCost,
+  buildErrorMessage,
+  isDefined,
+  removeNullish,
+} from "./general-helpers.util";

package/src/infrastructure/utils/image-helpers.util.ts

@@ -0,0 +1,40 @@
+/**
+ * Image Helper Utilities
+ * Functions for image data URI manipulation
+ */
+
+/**
+ * Format image as data URI if not already formatted
+ */
+export function formatImageDataUri(base64: string): string {
+  if (base64.startsWith("data:")) {
+    return base64;
+  }
+  return `data:image/jpeg;base64,${base64}`;
+}
+
+/**
+ * Extract base64 from data URI
+ */
+export function extractBase64(dataUri: string): string {
+  if (!dataUri.startsWith("data:")) {
+    return dataUri;
+  }
+  const parts = dataUri.split(",");
+  return parts.length > 1 ? parts[1] : dataUri;
+}
+
+/**
+ * Get file extension from data URI
+ */
+export function getDataUriExtension(dataUri: string): string | null {
+  const match = dataUri.match(/^data:image\/(\w+);base64/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Check if data URI is an image
+ */
+export function isImageDataUri(value: string): boolean {
+  return value.startsWith("data:image/");
+}

package/src/infrastructure/utils/prompt-helpers.util.ts

@@ -0,0 +1,21 @@
+/**
+ * Prompt Helper Utilities
+ * Functions for prompt manipulation and sanitization
+ */
+
+/**
+ * Truncate prompt to maximum length
+ */
+export function truncatePrompt(prompt: string, maxLength: number = 5000): string {
+  if (prompt.length <= maxLength) {
+    return prompt;
+  }
+  return prompt.slice(0, maxLength - 3) + "...";
+}
+
+/**
+ * Sanitize prompt by removing excessive whitespace
+ */
+export function sanitizePrompt(prompt: string): string {
+  return prompt.trim().replace(/\s+/g, " ");
+}

package/src/infrastructure/utils/timing-helpers.util.ts

@@ -0,0 +1,56 @@
+/**
+ * Timing Helper Utilities
+ * Functions for timing, debouncing, and throttling
+ */
+
+/**
+ * Calculate timeout with jitter to avoid thundering herd
+ */
+export function calculateTimeoutWithJitter(
+  baseTimeout: number,
+  jitterPercent: number = 0.1
+): number {
+  const jitter = baseTimeout * jitterPercent;
+  const randomJitter = Math.random() * jitter - jitter / 2;
+  return Math.max(1000, baseTimeout + randomJitter);
+}
+
+/**
+ * Debounce function (for rate limiting)
+ */
+export function debounce<T extends (...args: never[]) => unknown>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  return function executedFunction(...args: Parameters<T>) {
+    const later = () => {
+      timeout = null;
+      func(...args);
+    };
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(later, wait);
+  };
+}
+
+/**
+ * Simple throttle function
+ */
+export function throttle<T extends (...args: never[]) => unknown>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle = false;
+
+  return function executedFunction(...args: Parameters<T>) {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => (inThrottle = false), limit);
+    }
+  };
+}