@billdog.io/react-native 1.0.0-beta.2

package/dist/utils/priceFormatting.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Utilities for formatting prices and subscription periods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPrice = formatPrice;
+exports.formatSubscriptionPeriod = formatSubscriptionPeriod;
+exports.formatIntroPricing = formatIntroPricing;
+exports.getPackageTypeDisplayName = getPackageTypeDisplayName;
+/**
+ * Format a price with currency
+ */
+function formatPrice(price, currency = 'USD', locale = 'en-US') {
+    try {
+        const formatter = new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currency,
+        });
+        return formatter.format(price);
+    }
+    catch (error) {
+        return `${price} ${currency}`;
+    }
+}
+/**
+ * Format a subscription period
+ */
+function formatSubscriptionPeriod(duration, period, locale = 'en-US') {
+    const periodUnit = period.toLowerCase();
+    // Handle singular vs plural
+    if (duration === 1) {
+        switch (periodUnit) {
+            case 'day':
+                return 'daily';
+            case 'week':
+                return 'weekly';
+            case 'month':
+                return 'monthly';
+            case 'year':
+                return 'yearly';
+            default:
+                return `${duration} ${period}`;
+        }
+    }
+    // Plural
+    const pluralPeriod = (() => {
+        switch (periodUnit) {
+            case 'day':
+                return 'days';
+            case 'week':
+                return 'weeks';
+            case 'month':
+                return 'months';
+            case 'year':
+                return 'years';
+            default:
+                return `${period}s`;
+        }
+    })();
+    return `${duration} ${pluralPeriod}`;
+}
+/**
+ * Format intro pricing info
+ */
+function formatIntroPricing(introPrice, introDuration, introPeriod, introCycles, currency = 'USD', locale = 'en-US') {
+    if (!introDuration || !introPeriod) {
+        return null;
+    }
+    const periodText = formatSubscriptionPeriod(introDuration, introPeriod, locale);
+    // Free trial
+    if (introPrice === 0) {
+        return `${periodText} free trial`;
+    }
+    // Intro price
+    if (introPrice != null) {
+        const priceText = formatPrice(introPrice, currency, locale);
+        if (introCycles) {
+            return `${priceText} for ${introCycles} ${periodText}`;
+        }
+        return `${priceText} for ${periodText}`;
+    }
+    return null;
+}
+/**
+ * Helper to get package type display name
+ */
+function getPackageTypeDisplayName(packageType) {
+    const typeMap = {
+        monthly: 'Monthly',
+        annual: 'Annual',
+        six_month: '6 Months',
+        three_month: '3 Months',
+        two_month: '2 Months',
+        weekly: 'Weekly',
+        lifetime: 'Lifetime',
+        custom: 'Custom',
+    };
+    return typeMap[packageType] || packageType;
+}

package/dist/utils/shareSheet.d.ts

@@ -0,0 +1,17 @@
+export interface ShareData {
+    title?: string;
+    message?: string;
+    url?: string;
+}
+export interface ShareResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Share content using native share sheet
+ */
+export declare function share(data: ShareData): Promise<ShareResult>;
+/**
+ * Check if sharing is supported
+ */
+export declare function isShareSupported(): boolean;

package/dist/utils/shareSheet.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.share = share;
+exports.isShareSupported = isShareSupported;
+const react_native_1 = require("react-native");
+/**
+ * Share content using native share sheet
+ */
+async function share(data) {
+    try {
+        const shareOptions = {};
+        if (data.message) {
+            shareOptions.message = data.message;
+        }
+        if (data.url) {
+            shareOptions.url = data.url;
+        }
+        if (data.title) {
+            shareOptions.title = data.title;
+        }
+        const result = await react_native_1.Share.share(shareOptions);
+        if (result.action === react_native_1.Share.sharedAction) {
+            return { success: true };
+        }
+        else if (result.action === react_native_1.Share.dismissedAction) {
+            return { success: false, error: 'Share cancelled' };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Share failed',
+        };
+    }
+}
+/**
+ * Check if sharing is supported
+ */
+function isShareSupported() {
+    return true;
+}

