@umituz/react-native-subscription 2.27.114 → 2.27.116

package/src/shared/types/CommonTypes.ts

@@ -3,6 +3,8 @@
  * Shared types used across multiple domains
  */
 
+import type { Platform as SubscriptionPlatform } from "../../domains/subscription/core/SubscriptionConstants";
+
 /**
  * Purchase result from any purchase operation
  */
@@ -57,9 +59,12 @@ export interface TransactionMetadata {
 /**
  * Platform information
  */
-export type Platform = 'ios' | 'android';
+export type Platform = SubscriptionPlatform;
 
 /**
  * Purchase source tracking
  */
 export type PurchaseSource = 'settings' | 'paywall' | 'upgrade_prompt' | 'auto-execution' | 'manual';
+
+// Re-export from SubscriptionConstants to maintain compatibility
+export { PLATFORM, PURCHASE_SOURCE, type Platform as SubscriptionPlatformType, type PurchaseSource as PurchaseSourceType } from "../../domains/subscription/core/SubscriptionConstants";

package/src/shared/types/ReactTypes.ts

@@ -0,0 +1,80 @@
+/**
+ * Shared React Types
+ * Common type definitions for React components and hooks
+ */
+
+export type VoidCallback = () => void;
+export type AsyncCallback = () => Promise<void> | Promise<void>;
+
+export type EventHandler<T = void> = (event: T) => void;
+export type AsyncEventHandler<T = void> = (event: T) => Promise<void>;
+
+export interface LoadingState {
+  isLoading: boolean;
+  isRefreshing: boolean;
+}
+
+export interface ErrorState {
+  error: Error | null;
+  hasError: boolean;
+}
+
+export interface PaginationState {
+  page: number;
+  perPage: number;
+  total: number;
+  hasMore: boolean;
+}
+
+export interface ScreenProps<T = unknown> {
+  route: {
+    params?: T;
+  };
+  navigation: any;
+}
+
+export type ButtonProps = {
+  onPress: EventHandler | AsyncEventHandler;
+  disabled?: boolean;
+  loading?: boolean;
+};
+
+export interface SelectableItem {
+  id: string;
+  selected: boolean;
+}
+
+export interface FormFieldProps<T> {
+  value: T;
+  onChange: (value: T) => void;
+  error?: string;
+  label?: string;
+  placeholder?: string;
+  disabled?: boolean;
+}
+
+export interface ListItemProps<T> {
+  item: T;
+  index: number;
+  onPress?: (item: T, index: number) => void;
+  onLongPress?: (item: T, index: number) => void;
+}
+
+export interface SearchState {
+  query: string;
+  results: unknown[];
+  isSearching: boolean;
+}
+
+export interface TabItem {
+  id: string;
+  title: string;
+  icon?: string;
+  badge?: number | string;
+}
+
+export interface ModalProps {
+  visible: boolean;
+  onClose: () => void;
+  title?: string;
+}

package/src/shared/utils/Result.ts

@@ -114,22 +114,6 @@ export function tryCatchSync<T>(
     return failure(mappedError);
   }
 }
