@umituz/react-native-subscription 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Subscription management system for React Native apps - Database-first approach with secure validation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -64,10 +64,27 @@ export type { UseSubscriptionResult } from './presentation/hooks/useSubscription
 // UTILS
 // =============================================================================
 
+// Date utilities
 export {
   isSubscriptionExpired,
   getDaysUntilExpiration,
   formatExpirationDate,
   calculateExpirationDate,
-} from './utils/subscriptionUtils';
+} from './utils/dateUtils';
+
+// Price utilities
+export { formatPrice } from './utils/priceUtils';
+
+// Period utilities
+export { getPeriodText } from './utils/periodUtils';
+
+export {
+  SUBSCRIPTION_PLAN_TYPES,
+  MIN_SUBSCRIPTION_DURATIONS_DAYS,
+  SUBSCRIPTION_PERIOD_DAYS,
+  DATE_CONSTANTS,
+  SUBSCRIPTION_PERIOD_UNITS,
+  PRODUCT_ID_KEYWORDS,
+  type SubscriptionPlanType,
+} from './utils/subscriptionConstants';
 

package/src/utils/{subscriptionUtils.ts → dateUtils.ts}

@@ -1,14 +1,22 @@
 /**
- * Subscription Utilities
- * Helper functions for subscription operations
+ * Date Utilities
+ * Subscription date-related helper functions
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only date-related operations
+ * - DRY: No code duplication
+ * - KISS: Simple, clear implementations
  */
 
 import type { SubscriptionStatus } from '../domain/entities/SubscriptionStatus';