package/dist/utils/subscriptionUpgrade.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Subscription Upgrade/Downgrade Utilities
+ *
+ * Provides methods for managing subscription plan changes
+ * via the upgrade-subscription edge function.
+ *
+ * URLs are resolved through ApiClient → BillDogConfiguration.apiBaseUrl (api.billdog.io).
+ */
+/** Proration behavior options */
+export type ProrationBehavior = 'create_prorations' | 'none' | 'always_invoice';
+/** Billing cycle anchor options */
+export type BillingCycleAnchor = 'now' | 'unchanged';
+/** Options for configuring subscription upgrade/downgrade */
+export interface SubscriptionUpgradeOptions {
+    /** Customer ID (optional if already identified) */
+    customerId?: string;
+    /** App user ID (alternative identifier) */
+    appUserId?: string;
+    /** Specific web purchase ID to upgrade */
+    webPurchaseId?: string;
+    /** How proration should be handled */
+    prorationBehavior?: ProrationBehavior;
+    /** When the new billing cycle should start */
+    billingCycleAnchor?: BillingCycleAnchor;
+}
+/** Preview of subscription change costs */
+export interface ProrationPreview {
+    /** Current subscription price ID */
+    currentPriceId: string;
+    /** New price ID after upgrade/downgrade */
+    newPriceId: string;
+    /** Amount due immediately (in cents) */
+    immediateAmountCents: number;
+    /** Human-readable immediate amount */
+    formattedImmediateAmount: string;
+    /** Prorated credit amount (in cents) */
+    proratedCreditCents: number;
+    /** Prorated charge amount (in cents) */
+    proratedChargeCents: number;
+    /** Next billing date (ISO 8601 string) */
+    nextBillingDate: string | null;
+    /** Currency code */
+    currency: string;
+    /** Whether this is an upgrade or downgrade */
+    isUpgrade: boolean;
+}
+/** Result of a subscription upgrade/downgrade operation */
+export interface SubscriptionUpgradeResult {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Stripe subscription ID */
+    subscriptionId?: string;
+    /** Type of change: "upgrade" or "downgrade" */
+    upgradeType: string;
+    /** Previous price ID */
+    oldPriceId?: string;
+    /** New price ID */
+    newPriceId: string;
+    /** Current period start date (ISO 8601 string) */
+    currentPeriodStart?: string;
+    /** Current period end date (ISO 8601 string) */
+    currentPeriodEnd?: string;
+    /** Applied proration behavior */
+    prorationBehavior: string;
+    /** Error message if failed */
+    errorMessage?: string;
+}
+/**
+ * Preview a subscription upgrade/downgrade before executing.
+ * Shows prorated amounts and billing changes without making changes.
+ *
+ * @param newPriceId - The Stripe price ID to change to
+ * @param options - Upgrade options
+ * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+ */
+export declare function previewSubscriptionUpgrade(apiKey: string | undefined, newPriceId: string, options?: SubscriptionUpgradeOptions): Promise<ProrationPreview>;
+/**
+ * Upgrade a subscription to a higher-tier plan
+ */
+export declare function upgradeSubscription(apiKey: string | undefined, newPriceId: string, options?: SubscriptionUpgradeOptions): Promise<SubscriptionUpgradeResult>;
+/**
+ * Downgrade a subscription to a lower-tier plan
+ */
+export declare function downgradeSubscription(apiKey: string | undefined, newPriceId: string, options?: SubscriptionUpgradeOptions): Promise<SubscriptionUpgradeResult>;

