@umituz/react-native-ai-fal-provider 2.0.20 → 2.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.0.20",
+  "version": "2.0.21",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -28,8 +28,8 @@
   },
   "peerDependencies": {
     "@fal-ai/client": ">=0.6.0",
-    "react": ">=18.2.0",
-    "react-native": ">=0.74.0"
+    "react": ">=19.0.0",
+    "react-native": ">=0.81.0"
   },
   "dependencies": {
     "@fal-ai/client": ">=0.6.0"
@@ -46,7 +46,7 @@
     "@tanstack/query-async-storage-persister": "^5.66.7",
     "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-query-persist-client": "^5.66.7",
-    "@types/react": "~18.3.12",
+    "@types/react": "~19.1.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "@umituz/react-native-auth": "*",
@@ -77,8 +77,8 @@
     "expo-video": "^3.0.15",
     "expo-web-browser": "^12.0.0",
     "firebase": "^12.7.0",
-    "react": "18.3.1",
-    "react-native": "0.76.1",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
     "react-native-gesture-handler": "^2.30.0",
     "react-native-purchases": "^9.7.5",
     "react-native-reanimated": "^4.2.1",

package/src/infrastructure/utils/collection-filters.util.ts

@@ -0,0 +1,171 @@
+/**
+ * Collection Filter Utilities
+ * Common filter operations for arrays of objects
+ */
+
+/**
+ * Filter array by property value
+ */
+export function filterByProperty<T>(
+  items: readonly T[],
+  property: keyof T,
+  value: unknown
+): T[] {
+  return items.filter((item) => item[property] === value);
+}
+
+/**
+ * Filter array by predicate function
+ */
+export function filterByPredicate<T>(
+  items: readonly T[],
+  predicate: (item: T) => boolean
+): T[] {
+  return items.filter(predicate);
+}
+
+/**
+ * Filter array by time range (timestamp property)
+ */
+export function filterByTimeRange<T>(
+  items: readonly T[],
+  timestampProperty: keyof T,
+  startTime: number,
+  endTime: number
+): T[] {
+  return items.filter((item) => {
+    const timestamp = item[timestampProperty] as unknown as number;
+    return timestamp >= startTime && timestamp <= endTime;
+  });
+}
+
+/**
+ * Filter array by multiple property values (OR logic)
+ */
+export function filterByAnyProperty<T>(
+  items: readonly T[],
+  property: keyof T,
+  values: readonly unknown[]
+): T[] {
+  const valueSet = new Set(values);
+  return items.filter((item) => valueSet.has(item[property]));
+}
+
+/**
+ * Sort array by date property (descending - newest first)
+ */
+export function sortByDateDescending<T>(
+  items: readonly T[],
+  dateProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const timeA = new Date(a[dateProperty] as unknown as string).getTime();
+    const timeB = new Date(b[dateProperty] as unknown as string).getTime();
+    return timeB - timeA;
+  });
+}
+
+/**
+ * Sort array by date property (ascending - oldest first)
+ */
+export function sortByDateAscending<T>(
+  items: readonly T[],
+  dateProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const timeA = new Date(a[dateProperty] as unknown as string).getTime();
+    const timeB = new Date(b[dateProperty] as unknown as string).getTime();
+    return timeA - timeB;
+  });
+}
+
+/**
+ * Sort array by number property (descending)
+ */
+export function sortByNumberDescending<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const numA = a[numberProperty] as unknown as number;
+    const numB = b[numberProperty] as unknown as number;
+    return numB - numA;
+  });
+}
+
+/**
+ * Sort array by number property (ascending)
+ */
+export function sortByNumberAscending<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const numA = a[numberProperty] as unknown as number;
+    const numB = b[numberProperty] as unknown as number;
+    return numA - numB;
+  });
+}
+
+/**
+ * Reduce array to sum of number property
+ */
+export function sumByProperty<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): number {
+  return items.reduce((sum, item) => {
+    const value = item[numberProperty] as unknown as number;
+    return sum + (typeof value === "number" ? value : 0);
+  }, 0);
+}
+
+/**
+ * Group array by property value
+ */
+export function groupByProperty<T>(
+  items: readonly T[],
+  property: keyof T
+): Map<unknown, T[]> {
+  const groups = new Map<unknown, T[]>();
+  for (const item of items) {
+    const key = item[property];
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+
+/**
+ * Chunk array into smaller arrays of specified size
+ */
+export function chunkArray<T>(items: readonly T[], chunkSize: number): T[][] {
+  const result: T[][] = [];
+  for (let i = 0; i < items.length; i += chunkSize) {
+    result.push(items.slice(i, i + chunkSize) as T[]);
+  }
+  return result;
+}
+
+/**
+ * Get distinct values of a property from array
+ */
+export function distinctByProperty<T>(
+  items: readonly T[],
+  property: keyof T
+): unknown[] {
+  const seen = new Set<unknown>();
+  const result: unknown[] = [];
+  for (const item of items) {
+    const value = item[property];
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}