-export function tryCatchSync<T>(
-  fn: () => T,
-  errorMapper?: (error: unknown) => Error
-): Result<T, Error> {
-  try {
-    const data = fn();
-    return success(data);
-  } catch {
-    const mappedError = errorMapper
-      ? errorMapper(error)
-      : error instanceof Error
-        ? error
-        : new Error(String(error));
-    return failure(mappedError);
-  }
-}
 
 /** Combine multiple results into one */
 export function combine<T, E>(results: Result<T, E>[]): Result<T[], E> {

package/src/shared/utils/arrayUtils.core.ts

@@ -0,0 +1,81 @@
+/**
+ * Array Utilities - Core Operations
+ * Basic array manipulation functions
+ */
+
+/**
+ * Check if array is empty
+ */
+export function isEmpty<T>(arr: readonly T[] | null | undefined): boolean {
+  return !arr || arr.length === 0;
+}
+
+/**
+ * Check if array has elements
+ */
+export function isNotEmpty<T>(arr: readonly T[] | null | undefined): boolean {
+  return !isEmpty(arr);
+}
+
+/**
+ * Get first element of array or null
+ */
+export function first<T>(arr: readonly T[] | null | undefined): T | null {
+  if (!arr || arr.length === 0) return null;
+  return arr[0] ?? null;
+}
+
+/**
+ * Get last element of array or null
+ */
+export function last<T>(arr: readonly T[] | null | undefined): T | null {
+  if (!arr || arr.length === 0) return null;
+  return arr[arr.length - 1] ?? null;
+}
+
+/**
+ * Get nth element of array or null
+ */
+export function nth<T>(arr: readonly T[], index: number): T | null {
+  if (index < 0) index = arr.length + index;
+  if (index < 0 || index >= arr.length) return null;
+  return arr[index] ?? null;
+}
+
+/**
+ * Remove first element from array
+ */
+export function removeFirst<T>(arr: T[]): T[] {
+  return arr.slice(1);
+}
+
+/**
+ * Remove last element from array
+ */
+export function removeLast<T>(arr: T[]): T[] {
+  return arr.slice(0, -1);
+}
+
+/**
+ * Remove element at index
+ */
+export function removeAt<T>(arr: readonly T[], index: number): T[] {
+  return arr.filter((_, i) => i !== index);
+}
+
+/**
+ * Remove elements that match a predicate
+ */
+export function removeWhere<T>(
+  arr: readonly T[],
+  predicate: (item: T, index: number) => boolean
+): T[] {
+  return arr.filter((item, index) => !predicate(item, index));
+}
+
+/**
+ * Unique array elements (removes duplicates)
+ */
+export function unique<T>(arr: readonly T[]): T[] {
+  return Array.from(new Set(arr));
+}

package/src/shared/utils/arrayUtils.query.ts

@@ -0,0 +1,118 @@
+/**
+ * Array Utilities - Query Operations
+ * Array searching, filtering, and grouping functions
+ */
+
+/**
+ * Group array elements by a key function
+ */
+export function groupBy<T, K extends string | number | symbol>(
+  arr: readonly T[],
+  keyFn: (item: T, index: number) => K
+): Record<K, T[]> {
+  return arr.reduce((result, item, index) => {
+    const key = keyFn(item, index);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(item);
+    return result;
+  }, {} as Record<K, T[]>);
+}
+
+/**
+ * Unique array elements by a key function
+ */
+export function uniqueBy<T, K>(arr: readonly T[], keyFn: (item: T) => K): T[] {
+  const seen = new Set<K>();
+  return arr.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+/**
+ * Shuffle array (Fisher-Yates algorithm)
+ */
+export function shuffle<T>(arr: readonly T[]): T[] {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = result[i]!;
+    result[i] = result[j]!;
+    result[j] = temp;
+  }
+  return result;
+}
+
+/**
+ * Sort array by a key function
+ */
+export function sortBy<T>(
+  arr: readonly T[],
+  keyFn: (item: T) => string | number,
+  order: "asc" | "desc" = "asc"
+): T[] {
+  return [...arr].sort((a, b) => {
+    const keyA = keyFn(a);
+    const keyB = keyFn(b);
+    if (keyA < keyB) return order === "asc" ? -1 : 1;
+    if (keyA > keyB) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+
+/**
+ * Pick random element(s) from array
+ */
+export function sample<T>(arr: readonly T[], count: number = 1): T[] {
+  if (arr.length === 0) return [];
+  const shuffled = shuffle([...arr]);
+  return shuffled.slice(0, Math.min(count, arr.length));
+}
+
+/**
+ * Find intersection of two arrays
+ */
+export function intersection<T>(arr1: readonly T[], arr2: readonly T[]): T[] {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => set2.has(item));
+}
+
+/**
+ * Find difference of two arrays (elements in arr1 but not in arr2)
+ */
+export function difference<T>(arr1: readonly T[], arr2: readonly T[]): T[] {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => !set2.has(item));
+}
+
+/**
+ * Find symmetric difference of two arrays (elements in either array but not both)
+ */
+export function symmetricDifference<T>(arr1: readonly T[], arr2: readonly T[]): T[] {
+  const set1 = new Set(arr1);
+  const set2 = new Set(arr2);
+  return [
+    ...arr1.filter((item) => !set2.has(item)),
+    ...arr2.filter((item) => !set1.has(item)),
+  ];
+}
+
+/**
+ * Check if array contains all elements of another array
+ */
+export function containsAll<T>(arr: readonly T[], values: readonly T[]): boolean {
+  const arrSet = new Set(arr);
+  return values.every((value) => arrSet.has(value));
+}
+
+/**
+ * Check if array contains any element of another array
+ */
+export function containsAny<T>(arr: readonly T[], values: readonly T[]): boolean {
+  const arrSet = new Set(arr);
+  return values.some((value) => arrSet.has(value));
+}

package/src/shared/utils/arrayUtils.transforms.ts

@@ -0,0 +1,116 @@
+/**
+ * Array Utilities - Transformations
+ * Array transformation and manipulation functions
+ */
+
+/**
+ * Chunk array into smaller arrays of specified size
+ */
+export function chunk<T>(arr: readonly T[], size: number): T[][] {
+  if (size <= 0) return [];
+  const result: T[][] = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+
+/**
+ * Flatten array one level deep
+ */
+export function flatten<T>(arr: readonly (readonly T[] | T)[]): T[] {
+  const result: T[] = [];
+  for (const item of arr) {
+    if (Array.isArray(item)) {
+      result.push(...item);
+    } else if (item !== undefined) {
+      result.push(item as T);
+    }
+  }
+  return result;
+}
+
+/**
+ * Flatten array recursively
+ */
+export function flattenDeep<T>(arr: readonly unknown[]): T[] {
+  const result: T[] = [];
+  const stack = [...arr];
+
+  while (stack.length > 0) {
+    const item = stack.shift();
+    if (Array.isArray(item)) {
+      stack.unshift(...item);
+    } else if (item !== undefined) {
+      result.push(item as T);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Zip two arrays together
+ */
+export function zip<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][] {
+  const length = Math.min(arr1.length, arr2.length);
+  const result: [T, U][] = [];
+  for (let i = 0; i < length; i++) {
+    result.push([arr1[i]!, arr2[i]!]);
+  }
+  return result;
+}
+
+/**
+ * Partition array into two arrays based on predicate
+ */
+export function partition<T>(
+  arr: readonly T[],
+  predicate: (item: T, index: number) => boolean
+): [T[], T[]] {
+  const truthy: T[] = [];
+  const falsy: T[] = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item !== undefined) {
+      if (predicate(item, i)) {
+        truthy.push(item);
+      } else {
+        falsy.push(item);
+      }
+    }
+  }
+
+  return [truthy, falsy];
+}
+
+/**
+ * Move element from one index to another
+ */
+export function move<T>(arr: readonly T[], from: number, to: number): T[] {
+  if (from < 0 || from >= arr.length || to < 0 || to >= arr.length) {
+    return [...arr];
+  }
+  const result = [...arr];
+  const element = result[from];
+  if (element === undefined) return result;
+
+  result.splice(from, 1);
+  result.splice(to, 0, element);
+  return result;
+}
+
+/**
+ * Swap two elements in array
+ */
+export function swap<T>(arr: readonly T[], index1: number, index2: number): T[] {
+  if (index1 < 0 || index1 >= arr.length || index2 < 0 || index2 >= arr.length) {
+    return [...arr];
+  }
+  const result = [...arr];
+  const temp = result[index1];
+  result[index1] = result[index2]!;
+  result[index2] = temp!;
+  return result;
+}

package/src/shared/utils/arrayUtils.ts

@@ -0,0 +1,19 @@
+/**
+ * Array Utilities
+ * Re-exports all array utility modules
+ */
+
+export * from "./arrayUtils.core";
+export * from "./arrayUtils.transforms";
+export * from "./arrayUtils.query";
+
+/**
+ * Create an array of numbers from start to end (inclusive)
+ */
+export function range(start: number, end: number, step: number = 1): number[] {
+  const result: number[] = [];
+  for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
+    result.push(i);
+  }
+  return result;
+}

package/src/shared/utils/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared Utilities
+ */
+
+export * from "./arrayUtils";
+export * from "./BaseError";
+export * from "./InsufficientCreditsError";
+export * from "./Logger";
+export * from "./numberUtils";
+export * from "./Result";
+export * from "./stringUtils";
+export * from "./SubscriptionConfig";
+export * from "./SubscriptionError";
+export * from "./validators";

package/src/shared/utils/numberUtils.aggregate.ts

@@ -0,0 +1,35 @@
+/**
+ * Number Utilities - Aggregation
+ * Array aggregation functions for numbers
+ */
+
+/**
+ * Calculate the sum of an array of numbers
+ */
+export function sum(values: number[]): number {
+  return values.reduce((acc, val) => acc + val, 0);
+}
+
+/**
+ * Calculate the average of an array of numbers
+ */
+export function average(values: number[]): number {
+  if (values.length === 0) return 0;
+  return sum(values) / values.length;
+}
+
+/**
+ * Find the minimum value in an array
+ */
+export function min(values: number[]): number | null {
+  if (values.length === 0) return null;
+  return Math.min(...values);
+}
+
+/**
+ * Find the maximum value in an array
+ */
+export function max(values: number[]): number | null {
+  if (values.length === 0) return null;
+  return Math.max(...values);
+}

package/src/shared/utils/numberUtils.core.ts

@@ -0,0 +1,73 @@
+/**
+ * Number Utilities - Core Operations
+ * Basic numeric calculation functions
+ */
+
+/**
+ * Clamp a number between min and max values
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Round a number to specified decimal places
+ */
+export function roundTo(value: number, decimals: number = 2): number {
+  const multiplier = Math.pow(10, decimals);
+  return Math.round(value * multiplier) / multiplier;
+}
+
+/**
+ * Calculate percentage
+ */
+export function calculatePercentage(value: number, total: number): number {
+  if (total === 0) return 0;
+  return (value / total) * 100;
+}
+
+/**
+ * Calculate percentage and clamp between 0-100
+ */
+export function calculatePercentageClamped(value: number, total: number): number {
+  return clamp(calculatePercentage(value, total), 0, 100);
+}
+
+/**
+ * Check if two numbers are approximately equal (within epsilon)
+ */
+export function isApproximatelyEqual(a: number, b: number, epsilon: number = 0.0001): boolean {
+  return Math.abs(a - b) < epsilon;
+}
+
+/**
+ * Safe division that returns 0 instead of NaN
+ */
+export function safeDivide(numerator: number, denominator: number): number {
+  if (denominator === 0) return 0;
+  return numerator / denominator;
+}
+
+/**
+ * Calculate remaining value after subtraction with floor at 0
+ */
+export function calculateRemaining(current: number, cost: number): number {
+  return Math.max(0, current - cost);
+}
+
+/**
+ * Check if user can afford a cost
+ */
+export function canAfford(balance: number | null | undefined, cost: number): boolean {
+  if (balance === null || balance === undefined) return false;
+  return balance >= cost;
+}
+
+/**
+ * Calculate credit percentage for UI display
+ */
+export function calculateCreditPercentage(current: number | null | undefined, max: number): number {
+  if (current === null || current === undefined) return 0;
+  if (max <= 0) return 100;
+  return calculatePercentageClamped(current, max);
+}

package/src/shared/utils/numberUtils.format.ts

@@ -0,0 +1,42 @@
+/**
+ * Number Utilities - Formatting
+ * Number formatting and display functions
+ */
+
+/**
+ * Format number with thousands separator
+ */
+export function formatNumber(value: number, locale: string = "en-US"): string {
+  return new Intl.NumberFormat(locale).format(value);
+}
+
+/**
+ * Format number as compact string (e.g., 1K, 1M, 1B)
+ */
+export function formatCompactNumber(value: number, locale: string = "en-US"): string {
+  return new Intl.NumberFormat(locale, {
+    notation: "compact",
+    compactDisplay: "short",
+  }).format(value);
+}
+
+/**
+ * Round to nearest multiple (e.g., round to nearest 0.99)
+ */
+export function roundToNearest(value: number, multiple: number): number {
+  return Math.round(value / multiple) * multiple;
+}
+
+/**
+ * Floor to nearest multiple
+ */
+export function floorToNearest(value: number, multiple: number): number {
+  return Math.floor(value / multiple) * multiple;
+}
+
+/**
+ * Ceiling to nearest multiple
+ */
+export function ceilToNearest(value: number, multiple: number): number {
+  return Math.ceil(value / multiple) * multiple;
+}

package/src/shared/utils/numberUtils.math.ts

@@ -0,0 +1,48 @@
+/**
+ * Number Utilities - Math Operations
+ * Advanced mathematical operations
+ */
+
+import { clamp } from "./numberUtils.core";
+
+/**
+ * Linear interpolation between two values
+ */
+export function lerp(start: number, end: number, progress: number): number {
+  return start + (end - start) * clamp(progress, 0, 1);
+}
+
+/**
+ * Map a value from one range to another
+ */
+export function mapRange(
+  value: number,
+  inMin: number,
+  inMax: number,
+  outMin: number,
+  outMax: number
+): number {
+  const progress = (value - inMin) / (inMax - inMin);
+  return lerp(outMin, outMax, progress);
+}
+
+/**
+ * Check if a number is within range (inclusive)
+ */
+export function isInRange(value: number, min: number, max: number): boolean {
+  return value >= min && value <= max;
+}
+
+/**
+ * Calculate tax amount
+ */
+export function calculateTax(subtotal: number, taxRate: number): number {
+  return subtotal * (taxRate / 100);
+}
+
+/**
+ * Calculate total with tax
+ */
+export function calculateTotalWithTax(subtotal: number, taxRate: number): number {
+  return subtotal + calculateTax(subtotal, taxRate);
+}

package/src/shared/utils/numberUtils.ts

@@ -0,0 +1,9 @@
+/**
+ * Number Utilities
+ * Re-exports all number utility modules
+ */
+
+export * from "./numberUtils.aggregate";
+export * from "./numberUtils.core";
+export * from "./numberUtils.format";
+export * from "./numberUtils.math";