package/dist/utils/subscriptionUpgrade.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Subscription Upgrade/Downgrade Utilities
+ *
+ * Provides methods for managing subscription plan changes
+ * via the upgrade-subscription edge function.
+ *
+ * URLs are resolved through ApiClient → BillDogConfiguration.apiBaseUrl (api.billdog.io).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewSubscriptionUpgrade = previewSubscriptionUpgrade;
+exports.upgradeSubscription = upgradeSubscription;
+exports.downgradeSubscription = downgradeSubscription;
+const ApiClient_1 = require("./ApiClient");
+// MARK: - API Functions
+/**
+ * Preview a subscription upgrade/downgrade before executing.
+ * Shows prorated amounts and billing changes without making changes.
+ *
+ * @param newPriceId - The Stripe price ID to change to
+ * @param options - Upgrade options
+ * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+ */
+async function previewSubscriptionUpgrade(apiKey, newPriceId, options) {
+    var _a, _b, _c;
+    const data = await ApiClient_1.ApiClient.post('upgrade-subscription', {
+        new_price_id: newPriceId,
+        preview: true,
+        customer_id: options === null || options === void 0 ? void 0 : options.customerId,
+        app_user_id: options === null || options === void 0 ? void 0 : options.appUserId,
+        web_purchase_id: options === null || options === void 0 ? void 0 : options.webPurchaseId,
+        proration_behavior: (_a = options === null || options === void 0 ? void 0 : options.prorationBehavior) !== null && _a !== void 0 ? _a : 'create_prorations',
+        billing_cycle_anchor: (_b = options === null || options === void 0 ? void 0 : options.billingCycleAnchor) !== null && _b !== void 0 ? _b : 'unchanged',
+    }, {
+        apiKey: apiKey || undefined,
+    });
+    const preview = data.preview;
+    return {
+        currentPriceId: preview.current_price_id || '',
+        newPriceId: preview.new_price_id || '',
+        immediateAmountCents: preview.immediate_amount_cents || 0,
+        formattedImmediateAmount: preview.formatted_immediate_amount || '$0.00',
+        proratedCreditCents: preview.prorated_credit_cents || 0,
+        proratedChargeCents: preview.prorated_charge_cents || 0,
+        nextBillingDate: preview.next_billing_date || null,
+        currency: preview.currency || 'usd',
+        isUpgrade: (_c = preview.is_upgrade) !== null && _c !== void 0 ? _c : true,
+    };
+}
+/**
+ * Upgrade a subscription to a higher-tier plan
+ */
+async function upgradeSubscription(apiKey, newPriceId, options) {
+    return executeSubscriptionChange(apiKey, newPriceId, options);
+}
+/**
+ * Downgrade a subscription to a lower-tier plan
+ */
+async function downgradeSubscription(apiKey, newPriceId, options) {
+    return executeSubscriptionChange(apiKey, newPriceId, options);
+}
+/**
+ * Internal function to execute subscription change
+ */
+async function executeSubscriptionChange(apiKey, newPriceId, options) {
+    var _a, _b, _c, _d;
+    try {
+        const data = await ApiClient_1.ApiClient.post('upgrade-subscription', {
+            new_price_id: newPriceId,
+            preview: false,
+            customer_id: options === null || options === void 0 ? void 0 : options.customerId,
+            app_user_id: options === null || options === void 0 ? void 0 : options.appUserId,
+            web_purchase_id: options === null || options === void 0 ? void 0 : options.webPurchaseId,
+            proration_behavior: (_a = options === null || options === void 0 ? void 0 : options.prorationBehavior) !== null && _a !== void 0 ? _a : 'create_prorations',
+            billing_cycle_anchor: (_b = options === null || options === void 0 ? void 0 : options.billingCycleAnchor) !== null && _b !== void 0 ? _b : 'unchanged',
+        }, {
+            apiKey: apiKey || undefined,
+        });
+        return {
+            success: (_c = data.success) !== null && _c !== void 0 ? _c : false,
+            subscriptionId: data.subscription_id,
+            upgradeType: data.upgrade_type || 'upgrade',
+            oldPriceId: data.old_price_id,
+            newPriceId: data.new_price_id || newPriceId,
+            currentPeriodStart: data.current_period_start,
+            currentPeriodEnd: data.current_period_end,
+            prorationBehavior: data.proration_behavior || 'create_prorations',
+            errorMessage: data.error,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            upgradeType: 'unknown',
+            newPriceId: newPriceId,
+            prorationBehavior: (_d = options === null || options === void 0 ? void 0 : options.prorationBehavior) !== null && _d !== void 0 ? _d : 'create_prorations',
+            errorMessage: err.message || `Failed to change subscription`,
+        };
+    }
+}