-
-/**
- * Subscription plan types
- */
-type SubscriptionPlan = 'weekly' | 'monthly' | 'yearly' | 'unknown';
+import {
+  SUBSCRIPTION_PLAN_TYPES,
+  MIN_SUBSCRIPTION_DURATIONS_DAYS,
+  SUBSCRIPTION_PERIOD_DAYS,
+  DATE_CONSTANTS,
+  PRODUCT_ID_KEYWORDS,
+  type SubscriptionPlanType,
+} from './subscriptionConstants';
 
 /**
  * Extract subscription plan type from product ID
@@ -17,32 +25,30 @@ type SubscriptionPlan = 'weekly' | 'monthly' | 'yearly' | 'unknown';
  */
 function extractPlanFromProductId(
   productId: string | null | undefined,
-): SubscriptionPlan {
-  if (!productId) return 'unknown';
+): SubscriptionPlanType {
+  if (!productId) return SUBSCRIPTION_PLAN_TYPES.UNKNOWN;
 
   const lower = productId.toLowerCase();
 
-  if (lower.includes('weekly') || lower.includes('week')) {
-    return 'weekly';
+  if (PRODUCT_ID_KEYWORDS.WEEKLY.some((keyword) => lower.includes(keyword))) {
+    return SUBSCRIPTION_PLAN_TYPES.WEEKLY;
   }
-  if (lower.includes('monthly') || lower.includes('month')) {
-    return 'monthly';
+  if (PRODUCT_ID_KEYWORDS.MONTHLY.some((keyword) => lower.includes(keyword))) {
+    return SUBSCRIPTION_PLAN_TYPES.MONTHLY;
   }
-  if (
-    lower.includes('yearly') ||
-    lower.includes('year') ||
-    lower.includes('annual')
-  ) {
-    return 'yearly';
+  if (PRODUCT_ID_KEYWORDS.YEARLY.some((keyword) => lower.includes(keyword))) {
+    return SUBSCRIPTION_PLAN_TYPES.YEARLY;
   }
 
-  return 'unknown';
+  return SUBSCRIPTION_PLAN_TYPES.UNKNOWN;
 }
 
 /**
  * Check if subscription is expired
  */
-export function isSubscriptionExpired(status: SubscriptionStatus | null): boolean {
+export function isSubscriptionExpired(
+  status: SubscriptionStatus | null,
+): boolean {
   if (!status || !status.isPremium) {
     return true;
   }
@@ -72,7 +78,9 @@ export function getDaysUntilExpiration(
   const expirationDate = new Date(status.expiresAt);
   const now = new Date();
   const diffMs = expirationDate.getTime() - now.getTime();
-  const diffDays = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+  const diffDays = Math.ceil(
+    diffMs / DATE_CONSTANTS.MILLISECONDS_PER_DAY,
+  );
 
   return diffDays > 0 ? diffDays : 0;
 }
@@ -82,7 +90,7 @@ export function getDaysUntilExpiration(
  */
 export function formatExpirationDate(
   expiresAt: string | null,
-  locale: string = 'en-US',
+  locale: string = DATE_CONSTANTS.DEFAULT_LOCALE,
 ): string | null {
   if (!expiresAt) {
     return null;
@@ -102,23 +110,23 @@ export function formatExpirationDate(
 
 /**
  * Calculate expiration date based on subscription plan
- * 
+ *
  * This function handles:
  * - RevenueCat sandbox accelerated timers (detects and recalculates)
  * - Production dates (trusts RevenueCat's date if valid)
  * - Monthly subscriptions: Same day next month (e.g., Nov 10 → Dec 10)
  * - Yearly subscriptions: Same day next year (e.g., Nov 10, 2024 → Nov 10, 2025)
  * - Weekly subscriptions: +7 days
- * 
+ *
  * @param productId - Product identifier (e.g., "com.umituz.app.monthly")
  * @param revenueCatExpiresAt - Optional expiration date from RevenueCat API
  * @returns ISO date string for expiration, or null if invalid
- * 
+ *
  * @example
  * // Monthly subscription purchased on Nov 10, 2024
  * calculateExpirationDate('com.umituz.app.monthly', null)
  * // Returns: '2024-12-10T...' (Dec 10, 2024)
- * 
+ *
  * @example
  * // Yearly subscription purchased on Nov 10, 2024
  * calculateExpirationDate('com.umituz.app.yearly', null)
@@ -140,17 +148,22 @@ export function calculateExpirationDate(
       if (rcDate > now) {
         // Detect sandbox accelerated timers by checking duration
         const durationMs = rcDate.getTime() - now.getTime();
-        const durationDays = durationMs / (1000 * 60 * 60 * 24);
-
-        // Minimum expected durations (with 1 day tolerance for clock skew)
-        const minDurations: Record<SubscriptionPlan, number> = {
-          weekly: 6,
-          monthly: 28,
-          yearly: 360,
-          unknown: 28,
+        const durationDays =
+          durationMs / DATE_CONSTANTS.MILLISECONDS_PER_DAY;
+
+        // Get minimum expected duration for this plan type
+        const minDurationMap: Record<SubscriptionPlanType, number> = {
+          [SUBSCRIPTION_PLAN_TYPES.WEEKLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.WEEKLY,
+          [SUBSCRIPTION_PLAN_TYPES.MONTHLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.MONTHLY,
+          [SUBSCRIPTION_PLAN_TYPES.YEARLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.YEARLY,
+          [SUBSCRIPTION_PLAN_TYPES.UNKNOWN]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.UNKNOWN,
         };
 
-        const minDuration = minDurations[plan];
+        const minDuration = minDurationMap[plan];
 
         // If duration is reasonable, trust RevenueCat's date (production)
         if (durationDays >= minDuration) {
@@ -168,18 +181,20 @@ export function calculateExpirationDate(
   const calculatedDate = new Date(now);
 
   switch (plan) {
-    case 'weekly':
+    case SUBSCRIPTION_PLAN_TYPES.WEEKLY:
       // Weekly: +7 days
-      calculatedDate.setDate(calculatedDate.getDate() + 7);
+      calculatedDate.setDate(
+        calculatedDate.getDate() + SUBSCRIPTION_PERIOD_DAYS.WEEKLY,
+      );
       break;
 
-    case 'monthly':
+    case SUBSCRIPTION_PLAN_TYPES.MONTHLY:
       // Monthly: Same day next month
       // This handles edge cases like Jan 31 → Feb 28/29 correctly
       calculatedDate.setMonth(calculatedDate.getMonth() + 1);
       break;
 
-    case 'yearly':
+    case SUBSCRIPTION_PLAN_TYPES.YEARLY:
       // Yearly: Same day next year
       // This handles leap years correctly (Feb 29 → Feb 28/29)
       calculatedDate.setFullYear(calculatedDate.getFullYear() + 1);

package/src/utils/periodUtils.ts

@@ -0,0 +1,98 @@
+/**
+ * Period Utilities
+ * Subscription period-related helper functions
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only period-related operations
+ * - DRY: No code duplication
+ * - KISS: Simple, clear implementations
+ */
+
+import { SUBSCRIPTION_PERIOD_UNITS } from './subscriptionConstants';
+
+/**
+ * Get subscription period text from RevenueCat package
+ * Extracts readable period text from PurchasesPackage or subscription period object
+ *
+ * @param input - RevenueCat PurchasesPackage or subscription period object
+ * @returns Human-readable period text (e.g., "month", "year", "2 months")
+ *
+ * @example
+ * // From PurchasesPackage
+ * getPeriodText(pkg) // Returns: "month"
+ *
+ * @example
+ * // From subscription period object
+ * getPeriodText({ unit: "MONTH", numberOfUnits: 1 }) // Returns: "month"
+ * getPeriodText({ unit: "YEAR", numberOfUnits: 1 }) // Returns: "year"
+ * getPeriodText({ unit: "MONTH", numberOfUnits: 3 }) // Returns: "3 months"
+ */
+export function getPeriodText(
+  input:
+    | {
+        product?: {
+          subscriptionPeriod?: {
+            unit: string;
+            numberOfUnits: number;
+          } | null;
+        };
+      }
+    | {
+        unit: string;
+        numberOfUnits: number;
+      }
+    | null
+    | undefined,
+): string {
+  if (!input) return '';
+
+  // Extract subscription period from PurchasesPackage or use directly
+  let subscriptionPeriod:
+    | {
+        unit: string;
+        numberOfUnits: number;
+      }
+    | null
+    | undefined;
+
+  // Check if input is PurchasesPackage (has product property)
+  if ('product' in input && input.product?.subscriptionPeriod) {
+    const period = input.product.subscriptionPeriod;
+    // Type guard: check if period is an object with unit and numberOfUnits
+    if (
+      typeof period === 'object' &&
+      'unit' in period &&
+      'numberOfUnits' in period
+    ) {
+      subscriptionPeriod = {
+        unit: period.unit as string,
+        numberOfUnits: period.numberOfUnits as number,
+      };
+    }
+  } else if ('unit' in input && 'numberOfUnits' in input) {
+    // Input is already a subscription period object
+    subscriptionPeriod = {
+      unit: input.unit,
+      numberOfUnits: input.numberOfUnits,
+    };
+  }
+
+  if (!subscriptionPeriod) return '';
+
+  const { unit, numberOfUnits } = subscriptionPeriod;
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.MONTH) {
+    return numberOfUnits === 1 ? 'month' : `${numberOfUnits} months`;
+  }
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.YEAR) {
+    return numberOfUnits === 1 ? 'year' : `${numberOfUnits} years`;
+  }
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.WEEK) {
+    return numberOfUnits === 1 ? 'week' : `${numberOfUnits} weeks`;
+  }
+
+  return '';
+}
+

package/src/utils/priceUtils.ts

@@ -0,0 +1,31 @@
+/**
+ * Price Utilities
+ * Subscription price-related helper functions
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only price-related operations
+ * - DRY: No code duplication
+ * - KISS: Simple, clear implementations
+ */
+
+import { DATE_CONSTANTS } from './subscriptionConstants';
+
+/**
+ * Format price for display
+ * Formats a price value with currency code using Intl.NumberFormat
+ *
+ * @param price - Price value (e.g., 9.99)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR", "TRY")
+ * @returns Formatted price string (e.g., "$9.99", "€9.99", "₺9.99")
+ *
+ * @example
+ * formatPrice(9.99, "USD") // Returns: "$9.99"
+ * formatPrice(229.99, "TRY") // Returns: "₺229.99"
+ */
+export function formatPrice(price: number, currencyCode: string): string {
+  return new Intl.NumberFormat(DATE_CONSTANTS.DEFAULT_LOCALE, {
+    style: 'currency',
+    currency: currencyCode,
+  }).format(price);
+}
+

package/src/utils/subscriptionConstants.ts

@@ -0,0 +1,70 @@
+/**
+ * Subscription Constants
+ * Centralized constants for subscription operations
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only constants, no logic
+ * - DRY: All constants in one place
+ * - KISS: Simple, clear constant definitions
+ */
+
+/**
+ * Subscription plan types
+ */
+export const SUBSCRIPTION_PLAN_TYPES = {
+  WEEKLY: 'weekly',
+  MONTHLY: 'monthly',
+  YEARLY: 'yearly',
+  UNKNOWN: 'unknown',
+} as const;
+
+export type SubscriptionPlanType =
+  (typeof SUBSCRIPTION_PLAN_TYPES)[keyof typeof SUBSCRIPTION_PLAN_TYPES];
+
+/**
+ * Minimum expected subscription durations in days
+ * Used to detect sandbox accelerated timers
+ * Includes 1 day tolerance for clock skew
+ */
+export const MIN_SUBSCRIPTION_DURATIONS_DAYS = {
+  WEEKLY: 6,
+  MONTHLY: 28,
+  YEARLY: 360,
+  UNKNOWN: 28,
+} as const;
+
+/**
+ * Subscription period multipliers
+ * Days to add for each subscription type
+ */
+export const SUBSCRIPTION_PERIOD_DAYS = {
+  WEEKLY: 7,
+} as const;
+
+/**
+ * Date calculation constants
+ */
+export const DATE_CONSTANTS = {
+  MILLISECONDS_PER_DAY: 1000 * 60 * 60 * 24,
+  DEFAULT_LOCALE: 'en-US',
+} as const;
+
+/**
+ * Subscription period unit mappings
+ * Maps RevenueCat period units to our internal types
+ */
+export const SUBSCRIPTION_PERIOD_UNITS = {
+  WEEK: 'WEEK',
+  MONTH: 'MONTH',
+  YEAR: 'YEAR',
+} as const;
+
+/**
+ * Product ID keywords for plan detection
+ */
+export const PRODUCT_ID_KEYWORDS = {
+  WEEKLY: ['weekly', 'week'],
+  MONTHLY: ['monthly', 'month'],
+  YEARLY: ['yearly', 'year', 'annual'],
+} as const;
+