@umituz/react-native-firebase 2.4.80 → 2.4.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.80",
+  "version": "2.4.81",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/firestore/domain/constants/QuotaLimits.ts

@@ -6,6 +6,8 @@
  * Based on Firestore free tier and pricing documentation
  */
 
+import { calculatePercentage, calculateRemaining } from '../../../../shared/domain/utils/calculation.util';
+
 /**
  * Firestore free tier daily limits
  * https://firebase.google.com/docs/firestore/quotas
@@ -62,13 +64,13 @@ export const QUOTA_THRESHOLDS = {
 
 /**
  * Calculate quota usage percentage
+ * Optimized: Uses centralized calculation utility
  * @param current - Current usage count
  * @param limit - Total limit
  * @returns Percentage (0-1)
  */
 export function calculateQuotaUsage(current: number, limit: number): number {
-  if (limit <= 0) return current > 0 ? 1 : 0;
-  return Math.min(1, current / limit);
+  return calculatePercentage(current, limit);
 }
 
 /**
@@ -89,10 +91,11 @@ export function isQuotaThresholdReached(
 
 /**
  * Get remaining quota
+ * Optimized: Uses centralized calculation utility
  * @param current - Current usage count
  * @param limit - Total limit
  * @returns Remaining quota count
  */
 export function getRemainingQuota(current: number, limit: number): number {
-  return Math.max(0, limit - current);
+  return calculateRemaining(current, limit);
 }

package/src/domains/firestore/utils/dateUtils.ts

@@ -1,4 +1,5 @@
 import { Timestamp } from 'firebase/firestore';
+import { diffMinutes, diffHours, diffDays } from '../../../shared/domain/utils/calculation.util';
 
 /**
  * Validate ISO 8601 date string format
@@ -72,6 +73,7 @@ const DEFAULT_LABELS: RelativeTimeLabels = {
 
 /**
  * Format a Date (or Firestore Timestamp) as a short relative time string.
+ * Optimized: Uses centralized calculation utilities
  *
  * Examples: "now", "5m", "2h", "3d", or a localized date for older values.
  *
@@ -83,17 +85,17 @@ export function formatRelativeTime(
   labels: RelativeTimeLabels = DEFAULT_LABELS,
 ): string {
   const now = new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffMins = Math.floor(diffMs / 60_000);
 
-  if (diffMins < 1) return labels.now;
-  if (diffMins < 60) return `${diffMins}${labels.minutes}`;
+  // Use centralized calculation utilities
+  const minsAgo = diffMinutes(now, date);
+  if (minsAgo < 1) return labels.now;
+  if (minsAgo < 60) return `${minsAgo}${labels.minutes}`;
 
-  const diffHours = Math.floor(diffMins / 60);
-  if (diffHours < 24) return `${diffHours}${labels.hours}`;
+  const hoursAgo = diffHours(now, date);
+  if (hoursAgo < 24) return `${hoursAgo}${labels.hours}`;
 
-  const diffDays = Math.floor(diffHours / 24);
-  if (diffDays < 7) return `${diffDays}${labels.days}`;
+  const daysAgo = diffDays(now, date);
+  if (daysAgo < 7) return `${daysAgo}${labels.days}`;
 
   return date.toLocaleDateString();
 }

package/src/domains/firestore/utils/pagination.helper.ts

@@ -5,7 +5,7 @@
  * Handles pagination logic, cursor management, and hasMore detection.
  *
  * App-agnostic: Works with any document type and any collection.
- * Optimized: Uses singleton instance pattern for memory efficiency.
+ * Optimized: Uses centralized calculation utilities.
  *
  * @example
  * ```typescript
@@ -17,11 +17,18 @@
  */
 
 import type { PaginatedResult, PaginationParams } from '../types/pagination.types';