package/dist/valueUtils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ValueUtils — Shared primitive utilities for BillDog React Native SDK
+ *
+ * Canonical source for type coercion, comparison, and nested path walking.
+ * Used by dynamicValues.ts, xFlowTags.ts, and other modules.
+ *
+ * stringify/toNumber implement the canonical xFlow grammar (§5 of
+ * src/schemas/xflow-grammar.md): null/undefined → "", non-numeric → 0.
+ */
+/**
+ * Walk a dot-separated path on a nested object.
+ *
+ * Flat-key-first (grammar §4): a literal key matching the whole path wins
+ * over dotted traversal, so a variable stored under the literal key
+ * "user.name" resolves before descending into `user`.
+ */
+export declare function getNestedValue(obj: any, path: string): any;
+/**
+ * Numeric-first equality for dynamic value conditions, matching native `ValueUtils.isEqual` (iOS +
+ * Android) and the web/renderer copies. Both-null → true; if BOTH operands coerce to a number, compare
+ * numerically (so `10.0` equals `"10"`); otherwise string-compare. The string-only version this replaced
+ * diverged from the device the moment a fractional or typed value was involved.
+ */
+/**
+ * STRUCTURAL equality — the counterpart to `isEqual`, mirroring the split native
+ * `ValueUtils` already makes (`isDeepEqual` vs `valuesEqual` on Android).
+ *
+ * Do NOT confuse the two. `isEqual` coerces (`1` equals `"1"`) because DV CONDITIONS
+ * must; state identity must not, or PaywallStateManager would swallow a genuine
+ * `1` → `"1"` transition that Android/iOS emit. This mirrors Android's
+ * `ValueUtils.isDeepEqual`: numbers compare numerically, arrays/objects compare
+ * structurally, everything else is strict.
+ */
+export declare function isDeepEqual(a: any, b: any): boolean;
+export declare function isEqual(a: any, b: any): boolean;
+/**
+ * Check if a value is truthy (non-null, non-empty, non-zero).
+ */
+export declare function isTruthy(value: any): boolean;
+/** Canonical stringify — null/undefined → "" (grammar §5.1). */
+export declare function stringify(value: any): string;
+/** Canonical numeric coercion — non-numeric → 0, never NaN (grammar §5.2). */
+export declare function toNumber(value: any): number;
+/**
+ * Number-or-null, matching native `toDoubleOrNull`. Used by `isEqual` to decide whether to compare
+ * numerically. Booleans return null so `true` never numeric-equals `1` (they string-compare instead).
+ */
+export declare function toNumberOrNull(value: any): number | null;

