@sudobility/subscription_lib 0.0.1

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core Exports
+ */
+export { SubscriptionService, type SubscriptionServiceConfig } from './service';
+export { initializeSubscription, getSubscriptionInstance, isSubscriptionInitialized, resetSubscription, refreshSubscription, type SubscriptionConfig, } from './singleton';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAEhF,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,5 @@
+/**
+ * Core Exports
+ */
+export { SubscriptionService } from './service';
+export { initializeSubscription, getSubscriptionInstance, isSubscriptionInitialized, resetSubscription, refreshSubscription, } from './singleton';

package/dist/core/service.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Subscription Service
+ *
+ * Core service for managing subscription data with clean abstractions.
+ */
+import type { AdapterPurchaseParams, AdapterPurchaseResult, SubscriptionAdapter } from '../types/adapter';
+import type { CurrentSubscription, FreeTierConfig, SubscriptionOffer, SubscriptionPackage } from '../types/subscription';
+/**
+ * Configuration for SubscriptionService
+ */
+export interface SubscriptionServiceConfig {
+    /** RevenueCat adapter implementation */
+    adapter: SubscriptionAdapter;
+    /** Free tier configuration */
+    freeTier: FreeTierConfig;
+}
+/**
+ * Service for managing subscription data with clean abstractions.
+ */
+export declare class SubscriptionService {
+    private adapter;
+    private freeTier;
+    private offersCache;
+    private currentSubscription;
+    private isLoadingOfferings;
+    private isLoadingCustomerInfo;
+    constructor(config: SubscriptionServiceConfig);
+    /**
+     * Load offerings from RevenueCat
+     */
+    loadOfferings(params?: {
+        currency?: string;
+    }): Promise<void>;
+    /**
+     * Load customer info from RevenueCat
+     */
+    loadCustomerInfo(): Promise<void>;
+    /**
+     * Get offer by ID with complete hierarchy
+     */
+    getOffer(offerId: string): SubscriptionOffer | null;
+    /**
+     * Get all offer IDs
+     */
+    getOfferIds(): string[];
+    /**
+     * Get current subscription info
+     */
+    getCurrentSubscription(): CurrentSubscription | null;
+    /**
+     * Get free tier as a SubscriptionPackage
+     */
+    getFreeTierPackage(): SubscriptionPackage;
+    /**
+     * Get free tier config
+     */
+    getFreeTierConfig(): FreeTierConfig;
+    /**
+     * Make a purchase
+     */
+    purchase(params: AdapterPurchaseParams): Promise<AdapterPurchaseResult>;
+    /**
+     * Check if offerings are loaded
+     */
+    hasLoadedOfferings(): boolean;
+    /**
+     * Check if customer info is loaded
+     */
+    hasLoadedCustomerInfo(): boolean;
+    private parseOffering;
+    private parsePackage;
+    private extractEntitlementsFromMetadata;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/core/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/core/service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAGV,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,uBAAuB,CAAC;AAG/B;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,wCAAwC;IACxC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,8BAA8B;IAC9B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,WAAW,CAA6C;IAChE,OAAO,CAAC,mBAAmB,CAAoC;IAC/D,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,qBAAqB,CAAS;gBAE1B,MAAM,EAAE,yBAAyB;IAS7C;;OAEG;IACG,aAAa,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBlE;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IA6DvC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAInD;;OAEG;IACH,WAAW,IAAI,MAAM,EAAE;IAIvB;;OAEG;IACH,sBAAsB,IAAI,mBAAmB,GAAG,IAAI;IAIpD;;OAEG;IACH,kBAAkB,IAAI,mBAAmB;IASzC;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;OAEG;IACG,QAAQ,CACZ,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IASjC;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,qBAAqB,IAAI,OAAO;IAQhC,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,YAAY;IAgCpB,OAAO,CAAC,+BAA+B;CA6BxC"}

package/dist/core/service.js

@@ -0,0 +1,251 @@
+/**
+ * Subscription Service
+ *
+ * Core service for managing subscription data with clean abstractions.
+ */
+import { parseISO8601Period } from '../utils/period-parser';
+/**
+ * Service for managing subscription data with clean abstractions.
+ */
+export class SubscriptionService {
+    constructor(config) {
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "freeTier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "offersCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "currentSubscription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isLoadingOfferings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isLoadingCustomerInfo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.adapter = config.adapter;
+        this.freeTier = config.freeTier;
+    }
+    // ---------------------------------------------------------------------------
+    // Data Loading
+    // ---------------------------------------------------------------------------
+    /**
+     * Load offerings from RevenueCat
+     */
+    async loadOfferings(params) {
+        if (this.isLoadingOfferings)
+            return;
+        this.isLoadingOfferings = true;
+        try {
+            const offerings = await this.adapter.getOfferings(params);
+            this.offersCache.clear();
+            for (const [offerId, offering] of Object.entries(offerings.all)) {
+                const parsedOffer = this.parseOffering(offerId, offering);
+                this.offersCache.set(offerId, parsedOffer);
+            }
+            // Also add current offering as 'default' if available
+            if (offerings.current && !this.offersCache.has('default')) {
+                const parsedOffer = this.parseOffering('default', offerings.current);
+                this.offersCache.set('default', parsedOffer);
+            }
+        }
+        finally {
+            this.isLoadingOfferings = false;
+        }
+    }
+    /**
+     * Load customer info from RevenueCat
+     */
+    async loadCustomerInfo() {
+        if (this.isLoadingCustomerInfo)
+            return;
+        this.isLoadingCustomerInfo = true;
+        try {
+            // Ensure offerings are loaded first so we can match packageId
+            if (!this.hasLoadedOfferings()) {
+                await this.loadOfferings();
+            }
+            const customerInfo = await this.adapter.getCustomerInfo();
+            const activeEntitlementIds = Object.keys(customerInfo.entitlements.active);
+            if (activeEntitlementIds.length === 0) {
+                this.currentSubscription = {
+                    isActive: false,
+                    entitlements: [],
+                };
+                return;
+            }
+            const firstEntitlement = customerInfo.entitlements.active[activeEntitlementIds[0]];
+            // Find the package for this product
+            let packageId;
+            let period;
+            for (const offer of this.offersCache.values()) {
+                const pkg = offer.packages.find(p => p.product?.productId === firstEntitlement.productIdentifier);
+                if (pkg) {
+                    packageId = pkg.packageId;
+                    period = pkg.product?.period;
+                    break;
+                }
+            }
+            this.currentSubscription = {
+                isActive: true,
+                productId: firstEntitlement.productIdentifier,
+                packageId,
+                entitlements: activeEntitlementIds,
+                period,
+                expirationDate: firstEntitlement.expirationDate
+                    ? new Date(firstEntitlement.expirationDate)
+                    : undefined,
+                willRenew: firstEntitlement.willRenew,
+            };
+        }
+        finally {
+            this.isLoadingCustomerInfo = false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    /**
+     * Get offer by ID with complete hierarchy
+     */
+    getOffer(offerId) {
+        return this.offersCache.get(offerId) ?? null;
+    }
+    /**
+     * Get all offer IDs
+     */
+    getOfferIds() {
+        return Array.from(this.offersCache.keys());
+    }
+    /**
+     * Get current subscription info
+     */
+    getCurrentSubscription() {
+        return this.currentSubscription;
+    }
+    /**
+     * Get free tier as a SubscriptionPackage
+     */
+    getFreeTierPackage() {
+        return {
+            packageId: this.freeTier.packageId,
+            name: this.freeTier.name,
+            product: undefined,
+            entitlements: [],
+        };
+    }
+    /**
+     * Get free tier config
+     */
+    getFreeTierConfig() {
+        return this.freeTier;
+    }
+    /**
+     * Make a purchase
+     */
+    async purchase(params) {
+        const result = await this.adapter.purchase(params);
+        // Reload customer info after purchase
+        await this.loadCustomerInfo();
+        return result;
+    }
+    /**
+     * Check if offerings are loaded
+     */
+    hasLoadedOfferings() {
+        return this.offersCache.size > 0;
+    }
+    /**
+     * Check if customer info is loaded
+     */
+    hasLoadedCustomerInfo() {
+        return this.currentSubscription !== null;
+    }
+    // ---------------------------------------------------------------------------
+    // Private Helpers
+    // ---------------------------------------------------------------------------
+    parseOffering(offerId, offering) {
+        const packages = [];
+        // Extract entitlements from metadata if available
+        const metadataEntitlements = this.extractEntitlementsFromMetadata(offering.metadata);
+        for (const pkg of offering.availablePackages) {
+            packages.push(this.parsePackage(pkg, metadataEntitlements));
+        }
+        return {
+            offerId,
+            metadata: offering.metadata ?? undefined,
+            packages,
+        };
+    }
+    parsePackage(pkg, metadataEntitlements) {
+        const product = pkg.product;
+        const defaultOption = product.subscriptionOptions
+            ? Object.values(product.subscriptionOptions)[0]
+            : undefined;
+        const parsedProduct = {
+            productId: product.identifier,
+            name: product.title,
+            description: product.description ?? undefined,
+            price: product.price,
+            priceString: product.priceString,
+            currency: product.currencyCode,
+            period: parseISO8601Period(product.normalPeriodDuration),
+            periodDuration: product.normalPeriodDuration ?? '',
+            trialPeriod: defaultOption?.trial?.periodDuration ?? undefined,
+            introPrice: defaultOption?.introPrice?.priceString ?? undefined,
+            introPricePeriod: defaultOption?.introPrice?.periodDuration ?? undefined,
+            introPriceCycles: defaultOption?.introPrice?.cycleCount,
+        };
+        return {
+            packageId: pkg.identifier,
+            name: product.title,
+            product: parsedProduct,
+            entitlements: metadataEntitlements,
+        };
+    }
+    extractEntitlementsFromMetadata(metadata) {
+        if (!metadata)
+            return [];
+        const entitlements = [];
+        // Single entitlement in metadata
+        if (metadata.entitlement && typeof metadata.entitlement === 'string') {
+            entitlements.push(metadata.entitlement);
+        }
+        // Array of entitlements in metadata
+        if (Array.isArray(metadata.entitlements)) {
+            for (const ent of metadata.entitlements) {
+                if (typeof ent === 'string') {
+                    entitlements.push(ent);
+                }
+                else if (typeof ent === 'object' &&
+                    ent !== null &&
+                    typeof ent.identifier === 'string') {
+                    entitlements.push(ent.identifier);
+                }
+            }
+        }
+        return entitlements;
+    }
+}

package/dist/core/singleton.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Subscription Singleton
+ *
+ * Global singleton manager for the SubscriptionService.
+ */
+import type { SubscriptionAdapter } from '../types/adapter';
+import type { FreeTierConfig } from '../types/subscription';
+import { SubscriptionService } from './service';
+/**
+ * Configuration for initializing the subscription singleton
+ */
+export interface SubscriptionConfig {
+    /** RevenueCat adapter implementation */
+    adapter: SubscriptionAdapter;
+    /** Free tier configuration */
+    freeTier: FreeTierConfig;
+}
+/**
+ * Initialize the subscription singleton
+ *
+ * Call this once at app startup with your RevenueCat adapter.
+ *
+ * @param config Configuration with adapter and free tier info
+ *
+ * @example
+ * ```typescript
+ * import { initializeSubscription } from '@sudobility/subscription_lib';
+ * import { createWebRevenueCatAdapter } from './adapters/web';
+ *
+ * initializeSubscription({
+ *   adapter: createWebRevenueCatAdapter(purchases),
+ *   freeTier: { packageId: 'free', name: 'Free' }
+ * });
+ * ```
+ */
+export declare function initializeSubscription(config: SubscriptionConfig): void;
+/**
+ * Get the subscription service singleton
+ *
+ * @throws Error if not initialized
+ */
+export declare function getSubscriptionInstance(): SubscriptionService;
+/**
+ * Check if subscription singleton is initialized
+ */
+export declare function isSubscriptionInitialized(): boolean;
+/**
+ * Reset the subscription singleton (mainly for testing)
+ */
+export declare function resetSubscription(): void;
+/**
+ * Refresh subscription data (customer info and offerings)
+ *
+ * Call this after a purchase to ensure subscription state is up to date.
+ *
+ * @example
+ * ```typescript
+ * import { refreshSubscription } from '@sudobility/subscription_lib';
+ *
+ * // After purchase completes
+ * await refreshSubscription();
+ * ```
+ */
+export declare function refreshSubscription(): Promise<void>;
+//# sourceMappingURL=singleton.d.ts.map

package/dist/core/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../src/core/singleton.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,8BAA8B;IAC9B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAKvE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,mBAAmB,CAO7D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAKzD"}

package/dist/core/singleton.js

@@ -0,0 +1,73 @@
+/**
+ * Subscription Singleton
+ *
+ * Global singleton manager for the SubscriptionService.
+ */
+import { SubscriptionService } from './service';
+let instance = null;
+/**
+ * Initialize the subscription singleton
+ *
+ * Call this once at app startup with your RevenueCat adapter.
+ *
+ * @param config Configuration with adapter and free tier info
+ *
+ * @example
+ * ```typescript
+ * import { initializeSubscription } from '@sudobility/subscription_lib';
+ * import { createWebRevenueCatAdapter } from './adapters/web';
+ *
+ * initializeSubscription({
+ *   adapter: createWebRevenueCatAdapter(purchases),
+ *   freeTier: { packageId: 'free', name: 'Free' }
+ * });
+ * ```
+ */
+export function initializeSubscription(config) {
+    instance = new SubscriptionService({
+        adapter: config.adapter,
+        freeTier: config.freeTier,
+    });
+}
+/**
+ * Get the subscription service singleton
+ *
+ * @throws Error if not initialized
+ */
+export function getSubscriptionInstance() {
+    if (!instance) {
+        throw new Error('Subscription not initialized. Call initializeSubscription() first.');
+    }
+    return instance;
+}
+/**
+ * Check if subscription singleton is initialized
+ */
+export function isSubscriptionInitialized() {
+    return instance !== null;
+}
+/**
+ * Reset the subscription singleton (mainly for testing)
+ */
+export function resetSubscription() {
+    instance = null;
+}
+/**
+ * Refresh subscription data (customer info and offerings)
+ *
+ * Call this after a purchase to ensure subscription state is up to date.
+ *
+ * @example
+ * ```typescript
+ * import { refreshSubscription } from '@sudobility/subscription_lib';
+ *
+ * // After purchase completes
+ * await refreshSubscription();
+ * ```
+ */
+export async function refreshSubscription() {
+    if (!instance) {
+        return;
+    }
+    await Promise.all([instance.loadOfferings(), instance.loadCustomerInfo()]);
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook Exports
+ */
+export { useSubscriptions, type UseSubscriptionsResult, } from './useSubscriptions';
+export { useUserSubscription, type UseUserSubscriptionResult, } from './useUserSubscription';
+export { useSubscriptionPeriods, type UseSubscriptionPeriodsResult, } from './useSubscriptionPeriods';
+export { useSubscriptionForPeriod, type UseSubscriptionForPeriodResult, } from './useSubscriptionForPeriod';
+export { useSubscribable, type UseSubscribableResult } from './useSubscribable';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,gBAAgB,EAChB,KAAK,sBAAsB,GAC5B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,mBAAmB,EACnB,KAAK,yBAAyB,GAC/B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,sBAAsB,EACtB,KAAK,4BAA4B,GAClC,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,wBAAwB,EACxB,KAAK,8BAA8B,GACpC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,8 @@
+/**
+ * Hook Exports
+ */
+export { useSubscriptions, } from './useSubscriptions';
+export { useUserSubscription, } from './useUserSubscription';
+export { useSubscriptionPeriods, } from './useSubscriptionPeriods';
+export { useSubscriptionForPeriod, } from './useSubscriptionForPeriod';
+export { useSubscribable } from './useSubscribable';

package/dist/hooks/useSubscribable.d.ts

@@ -0,0 +1,50 @@
+/**
+ * useSubscribable Hook
+ *
+ * Get packages that the user can subscribe to or upgrade to.
+ */
+/**
+ * Result of useSubscribable hook
+ */
+export interface UseSubscribableResult {
+    /** Package IDs that the user can subscribe/upgrade to */
+    subscribablePackageIds: string[];
+    /** Whether data is being loaded */
+    isLoading: boolean;
+    /** Error if loading failed */
+    error: Error | null;
+}
+/**
+ * Hook to get packages that the user can subscribe to or upgrade to
+ *
+ * Upgrade eligibility rules:
+ * - If no current subscription: all packages are subscribable
+ * - If on free tier: all paid packages are subscribable
+ * - If has subscription:
+ *   - Package period must be >= current period (monthly → yearly OK, yearly → monthly NOT OK)
+ *   - Package level must be >= current level (basic → pro OK, pro → basic NOT OK)
+ *   - Level is determined by price comparison within the same period
+ *
+ * @param offerId Offer identifier
+ * @returns List of subscribable package IDs
+ *
+ * @example
+ * ```typescript
+ * const { subscribablePackageIds } = useSubscribable('default');
+ * const { packages } = useSubscriptionForPeriod('default', 'monthly');
+ *
+ * return (
+ *   <div>
+ *     {packages.map(pkg => (
+ *       <SubscriptionTile
+ *         key={pkg.packageId}
+ *         enabled={subscribablePackageIds.includes(pkg.packageId)}
+ *         {...pkg}
+ *       />
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export declare function useSubscribable(offerId: string): UseSubscribableResult;
+//# sourceMappingURL=useSubscribable.d.ts.map

package/dist/hooks/useSubscribable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscribable.d.ts","sourceRoot":"","sources":["../../src/hooks/useSubscribable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,yDAAyD;IACzD,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,mCAAmC;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAsDtE"}

package/dist/hooks/useSubscribable.js

@@ -0,0 +1,80 @@
+/**
+ * useSubscribable Hook
+ *
+ * Get packages that the user can subscribe to or upgrade to.
+ */
+import { useMemo } from 'react';
+import { useSubscriptions } from './useSubscriptions';
+import { useUserSubscription } from './useUserSubscription';
+import { findUpgradeablePackages } from '../utils/level-calculator';
+import { getSubscriptionInstance, isSubscriptionInitialized, } from '../core/singleton';
+/**
+ * Hook to get packages that the user can subscribe to or upgrade to
+ *
+ * Upgrade eligibility rules:
+ * - If no current subscription: all packages are subscribable
+ * - If on free tier: all paid packages are subscribable
+ * - If has subscription:
+ *   - Package period must be >= current period (monthly → yearly OK, yearly → monthly NOT OK)
+ *   - Package level must be >= current level (basic → pro OK, pro → basic NOT OK)
+ *   - Level is determined by price comparison within the same period
+ *
+ * @param offerId Offer identifier
+ * @returns List of subscribable package IDs
+ *
+ * @example
+ * ```typescript
+ * const { subscribablePackageIds } = useSubscribable('default');
+ * const { packages } = useSubscriptionForPeriod('default', 'monthly');
+ *
+ * return (
+ *   <div>
+ *     {packages.map(pkg => (
+ *       <SubscriptionTile
+ *         key={pkg.packageId}
+ *         enabled={subscribablePackageIds.includes(pkg.packageId)}
+ *         {...pkg}
+ *       />
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export function useSubscribable(offerId) {
+    const { offer, isLoading: loadingOffer, error: offerError, } = useSubscriptions(offerId);
+    const { subscription, isLoading: loadingSub, error: subError, } = useUserSubscription();
+    const isLoading = loadingOffer || loadingSub;
+    const error = offerError || subError;
+    const subscribablePackageIds = useMemo(() => {
+        if (!offer) {
+            return [];
+        }
+        // Get all packages including free tier
+        let allPackages = [...offer.packages];
+        // Add free tier if initialized
+        if (isSubscriptionInitialized()) {
+            const service = getSubscriptionInstance();
+            const freeTier = service.getFreeTierPackage();
+            // Only add if not already in the list
+            if (!allPackages.some(p => p.packageId === freeTier.packageId)) {
+                allPackages = [freeTier, ...allPackages];
+            }
+        }
+        // No subscription or inactive = all packages subscribable
+        if (!subscription || !subscription.isActive) {
+            return allPackages.map(p => p.packageId);
+        }
+        // Pass both packageId and productId for matching
+        const current = {
+            packageId: subscription.packageId,
+            productId: subscription.productId,
+        };
+        // If we don't know the current package or product, return all (shouldn't happen)
+        if (!current.packageId && !current.productId) {
+            return allPackages.map(p => p.packageId);
+        }
+        // Calculate upgradeable packages
+        return findUpgradeablePackages(current, allPackages);
+    }, [offer, subscription]);
+    return { subscribablePackageIds, isLoading, error };
+}