@umituz/react-native-subscription 2.37.13 → 2.37.15

package/src/shared/presentation/hooks/useServiceCall.ts

@@ -1,77 +0,0 @@
-/**
- * useServiceCall Hook
- * Shared hook for handling service calls with loading, error, and success states
- */
-
-import { useState, useCallback, useRef, useEffect } from "react";
-import { normalizeError } from "../../utils/errorUtils";
-
-export interface ServiceCallState<T> {
-  data: T | null;
-  isLoading: boolean;
-  error: Error | null;
-}
-
-export interface UseServiceCallOptions<T> {
-  onSuccess?: (data: T) => void;
-  onError?: (error: Error) => void;
-  onComplete?: () => void;
-}
-
-export interface ServiceCallResult<T> {
-  data: T | null;
-  isLoading: boolean;
-  error: Error | null;
-  execute: () => Promise<void>;
-  reset: () => void;
-}
-
-export function useServiceCall<T>(
-  serviceFn: () => Promise<T>,
-  options: UseServiceCallOptions<T> = {}
-): ServiceCallResult<T> {
-  const { onSuccess, onError, onComplete } = options;
-  const [state, setState] = useState<ServiceCallState<T>>({
-    data: null,
-    isLoading: false,
-    error: null,
-  });
-
-  const onSuccessRef = useRef(onSuccess);
-  const onErrorRef = useRef(onError);
-  const onCompleteRef = useRef(onComplete);
-
-  useEffect(() => {
-    onSuccessRef.current = onSuccess;
-    onErrorRef.current = onError;
-    onCompleteRef.current = onComplete;
-  });
-
-  const execute = useCallback(async () => {
-    setState({ data: null, isLoading: true, error: null });
-
-    try {
-      const data = await serviceFn();
-      setState({ data, isLoading: false, error: null });
-      onSuccessRef.current?.(data);
-    } catch (error) {
-      const errorObj = normalizeError(error, "Service call failed");
-      setState({ data: null, isLoading: false, error: errorObj });
-      onErrorRef.current?.(errorObj);
-    } finally {
-      onCompleteRef.current?.();
-    }
-  }, [serviceFn]);
-
-  const reset = useCallback(() => {
-    setState({ data: null, isLoading: false, error: null });
-  }, []);
-
-  return {
-    data: state.data,
-    isLoading: state.isLoading,
-    error: state.error,
-    execute,
-    reset,
-  };
-}

package/src/shared/types/ReactTypes.ts

@@ -1,80 +0,0 @@
-/**
- * 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/InsufficientCreditsError.ts

@@ -1,32 +0,0 @@
-/**
- * InsufficientCreditsError
- *
- * Thrown when user doesn't have enough credits for an operation.
- * Silently handled - triggers paywall display.
- */
-
-export class InsufficientCreditsError extends Error {
-  public readonly requiredCredits: number;
-  public readonly availableCredits: number;
-  public readonly operationType: string;
-
-  constructor(
-    requiredCredits: number,
-    availableCredits: number,
-    operationType: string,
-  ) {
-    super(
-      `Insufficient credits: ${availableCredits} available, ${requiredCredits} required`,
-    );
-    this.name = "InsufficientCreditsError";
-    this.requiredCredits = requiredCredits;
-    this.availableCredits = availableCredits;
-    this.operationType = operationType;
-
-    Object.setPrototypeOf(this, InsufficientCreditsError.prototype);
-  }
-
-  get deficit(): number {
-    return this.requiredCredits - this.availableCredits;
-  }
-}

package/src/shared/utils/Logger.ts

@@ -1,81 +0,0 @@
-/**
- * Subscription Logger
- * Centralized logging utility for the subscription package.
- * All logs are disabled - no logging.
- */
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-export interface LogMetadata {
-  [key: string]: unknown;
-}
-
-/** Log categories for filtering and grouping */
-export const LOG_CATEGORY = {
-  REVENUECAT: "RevenueCat",
-  CREDITS: "Credits",
-  TRIAL: "Trial",
-  PURCHASE: "Purchase",
-  FEATURE_GATE: "FeatureGate",
-  SUBSCRIPTION: "Subscription",
-  SYNC: "Sync",
-} as const;
-
-export type LogCategory = (typeof LOG_CATEGORY)[keyof typeof LOG_CATEGORY];
-
-/**
- * Development-only logger that automatically respects __DEV__ flag.
- * All methods are no-ops - logging is disabled.
- */
-class SubscriptionLogger {
-  /** Enable or disable all logging */
-  setEnabled(_enabled: boolean): void {
-  }
-
-  /** Enable logging for specific categories only */
-  setCategories(_categories: LogCategory[]): void {
-  }
-
-  /** Clear category filter (log all categories) */
-  clearCategories(): void {
-  }
-
-  debug(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
-  }
-
-  info(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
-  }
-
-  warn(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
-  }
-
-  error(_category: LogCategory, _message: string, _error?: unknown, _metadata?: LogMetadata): void {
-  }
-
-  /** Log purchase flow events */
-  purchase(_message: string, _metadata?: LogMetadata): void {
-  }
-
-  /** Log credits-related events */
-  credits(_message: string, _metadata?: LogMetadata): void {
-  }
-
-  /** Log trial-related events */
-  trial(_message: string, _metadata?: LogMetadata): void {
-  }
-
-  /** Log RevenueCat SDK events */
-  revenueCat(_message: string, _metadata?: LogMetadata): void {
-  }
-
-  /** Log feature gate events */
-  featureGate(_message: string, _metadata?: LogMetadata): void {
-  }
-
-  /** Log sync operations */
-  sync(_message: string, _metadata?: LogMetadata): void {
-  }
-}
-
-/** Singleton logger instance */
-export const Logger = new SubscriptionLogger();