package/dist/valueUtils.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * ValueUtils — Shared primitive utilities for BillDog React Native SDK
+ *
+ * Canonical source for type coercion, comparison, and nested path walking.
+ * Used by dynamicValues.ts, xFlowTags.ts, and other modules.
+ *
+ * stringify/toNumber implement the canonical xFlow grammar (§5 of
+ * src/schemas/xflow-grammar.md): null/undefined → "", non-numeric → 0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedValue = getNestedValue;
+exports.isDeepEqual = isDeepEqual;
+exports.isEqual = isEqual;
+exports.isTruthy = isTruthy;
+exports.stringify = stringify;
+exports.toNumber = toNumber;
+exports.toNumberOrNull = toNumberOrNull;
+/**
+ * Walk a dot-separated path on a nested object.
+ *
+ * Flat-key-first (grammar §4): a literal key matching the whole path wins
+ * over dotted traversal, so a variable stored under the literal key
+ * "user.name" resolves before descending into `user`.
+ */
+function getNestedValue(obj, path) {
+    if (obj && typeof obj === 'object' && path in obj)
+        return obj[path];
+    return path.split('.').reduce((current, key) => current === null || current === void 0 ? void 0 : current[key], obj);
+}
+/**
+ * Numeric-first equality for dynamic value conditions, matching native `ValueUtils.isEqual` (iOS +
+ * Android) and the web/renderer copies. Both-null → true; if BOTH operands coerce to a number, compare
+ * numerically (so `10.0` equals `"10"`); otherwise string-compare. The string-only version this replaced
+ * diverged from the device the moment a fractional or typed value was involved.
+ */
+/**
+ * STRUCTURAL equality — the counterpart to `isEqual`, mirroring the split native
+ * `ValueUtils` already makes (`isDeepEqual` vs `valuesEqual` on Android).
+ *
+ * Do NOT confuse the two. `isEqual` coerces (`1` equals `"1"`) because DV CONDITIONS
+ * must; state identity must not, or PaywallStateManager would swallow a genuine
+ * `1` → `"1"` transition that Android/iOS emit. This mirrors Android's
+ * `ValueUtils.isDeepEqual`: numbers compare numerically, arrays/objects compare
+ * structurally, everything else is strict.
+ */
+function isDeepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a === b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => isDeepEqual(v, b[i]));
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (typeof a === 'object' && typeof b === 'object') {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        return ak.length === bk.length && ak.every((k) => isDeepEqual(a[k], b[k]));
+    }
+    return false;
+}
+function isEqual(a, b) {
+    if (a == null && b == null)
+        return true;
+    if (a == null || b == null)
+        return false;
+    const an = toNumberOrNull(a);
+    const bn = toNumberOrNull(b);
+    if (an !== null && bn !== null)
+        return an === bn;
+    return stringify(a) === stringify(b);
+}
+/**
+ * Check if a value is truthy (non-null, non-empty, non-zero).
+ */
+function isTruthy(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (value === false)
+        return false;
+    if (value === '' || value === 0)
+        return false;
+    return true;
+}
+/** Canonical stringify — null/undefined → "" (grammar §5.1). */
+function stringify(value) {
+    var _a;
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number')
+        return String(value);
+    try {
+        return (_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : '';
+    }
+    catch {
+        return String(value);
+    }
+}
+/** Canonical numeric coercion — non-numeric → 0, never NaN (grammar §5.2). */
+function toNumber(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : 0;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : 0;
+    }
+    return 0;
+}
+/**
+ * Number-or-null, matching native `toDoubleOrNull`. Used by `isEqual` to decide whether to compare
+ * numerically. Booleans return null so `true` never numeric-equals `1` (they string-compare instead).
+ */
+function toNumberOrNull(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}

package/dist/xFlowTags.d.ts

@@ -0,0 +1,18 @@
+/**
+ * xFlow Tag Preprocessor — React Native SDK.
+ *
+ * Faithful port of src/lib/filters/xFlowTags.ts (the web reference). Implements
+ * the canonical grammar at src/schemas/xflow-grammar.md. Runs as a first pass
+ * before {{ }} interpolation. The conformance corpus
+ * (tests/parity/xflow-corpus/) is the cross-platform contract — web, iOS,
+ * Android, and React Native parsers must produce identical output.
+ *
+ * Tags: {% assign %} (with filter chains), {% if/elsif/else/endif %},
+ *       {% unless/endunless %}, {% case/when/else/endcase %}.
+ * Conditions: ==, !=, >, <, >=, <=, contains, and, or, unary !, postfix exists.
+ */
+export interface XFlowTagResult {
+    text: string;
+    variables: Record<string, any>;
+}
+export declare function processXFlowTags(text: string, variables: Record<string, any>): XFlowTagResult;