+import {
+  safeSlice,
+  getFetchLimit as calculateFetchLimit,
+  hasMore as checkHasMore,
+  getResultCount,
+  safeFloor,
+} from '../../../shared/domain/utils/calculation.util';
 
 export class PaginationHelper<T> {
   /**
    * Build paginated result from items
-   * Optimized: Minimized array operations and function calls
+   * Optimized: Uses centralized calculation utilities
    *
    * @param items - All items fetched (should be limit + 1)
    * @param pageLimit - Requested page size
@@ -33,12 +40,13 @@ export class PaginationHelper<T> {
     pageLimit: number,
     getCursor: (item: T) => string,
   ): PaginatedResult<T> {
-    const hasMore = items.length > pageLimit;
-    const resultItems = hasMore ? items.slice(0, pageLimit) : items;
+    const hasMoreValue = checkHasMore(items.length, pageLimit);
+    const resultCount = getResultCount(items.length, pageLimit);
+    const resultItems = safeSlice(items, 0, resultCount);
 
     // Safe access: check array is not empty before accessing last item
     let nextCursor: string | null = null;
-    if (hasMore && resultItems.length > 0) {
+    if (hasMoreValue && resultItems.length > 0) {
       const lastItem = resultItems[resultItems.length - 1];
       if (lastItem) {
         nextCursor = getCursor(lastItem);
@@ -48,13 +56,13 @@ export class PaginationHelper<T> {
     return {
       items: resultItems,
       nextCursor,
-      hasMore,
+      hasMore: hasMoreValue,
     };
   }
 
   /**
    * Get default limit from params or use default
-   * Optimized: Direct math operations without intermediate variables
+   * Optimized: Uses centralized calculation utility
    *
    * @param params - Pagination params
    * @param defaultLimit - Default limit if not specified
@@ -62,19 +70,18 @@ export class PaginationHelper<T> {
    */
   getLimit(params?: PaginationParams, defaultLimit: number = 10): number {
     const limit = params?.limit ?? defaultLimit;
-    // Direct calculation: max(1, floor(limit))
-    return limit < 1 ? 1 : (limit % 1 === 0 ? limit : Math.floor(limit));
+    return safeFloor(limit, 1);
   }
 
   /**
    * Calculate fetch limit (page limit + 1 for hasMore detection)
-   * Inline function for performance (this is called frequently)
+   * Optimized: Uses centralized calculation utility
    *
    * @param pageLimit - Requested page size
    * @returns Fetch limit (pageLimit + 1)
    */
   getFetchLimit(pageLimit: number): number {
-    return pageLimit + 1;
+    return calculateFetchLimit(pageLimit);
   }
 
   /**

package/src/domains/firestore/utils/query/filters.util.ts

@@ -1,6 +1,7 @@
 /**
  * Query Filters Utility
  * Utilities for creating Firestore field filters
+ * Optimized: Uses centralized calculation utilities
  */
 
 import {
@@ -11,6 +12,26 @@ import {
   type Query,
 } from "firebase/firestore";
 
+/**
+ * Chunk array into smaller arrays (local copy for this module)
+ * Inlined here to avoid circular dependencies
+ */
+function chunkArray(array: readonly (string | number)[], chunkSize: number): (string | number)[][] {
+  if (chunkSize <= 0) {
+    throw new Error('chunkSize must be greater than 0');
+  }
+
+  const chunks: (string | number)[][] = [];
+  const len = array.length;
+
+  for (let i = 0; i < len; i += chunkSize) {
+    const end = Math.min(i + chunkSize, len);
+    chunks.push(array.slice(i, end));
+  }
+
+  return chunks;
+}
+
 export interface FieldFilter {
   field: string;
   operator: WhereFilterOp;
@@ -21,6 +42,7 @@ const MAX_IN_OPERATOR_VALUES = 10;
 
 /**
  * Apply field filter with 'in' operator and chunking support
+ * Optimized: Uses centralized chunkArray utility
  */
 export function applyFieldFilter(q: Query, filter: FieldFilter): Query {
   const { field, operator, value } = filter;
@@ -31,11 +53,8 @@ export function applyFieldFilter(q: Query, filter: FieldFilter): Query {
     }
 
     // Split into chunks of 10 and use 'or' operator
-    const chunks: (string[] | number[])[] = [];
-    for (let i = 0; i < value.length; i += MAX_IN_OPERATOR_VALUES) {
-      chunks.push(value.slice(i, i + MAX_IN_OPERATOR_VALUES));
-    }
-
+    // Optimized: Uses local chunkArray utility
+    const chunks = chunkArray(value, MAX_IN_OPERATOR_VALUES);
     const orConditions = chunks.map((chunk) => where(field, "in", chunk));
     return query(q, or(...orConditions));
   }

package/src/shared/domain/utils/calculation.util.ts

@@ -0,0 +1,352 @@
+/**
+ * Calculation Utilities
+ * Common mathematical operations used across the codebase
+ * Optimized for performance with minimal allocations
+ */
+
+/**
+ * Safely calculates percentage (0-1 range)
+ * Optimized: Guards against division by zero
+ *
+ * @param current - Current value
+ * @param limit - Maximum value
+ * @returns Percentage between 0 and 1
+ *
+ * @example
+ * ```typescript
+ * const percentage = calculatePercentage(750, 1000); // 0.75
+ * const percentage = calculatePercentage(1200, 1000); // 1.0 (capped)
+ * const percentage = calculatePercentage(0, 1000); // 0.0
+ * ```
+ */
+export function calculatePercentage(current: number, limit: number): number {
+  if (limit <= 0) return 0;
+  if (current <= 0) return 0;
+  if (current >= limit) return 1;
+  return current / limit;
+}
+
+/**
+ * Calculates remaining quota
+ * Optimized: Single Math.max call
+ *
+ * @param current - Current usage
+ * @param limit - Maximum limit
+ * @returns Remaining amount (minimum 0)
+ *
+ * @example
+ * ```typescript
+ * const remaining = calculateRemaining(250, 1000); // 750
+ * const remaining = calculateRemaining(1200, 1000); // 0 (capped)
+ * ```
+ */
+export function calculateRemaining(current: number, limit: number): number {
+  return Math.max(0, limit - current);
+}
+
+/**
+ * Safe floor with minimum value
+ * Optimized: Single comparison
+ *
+ * @param value - Value to floor
+ * @param min - Minimum allowed value
+ * @returns Floored value, at least min
+ *
+ * @example
+ * ```typescript
+ * const result = safeFloor(5.7, 1); // 5
+ * const result = safeFloor(0.3, 1); // 1 (min enforced)
+ * const result = safeFloor(-2.5, 0); // 0 (min enforced)
+ * ```
+ */
+export function safeFloor(value: number, min: number): number {
+  const floored = Math.floor(value);
+  return floored < min ? min : floored;
+}
+
+/**
+ * Safe ceil with maximum value
+ * Optimized: Single comparison
+ *
+ * @param value - Value to ceil
+ * @param max - Maximum allowed value
+ * @returns Ceiled value, at most max
+ *
+ * @example
+ * ```typescript
+ * const result = safeCeil(5.2, 10); // 6
+ * const result = safeCeil(9.8, 10); // 10 (max enforced)
+ * const result = safeCeil(12.1, 10); // 10 (max enforced)
+ * ```
+ */
+export function safeCeil(value: number, max: number): number {
+  const ceiled = Math.ceil(value);
+  return ceiled > max ? max : ceiled;
+}
+
+/**
+ * Clamp value between min and max
+ * Optimized: Efficient without branching
+ *
+ * @param value - Value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ *
+ * @example
+ * ```typescript
+ * const result = clamp(5, 0, 10); // 5
+ * const result = clamp(-5, 0, 10); // 0
+ * const result = clamp(15, 0, 10); // 10
+ * ```
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(value, max));
+}
+
+/**
+ * Calculate milliseconds between two dates
+ * Optimized: Direct subtraction without Date object creation
+ *
+ * @param date1 - First date (timestamp or Date)
+ * @param date2 - Second date (timestamp or Date)
+ * @returns Difference in milliseconds (date1 - date2)
+ *
+ * @example
+ * ```typescript
+ * const diff = diffMs(Date.now(), Date.now() - 3600000); // 3600000
+ * ```
+ */
+export function diffMs(date1: number | Date, date2: number | Date): number {
+  const ms1 = typeof date1 === 'number' ? date1 : date1.getTime();
+  const ms2 = typeof date2 === 'number' ? date2 : date2.getTime();
+  return ms1 - ms2;
+}
+
+/**
+ * Calculate minutes difference between two dates
+ * Optimized: Single Math.floor call
+ *
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns Difference in minutes (floored)
+ *
+ * @example
+ * ```typescript
+ * const diff = diffMinutes(Date.now(), Date.now() - 180000); // 3
+ * ```
+ */
+export function diffMinutes(date1: number | Date, date2: number | Date): number {
+  const msDiff = diffMs(date1, date2);
+  return Math.floor(msDiff / 60_000);
+}
+
+/**
+ * Calculate hours difference between two dates
+ * Optimized: Single Math.floor call
+ *
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns Difference in hours (floored)
+ *
+ * @example
+ * ```typescript
+ * const diff = diffHours(Date.now(), Date.now() - 7200000); // 2
+ * ```
+ */
+export function diffHours(date1: number | Date, date2: number | Date): number {
+  const minsDiff = diffMinutes(date1, date2);
+  return Math.floor(minsDiff / 60);
+}
+
+/**
+ * Calculate days difference between two dates
+ * Optimized: Single Math.floor call
+ *
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns Difference in days (floored)
+ *
+ * @example
+ * ```typescript
+ * const diff = diffDays(Date.now(), Date.now() - 172800000); // 2
+ * ```
+ */
+export function diffDays(date1: number | Date, date2: number | Date): number {
+  const hoursDiff = diffHours(date1, date2);
+  return Math.floor(hoursDiff / 24);
+}
+
+/**
+ * Safe array slice with bounds checking
+ * Optimized: Prevents negative indices and out-of-bounds
+ *
+ * @param array - Array to slice
+ * @param start - Start index (inclusive)
+ * @param end - End index (exclusive)
+ * @returns Sliced array
+ *
+ * @example
+ * ```typescript
+ * const items = [1, 2, 3, 4, 5];
+ * const sliced = safeSlice(items, 1, 3); // [2, 3]
+ * const sliced = safeSlice(items, -5, 10); // [1, 2, 3, 4, 5] (bounds checked)
+ * ```
+ */
+export function safeSlice<T>(array: T[], start: number, end?: number): T[] {
+  const len = array.length;
+
+  // Clamp start index
+  const safeStart = start < 0 ? 0 : (start >= len ? len : start);
+
+  // Clamp end index
+  const safeEnd = end === undefined
+    ? len
+    : (end < 0 ? 0 : (end >= len ? len : end));
+
+  // Only slice if valid range
+  if (safeStart >= safeEnd) {
+    return [];
+  }
+
+  return array.slice(safeStart, safeEnd);
+}
+
+/**
+ * Calculate fetch limit for pagination (pageLimit + 1)
+ * Optimized: Simple addition
+ *
+ * @param pageLimit - Requested page size
+ * @returns Fetch limit (pageLimit + 1 for hasMore detection)
+ *
+ * @example
+ * ```typescript
+ * const fetchLimit = getFetchLimit(10); // 11
+ * ```
+ */
+export function getFetchLimit(pageLimit: number): number {
+  return pageLimit + 1;
+}
+
+/**
+ * Calculate if hasMore based on items length and page limit
+ * Optimized: Direct comparison
+ *
+ * @param itemsLength - Total items fetched
+ * @param pageLimit - Requested page size
+ * @returns true if there are more items
+ *
+ * @example
+ * ```typescript
+ * const hasMore = hasMore(11, 10); // true
+ * const hasMore = hasMore(10, 10); // false
+ * ```
+ */
+export function hasMore(itemsLength: number, pageLimit: number): boolean {
+  return itemsLength > pageLimit;
+}
+
+/**
+ * Calculate result items count (min of itemsLength and pageLimit)
+ * Optimized: Single Math.min call
+ *
+ * @param itemsLength - Total items fetched
+ * @param pageLimit - Requested page size
+ * @returns Number of items to return
+ *
+ * @example
+ * ```typescript
+ * const count = getResultCount(11, 10); // 10
+ * const count = getResultCount(8, 10); // 8
+ * ```
+ */
+export function getResultCount(itemsLength: number, pageLimit: number): number {
+  return Math.min(itemsLength, pageLimit);
+}
+
+/**
+ * Chunk array into smaller arrays
+ * Optimized: Pre-allocated chunks when size is known
+ *
+ * @param array - Array to chunk
+ * @param chunkSize - Size of each chunk
+ * @returns Array of chunks
+ *
+ * @example
+ * ```typescript
+ * const chunks = chunkArray([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+export function chunkArray<T>(array: readonly T[], chunkSize: number): T[][] {
+  if (chunkSize <= 0) {
+    throw new Error('chunkSize must be greater than 0');
+  }
+
+  const chunks: T[][] = [];
+  const len = array.length;
+
+  for (let i = 0; i < len; i += chunkSize) {
+    const end = Math.min(i + chunkSize, len);
+    chunks.push(array.slice(i, end) as T[]);
+  }
+
+  return chunks;
+}
+
+/**
+ * Sum array of numbers
+ * Optimized: Direct for-loop (faster than reduce)
+ *
+ * @param numbers - Array of numbers to sum
+ * @returns Sum of all numbers
+ *
+ * @example
+ * ```typescript
+ * const sum = sumArray([1, 2, 3, 4, 5]); // 15
+ * ```
+ */
+export function sumArray(numbers: number[]): number {
+  let sum = 0;
+  for (let i = 0; i < numbers.length; i++) {
+    const num = numbers[i];
+    if (num !== undefined && num !== null) {
+      sum += num;
+    }
+  }
+  return sum;
+}
+
+/**
+ * Average of array of numbers
+ * Optimized: Single-pass calculation
+ *
+ * @param numbers - Array of numbers
+ * @returns Average value
+ *
+ * @example
+ * ```typescript
+ * const avg = averageArray([1, 2, 3, 4, 5]); // 3
+ * ```
+ */
+export function averageArray(numbers: number[]): number {
+  if (numbers.length === 0) return 0;
+  return sumArray(numbers) / numbers.length;
+}
+
+/**
+ * Round to decimal places
+ * Optimized: Efficient rounding without string conversion
+ *
+ * @param value - Value to round
+ * @param decimals - Number of decimal places
+ * @returns Rounded value
+ *
+ * @example
+ * ```typescript
+ * const rounded = roundToDecimals(3.14159, 2); // 3.14
+ * ```
+ */
+export function roundToDecimals(value: number, decimals: number): number {
+  const multiplier = Math.pow(10, decimals);
+  return Math.round(value * multiplier) / multiplier;
+}

package/src/shared/domain/utils/index.ts

@@ -31,3 +31,24 @@ export { toErrorInfo } from './error-handlers/error-converters';
 export {
   ERROR_MESSAGES,
 } from './error-handlers/error-messages';
+
+// Calculation utilities
+export {
+  calculatePercentage,
+  calculateRemaining,
+  safeFloor,
+  safeCeil,
+  clamp,
+  diffMs,
+  diffMinutes,
+  diffHours,
+  diffDays,
+  safeSlice,
+  getFetchLimit,
+  hasMore,
+  getResultCount,
+  chunkArray,
+  sumArray,
+  averageArray,
+  roundToDecimals,
+} from './calculation.util';