@umituz/react-native-subscription 2.27.115 → 2.27.116

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";

package/src/shared/utils/stringUtils.case.ts

@@ -0,0 +1,64 @@
+/**
+ * String Utilities - Case Conversion
+ * String case transformation functions
+ */
+
+/**
+ * Capitalize first letter of a string
+ */
+export function capitalize(str: string): string {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+/**
+ * Capitalize first letter of each word
+ */
+export function titleCase(str: string): string {
+  if (!str) return "";
+  return str
+    .toLowerCase()
+    .split(" ")
+    .map((word) => capitalize(word))
+    .join(" ");
+}
+
+/**
+ * Convert string to kebab-case
+ */
+export function kebabCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+}
+
+/**
+ * Convert string to snake_case
+ */
+export function snakeCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/[\s-]+/g, "_")
+    .toLowerCase();
+}
+
+/**
+ * Convert string to camelCase
+ */
+export function camelCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ""))
+    .replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+
+/**
+ * Convert string to PascalCase
+ */
+export function pascalCase(str: string): string {
+  if (!str) return "";
+  return capitalize(camelCase(str));
+}

package/src/shared/utils/stringUtils.check.ts

@@ -0,0 +1,65 @@
+/**
+ * String Utilities - Check Operations
+ * String validation and comparison functions
+ */
+
+/**
+ * Check if value is a non-empty string
+ */
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+/**
+ * Check if string contains a substring (case insensitive)
+ */
+export function containsIgnoreCase(str: string, search: string): boolean {
+  return str.toLowerCase().includes(search.toLowerCase());
+}
+
+/**
+ * Check if string starts with a prefix (case insensitive)
+ */
+export function startsWithIgnoreCase(str: string, prefix: string): boolean {
+  return str.toLowerCase().startsWith(prefix.toLowerCase());
+}
+
+/**
+ * Check if string ends with a suffix (case insensitive)
+ */
+export function endsWithIgnoreCase(str: string, suffix: string): boolean {
+  return str.toLowerCase().endsWith(suffix.toLowerCase());
+}
+
+/**
+ * Check if a string is a valid email (basic validation)
+ */
+export function isValidEmailString(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+
+/**
+ * Check if value is a valid URL (basic validation)
+ */
+export function isValidUrlString(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  try {
+    new URL(value as string);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a string is a valid product identifier
+ */
+export function isValidProductIdString(value: unknown): value is string {
+  return isNonEmptyString(value) && /^[a-zA-Z0-9._-]+$/.test(value as string);
+}