package/src/shared/utils/SubscriptionConfig.ts

@@ -1,15 +0,0 @@
-/**
- * Subscription Config Value Object
- */
-
-import { ISubscriptionRepository } from "../application/ports/ISubscriptionRepository";
-import { SubscriptionStatus } from "../../domains/subscription/core/SubscriptionStatus";
-
-export interface SubscriptionConfig {
-    repository: ISubscriptionRepository;
-    revenueCatApiKey?: string;
-    entitlements?: string[];
-    debugMode?: boolean;
-    onStatusChanged?: (userId: string, status: SubscriptionStatus) => Promise<void> | void;
-    onError?: (error: Error, operation: string) => Promise<void> | void;
-}

package/src/shared/utils/SubscriptionError.ts

@@ -1,47 +0,0 @@
-/**
- * Subscription Error
- * Custom error class for subscription-related errors
- */
-
-import { BaseError } from "./BaseError";
-
-export class SubscriptionError extends BaseError {
-    constructor(message: string, code: string = 'SUBSCRIPTION_ERROR', cause?: Error) {
-        super(message, code, cause);
-        this.name = 'SubscriptionError';
-    }
-
-    static notFound(message: string = 'Subscription not found', cause?: Error): SubscriptionError {
-        return new SubscriptionError(message, 'SUBSCRIPTION_NOT_FOUND', cause);
-    }
-
-    static expired(message: string = 'Subscription has expired', cause?: Error): SubscriptionError {
-        return new SubscriptionError(message, 'SUBSCRIPTION_EXPIRED', cause);
-    }
-
-    static purchaseFailed(message: string = 'Purchase failed', cause?: Error): SubscriptionError {
-        return new SubscriptionError(message, 'PURCHASE_FAILED', cause);
-    }
-
-    static restoreFailed(message: string = 'Restore failed', cause?: Error): SubscriptionError {
-        return new SubscriptionError(message, 'RESTORE_FAILED', cause);
-    }
-
-    static networkError(message: string = 'Network error', cause?: Error): SubscriptionError {
-        return new SubscriptionError(message, 'NETWORK_ERROR', cause);
-    }
-}
-
-export class SubscriptionRepositoryError extends BaseError {
-    constructor(message: string, code: string = 'REPOSITORY_ERROR', cause?: Error) {
-        super(message, code, cause);
-        this.name = 'SubscriptionRepositoryError';
-    }
-}
-
-export class SubscriptionValidationError extends BaseError {
-    constructor(message: string, code: string = 'VALIDATION_ERROR', cause?: Error) {
-        super(message, code, cause);
-        this.name = 'SubscriptionValidationError';
-    }
-}

package/src/shared/utils/appValidators.ts

@@ -1,38 +0,0 @@
-import {
-  isNonEmptyString,
-  isValidNumber,
-  isPositiveNumber,
-  isNonNegativeNumber,
-  isInteger,
-} from "./validators";
-
-export function isValidCreditAmount(value: unknown): value is number {
-  return isInteger(value) && isNonNegativeNumber(value);
-}
-
-export function isValidPrice(value: unknown): value is number {
-  if (!isPositiveNumber(value)) return false;
-  const decimalPlaces = (value.toString().split(".")[1] || "").length;
-  return decimalPlaces <= 2;
-}
-
-export function isValidProductId(value: unknown): value is string {
-  return isNonEmptyString(value) && /^[a-zA-Z0-9._-]+$/.test(value);
-}
-
-export function isValidUserId(value: unknown): value is string {
-  return isNonEmptyString(value);
-}
-
-export function sanitizeString(value: unknown): string | null {
-  if (value === null || value === undefined) return null;
-  return String(value).trim().replace(/\s+/g, " ");
-}
-
-export function sanitizeNumber(value: unknown, defaultValue: number = 0): number {
-  return isValidNumber(value) ? value : defaultValue;
-}
-
-export function isOneOf<T>(value: unknown, allowedValues: readonly T[]): value is T {
-  return allowedValues.includes(value as T);
-}

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

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1,118 +0,0 @@
-/**
- * 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

@@ -1,116 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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;
-}