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

package/dist/filters/index.js

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Filter Registry and Chain Processor — React Native SDK.
+ *
+ * Verbatim mirror of src/lib/filters/index.ts (pure TypeScript, no web
+ * dependencies). Handles xFlow filter syntax: {{ variable | filter: arg }}
+ * and {% assign x = value | filter %}. Kept in lockstep with the web file;
+ * the shared conformance corpus enforces parity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE_FILTERS = exports.ALL_FILTERS = void 0;
+exports.applyFilterChain = applyFilterChain;
+exports.replaceVariablesWithFilters = replaceVariablesWithFilters;
+const dateFilters_1 = require("./dateFilters");
+// ============= String Filters =============
+const STRING_FILTERS = {
+    upcase: (value) => String(value).toUpperCase(),
+    downcase: (value) => String(value).toLowerCase(),
+    capitalize: (value) => {
+        const str = String(value);
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    },
+    titlecase: (value) => String(value).replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase()),
+    strip: (value) => String(value).trim(),
+    lstrip: (value) => String(value).trimStart(),
+    rstrip: (value) => String(value).trimEnd(),
+    truncate: (value, length = 50, ellipsis = '...') => {
+        const str = String(value);
+        if (str.length <= length)
+            return str;
+        return str.slice(0, length - ellipsis.length) + ellipsis;
+    },
+    truncatewords: (value, words = 15, ellipsis = '...') => {
+        const wordArray = String(value).split(/\s+/);
+        if (wordArray.length <= words)
+            return value;
+        return wordArray.slice(0, words).join(' ') + ellipsis;
+    },
+    append: (value, suffix) => String(value) + suffix,
+    prepend: (value, prefix) => prefix + String(value),
+    replace: (value, search, replacement = '') => String(value).replace(new RegExp(search, 'g'), replacement),
+    replace_first: (value, search, replacement = '') => String(value).replace(search, replacement),
+    remove: (value, toRemove) => String(value).replace(new RegExp(toRemove, 'g'), ''),
+    remove_first: (value, toRemove) => String(value).replace(toRemove, ''),
+    size: (value) => (Array.isArray(value) ? value.length : String(value).length),
+    escape: (value) => String(value)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;'),
+    url_encode: (value) => encodeURIComponent(String(value)),
+    url_decode: (value) => decodeURIComponent(String(value)),
+};
+// ============= Number Filters =============
+const NUMBER_FILTERS = {
+    plus: (value, addend) => Number(value) + Number(addend),
+    minus: (value, subtrahend) => Number(value) - Number(subtrahend),
+    times: (value, multiplier) => Number(value) * Number(multiplier),
+    divided_by: (value, divisor) => Number(value) / Number(divisor),
+    modulo: (value, divisor) => Number(value) % Number(divisor),
+    round: (value, decimals = 0) => {
+        const factor = Math.pow(10, decimals);
+        return Math.round(Number(value) * factor) / factor;
+    },
+    floor: (value) => Math.floor(Number(value)),
+    ceil: (value) => Math.ceil(Number(value)),
+    abs: (value) => Math.abs(Number(value)),
+    number_with_delimiter: (value, delimiter = ',') => Number(value).toLocaleString('en-US').replace(/,/g, delimiter),
+    currency: (value, symbol = '$', decimals = 2) => `${symbol}${Number(value).toFixed(decimals)}`,
+    percentage: (value, decimals = 0) => `${(Number(value) * 100).toFixed(decimals)}%`,
+    at_least: (value, min) => Math.max(Number(value), Number(min)),
+    at_most: (value, max) => Math.min(Number(value), Number(max)),
+};
+// ============= Array Filters =============
+const ARRAY_FILTERS = {
+    first: (value) => (Array.isArray(value) ? value[0] : value),
+    last: (value) => (Array.isArray(value) ? value[value.length - 1] : value),
+    join: (value, separator = ', ') => Array.isArray(value) ? value.join(separator) : String(value),
+    reverse: (value) => (Array.isArray(value) ? [...value].reverse() : value),
+    sort: (value) => (Array.isArray(value) ? [...value].sort() : value),
+    uniq: (value) => (Array.isArray(value) ? [...new Set(value)] : value),
+    compact: (value) => (Array.isArray(value) ? value.filter((v) => v != null) : value),
+};
+// ============= Default/Fallback Filters =============
+const UTILITY_FILTERS = {
+    default: (value, defaultValue) => value == null || value === '' || value === false ? defaultValue : value,
+    default_if_none: (value, defaultValue) => (value == null ? defaultValue : value),
+};
+// ============= All Filters Combined =============
+exports.ALL_FILTERS = {
+    ...STRING_FILTERS,
+    ...NUMBER_FILTERS,
+    ...ARRAY_FILTERS,
+    ...UTILITY_FILTERS,
+    date: (value, format, locale) => (0, dateFilters_1.formatDate)(value, format, locale),
+    date_add: (value, amount, unit) => (0, dateFilters_1.dateAdd)(value, amount, unit),
+    date_subtract: (value, amount, unit) => (0, dateFilters_1.dateSubtract)(value, amount, unit),
+    countdown_from: (endDate, startDate, format, maxUnit) => (0, dateFilters_1.countdownFrom)(endDate, startDate, format, maxUnit),
+    countdown_days_total: (start, end) => (0, dateFilters_1.countdownDaysTotal)(start, end),
+    countdown_hours_total: (start, end) => (0, dateFilters_1.countdownHoursTotal)(start, end),
+    countdown_minutes_total: (start, end) => (0, dateFilters_1.countdownMinutesTotal)(start, end),
+    countdown_seconds_total: (start, end) => (0, dateFilters_1.countdownSecondsTotal)(start, end),
+    to_ordinal: (value) => (0, dateFilters_1.toOrdinal)(value),
+    to_month_name: (value, format, locale) => (0, dateFilters_1.toMonthName)(value, format, locale),
+    to_day_name: (value, format, locale) => (0, dateFilters_1.toDayName)(value, format, locale),
+    relative_time: (value, locale) => (0, dateFilters_1.relativeTime)(value, locale),
+};
+// ============= Filter Argument Parser =============
+function parseFilterArgs(argsString) {
+    if (!(argsString === null || argsString === void 0 ? void 0 : argsString.trim()))
+        return [];
+    const args = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+    let depth = 0;
+    for (let i = 0; i < argsString.length; i++) {
+        const char = argsString[i];
+        if ((char === '"' || char === "'") && argsString[i - 1] !== '\\') {
+            if (!inQuote) {
+                inQuote = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar) {
+                inQuote = false;
+            }
+            current += char;
+        }
+        else if (char === '[' || char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === ']' || char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && !inQuote && depth === 0) {
+            args.push(parseArgValue(current.trim()));
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim())
+        args.push(parseArgValue(current.trim()));
+    return args;
+}
+function parseArgValue(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null' || value === 'nil')
+        return null;
+    const num = Number(value);
+    if (!isNaN(num) && value !== '')
+        return num;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseFilterChain(filterChain) {
+    const filters = [];
+    const parts = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < filterChain.length; i++) {
+        const char = filterChain[i];
+        if ((char === '"' || char === "'") && filterChain[i - 1] !== '\\') {
+            if (!inQuote) {
+                inQuote = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar) {
+                inQuote = false;
+            }
+            current += char;
+        }
+        else if (char === '|' && !inQuote) {
+            if (current.trim())
+                parts.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    for (const part of parts) {
+        const colonIndex = part.indexOf(':');
+        if (colonIndex === -1) {
+            filters.push({ name: part.trim(), args: [] });
+        }
+        else {
+            const name = part.slice(0, colonIndex).trim();
+            const argsString = part.slice(colonIndex + 1).trim();
+            filters.push({ name, args: parseFilterArgs(argsString) });
+        }
+    }
+    return filters;
+}
+function applyFilterChain(value, filterChain) {
+    const filters = parseFilterChain(filterChain);
+    let result = value;
+    for (const filter of filters) {
+        const filterFn = exports.ALL_FILTERS[filter.name];
+        if (filterFn) {
+            try {
+                result = filterFn(result, ...filter.args);
+            }
+            catch (error) {
+                console.warn(`Filter "${filter.name}" failed:`, error);
+            }
+        }
+        else {
+            console.warn(`Unknown filter: "${filter.name}"`);
+        }
+    }
+    return result;
+}
+/**
+ * Replace {{ variable }} and {{ variable | filter: arg }} occurrences in text.
+ * Mirror of the web replaceVariablesWithFilters — unresolved variables are
+ * left untouched.
+ */
+function replaceVariablesWithFilters(text, variables) {
+    if (!text)
+        return text;
+    return text.replace(/\{\{\s*([\w.]+)(?:\s*\|\s*(.+?))?\s*\}\}/g, (match, varPath, filterChain) => {
+        let value = varPath
+            .split('.')
+            .reduce((obj, key) => obj === null || obj === void 0 ? void 0 : obj[key], variables);
+        if (value === undefined)
+            return match;
+        if (filterChain) {
+            value = applyFilterChain(value, filterChain);
+        }
+        return value !== undefined ? String(value) : match;
+    });
+}
+var dateFilters_2 = require("./dateFilters");
+Object.defineProperty(exports, "DATE_FILTERS", { enumerable: true, get: function () { return dateFilters_2.DATE_FILTERS; } });

package/dist/hooks/useOfferings.d.ts

@@ -0,0 +1,76 @@
+/**
+ * useOfferings Hook - Fetches offerings list with filtering and pagination
+ */
+interface Package {
+    id: string;
+    package_identifier: string;
+    position: number;
+    metadata?: Record<string, any>;
+    product_id?: string;
+    product?: {
+        id: string;
+        product_identifier: string;
+        display_name: string;
+        description?: string;
+        type: string;
+        platform: string;
+        price_usd?: number;
+        currency?: string;
+    };
+}
+interface PaywallOffering {
+    is_primary: boolean;
+    paywall: {
+        id: string;
+        identifier: string;
+        name: string;
+        configuration: any;
+        version: number;
+    };
+}
+interface Offering {
+    id: string;
+    identifier: string;
+    display_name: string;
+    description?: string;
+    notes?: string;
+    is_current: boolean;
+    is_default: boolean;
+    metadata?: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    offering_packages?: Package[];
+    paywall_offerings?: PaywallOffering[];
+}
+export interface UseOfferingsOptions {
+    /** @deprecated Use BillDogConfiguration.configure({ apiKey }) instead */
+    apiKey?: string;
+    skipFetch?: boolean;
+    limit?: number;
+    offset?: number;
+    is_current?: boolean;
+    is_default?: boolean;
+    identifier?: string;
+    expand?: 'packages' | 'products' | 'paywall' | string;
+    sort_by?: 'created_at' | 'display_name' | 'identifier';
+    sort_order?: 'asc' | 'desc';
+}
+interface Pagination {
+    total: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+}
+export interface UseOfferingsResult {
+    offerings: Offering[];
+    currentOffering: Offering | null;
+    allOfferings: Record<string, Offering> | null;
+    pagination: Pagination | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    fetchCurrentOffering: () => Promise<Offering | null>;
+    fetchOfferingForPlacement: (placementIdentifier: string, userContext?: Record<string, any>) => Promise<any>;
+}
+export declare const useOfferings: ({ apiKey: apiKeyOverride, skipFetch, limit, offset, is_current, is_default, identifier, expand, sort_by, sort_order, }: UseOfferingsOptions) => UseOfferingsResult;
+export {};

package/dist/hooks/useOfferings.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * useOfferings Hook - Fetches offerings list with filtering and pagination
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOfferings = void 0;
+const react_1 = require("react");
+const ApiClient_1 = require("../utils/ApiClient");
+const useOfferings = ({ apiKey: apiKeyOverride, skipFetch = false, limit = 20, offset = 0, is_current, is_default, identifier, expand, sort_by = 'created_at', sort_order = 'desc', }) => {
+    const [offerings, setOfferings] = (0, react_1.useState)([]);
+    const [currentOffering, setCurrentOffering] = (0, react_1.useState)(null);
+    const [allOfferings, setAllOfferings] = (0, react_1.useState)(null);
+    const [pagination, setPagination] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const resolvedApiKey = ApiClient_1.ApiClient.resolveApiKey(apiKeyOverride);
+    const deprecatedOptions = { apiKey: apiKeyOverride };
+    const fetchOfferings = async () => {
+        if (skipFetch || !resolvedApiKey) {
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const body = {
+                limit,
+                offset,
+                sort_by,
+                sort_order,
+            };
+            if (is_current !== undefined)
+                body.is_current = is_current;
+            if (is_default !== undefined)
+                body.is_default = is_default;
+            if (identifier)
+                body.identifier = identifier;
+            if (expand)
+                body.expand = expand;
+            const json = await ApiClient_1.ApiClient.post('list-offerings', body, deprecatedOptions);
+            // Phase M4: Extract from wrapped envelope { success, data, meta }
+            const data = json.data;
+            setOfferings(data.offerings || []);
+            setCurrentOffering(data.current_offering || null);
+            setAllOfferings(data.all_offerings || null);
+            setPagination(data.pagination || null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    (0, react_1.useEffect)(() => {
+        fetchOfferings();
+    }, [resolvedApiKey, skipFetch, limit, offset, is_current, is_default, identifier, expand, sort_by, sort_order]);
+    const fetchCurrentOffering = (0, react_1.useCallback)(async () => {
+        if (!resolvedApiKey)
+            return null;
+        try {
+            const json = await ApiClient_1.ApiClient.post('fetch-offering', {
+                is_current: true,
+            }, deprecatedOptions);
+            const data = json.data;
+            return data.current_offering || null;
+        }
+        catch (err) {
+            console.error('Error fetching current offering:', err);
+            return null;
+        }
+    }, [resolvedApiKey, apiKeyOverride]);
+    const fetchOfferingForPlacement = (0, react_1.useCallback)(async (placementIdentifier, userContext) => {
+        if (!resolvedApiKey)
+            return null;
+        try {
+            const json = await ApiClient_1.ApiClient.post('fetch-offerings-for-placement', {
+                placement_identifier: placementIdentifier,
+                ...userContext,
+            }, deprecatedOptions);
+            return json.data;
+        }
+        catch (err) {
+            console.error('Error fetching offering for placement:', err);
+            return null;
+        }
+    }, [resolvedApiKey, apiKeyOverride]);
+    return {
+        offerings,
+        currentOffering,
+        allOfferings,
+        pagination,
+        loading,
+        error,
+        refetch: fetchOfferings,
+        fetchCurrentOffering,
+        fetchOfferingForPlacement,
+    };
+};
+exports.useOfferings = useOfferings;

package/dist/hooks/usePaywall.d.ts

@@ -0,0 +1,27 @@
+/**
+ * usePaywall Hook - Fetches paywall configuration from API
+ */
+import { PaywallConfiguration } from '../types';
+import { AdvancedCacheConfig } from '../AdvancedPaywallCache';
+export interface UsePaywallOptions {
+    paywallIdentifier?: string;
+    /** @deprecated Use BillDogConfiguration.configure({ apiKey }) instead */
+    apiKey?: string;
+    skipFetch?: boolean;
+    cacheConfig?: Partial<AdvancedCacheConfig>;
+    userContext?: {
+        app_user_id?: string;
+        country?: string;
+        app_version?: string;
+        platform?: string;
+        sdk_version?: string;
+        custom_attributes?: Record<string, string>;
+    };
+}
+export interface UsePaywallResult {
+    configuration: PaywallConfiguration | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare const usePaywall: ({ paywallIdentifier, apiKey: apiKeyOverride, skipFetch, cacheConfig, userContext, }: UsePaywallOptions) => UsePaywallResult;

package/dist/hooks/usePaywall.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * usePaywall Hook - Fetches paywall configuration from API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePaywall = void 0;
+const react_1 = require("react");
+const AdvancedPaywallCache_1 = require("../AdvancedPaywallCache");
+const deviceDetection_1 = require("../utils/deviceDetection");
+const configurationResolver_1 = require("../utils/configurationResolver");
+const ApiClient_1 = require("../utils/ApiClient");
+const usePaywall = ({ paywallIdentifier, apiKey: apiKeyOverride, skipFetch = false, cacheConfig, userContext, }) => {
+    const [configuration, setConfiguration] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [cache] = (0, react_1.useState)(() => (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.enabled) !== false ? new AdvancedPaywallCache_1.AdvancedPaywallCache(cacheConfig || {}) : null);
+    const resolvedApiKey = ApiClient_1.ApiClient.resolveApiKey(apiKeyOverride);
+    const fetchPaywall = async () => {
+        if (skipFetch || !paywallIdentifier || !resolvedApiKey) {
+            return;
+        }
+        // Try cache first if enabled
+        if (cache) {
+            const cached = await cache.get(paywallIdentifier);
+            if (cached && Date.now() < cached.expiresAt) {
+                console.log(`[usePaywall] Cache HIT for ${paywallIdentifier}`);
+                setConfiguration(cached.paywall.configuration);
+                setLoading(false);
+                // Check for updates in background
+                checkAndUpdateInBackground(paywallIdentifier, cached.version);
+                return;
+            }
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const json = await ApiClient_1.ApiClient.post('fetch-paywall', {
+                paywall_identifier: paywallIdentifier,
+                ...userContext,
+            }, {
+                apiKey: apiKeyOverride,
+            });
+            // Phase M4: Extract from wrapped envelope { success, data, meta }
+            const data = json.data;
+            if (data.paywall) {
+                // Detect device category
+                const deviceCategory = (0, deviceDetection_1.detectDeviceCategory)();
+                // Check if we have multi-config or single config
+                let resolvedConfig = null;
+                if (data.paywall.configurations) {
+                    // Multi-config mode
+                    const multiConfig = {
+                        mode: data.paywall.configuration_mode || 'single',
+                        ...data.paywall.configurations,
+                    };
+                    resolvedConfig = (0, configurationResolver_1.resolveConfiguration)(multiConfig, deviceCategory);
+                }
+                else if (data.paywall.configuration) {
+                    // Single config mode (legacy)
+                    resolvedConfig = data.paywall.configuration;
+                }
+                if (!resolvedConfig) {
+                    throw new Error('No configuration available for current device');
+                }
+                setConfiguration(resolvedConfig);
+                // Cache the result
+                if (cache) {
+                    await cache.set(paywallIdentifier, {
+                        paywall: data.paywall,
+                        version: data.paywall.version || 1,
+                        cachedAt: Date.now(),
+                        expiresAt: Date.now() + ((cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.maxCacheAge) || 604800000),
+                    });
+                }
+            }
+            else {
+                throw new Error('Invalid paywall data');
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const checkAndUpdateInBackground = async (identifier, currentVersion) => {
+        try {
+            const versionInfo = await ApiClient_1.ApiClient.post('check-paywall-version', {
+                paywall_identifier: identifier,
+                current_version: currentVersion,
+            }, {
+                apiKey: apiKeyOverride,
+            });
+            if (versionInfo.has_update) {
+                console.log(`[usePaywall] New version available for ${identifier}`);
+                await fetchPaywall();
+            }
+        }
+        catch (err) {
+            console.error('[usePaywall] Background update failed:', err);
+        }
+    };
+    (0, react_1.useEffect)(() => {
+        fetchPaywall();
+    }, [paywallIdentifier, resolvedApiKey, skipFetch]);
+    return {
+        configuration,
+        loading,
+        error,
+        refetch: fetchPaywall,
+    };
+};
+exports.usePaywall = usePaywall;

package/dist/hooks/usePlacement.d.ts

@@ -0,0 +1,34 @@
+/**
+ * usePlacement Hook — placement registration with a feature-callback model
+ * (API_Calls_Migration P4, Track D).
+ *
+ * Mirrors the iOS `register` / Android `registerFeature` feature gate:
+ *  - **non-gated** placement → `onFeatureUnlocked` runs immediately;
+ *  - **gated** placement → the paywall is presented (via the native bridge)
+ *    and `onFeatureUnlocked` runs only on an entitlement-granting outcome
+ *    (already-entitled / purchased / restored). A dismissed/errored outcome
+ *    does NOT run it.
+ *
+ * Gating is resolved in JS through the unified `get-wall-for-placement`
+ * endpoint (an unknown placement is auto-created server-side — P4 hybrid
+ * auto-create). `usePaywall` + `useOfferings` remain the escape-hatch hooks.
+ */
+import type { PlacementResult, PaywallPresentationHandler } from '../models/Placement';
+export interface UsePlacementResult {
+    /**
+     * Result-handler variant — register a placement and get the
+     * `PlacementResult`. The paywall (if any) is presented via the native bridge.
+     */
+    register: (placementId: string, params?: Record<string, unknown>, handler?: PaywallPresentationHandler) => Promise<PlacementResult>;
+    /**
+     * Feature-closure variant — Superwall's `register("feature") { unlock() }`.
+     * Non-gated → `onFeatureUnlocked` runs immediately; gated → it runs only
+     * when the placement yields entitlement (entitled / purchased / restored).
+     */
+    registerFeature: (placementId: string, onFeatureUnlocked: () => void, params?: Record<string, unknown>) => Promise<PlacementResult>;
+    /** True while a registration is in flight. */
+    loading: boolean;
+    /** The most recent `PlacementResult`, or null. */
+    lastResult: PlacementResult | null;
+}
+export declare const usePlacement: () => UsePlacementResult;