@mysuperwall/react-native 0.0.0-stage → 1.2.0

package/lib/engine/localRuleEngine.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRuleEngine = void 0;
+/**
+ * Pure TypeScript SHA-256 hash to ensure 0-dependency, 0-native-bridge execution on Hermes & JSC.
+ */
+function sha256Bytes(ascii) {
+    function rightRotate(value, amount) {
+        return (value >>> amount) | (value << (32 - amount));
+    }
+    const mathPow = Math.pow;
+    const maxWord = mathPow(2, 32);
+    const lengthProperty = 'length';
+    let i = 0, j = 0;
+    let result = '';
+    const words = [];
+    const asciiBitLength = ascii[lengthProperty] * 8;
+    const hash = [];
+    const k = [];
+    let primeCounter = 0;
+    const isComposite = {};
+    for (let candidate = 2; primeCounter < 64; candidate++) {
+        if (!isComposite[candidate]) {
+            for (i = 0; i < 313; i += candidate) {
+                isComposite[i] = true;
+            }
+            hash[primeCounter] = (mathPow(candidate, 0.5) * maxWord) | 0;
+            k[primeCounter++] = (mathPow(candidate, 1 / 3) * maxWord) | 0;
+        }
+    }
+    ascii += '\x80';
+    while ((ascii[lengthProperty] % 64) - 56)
+        ascii += '\x00';
+    for (i = 0; i < ascii[lengthProperty]; i++) {
+        j = ascii.charCodeAt(i);
+        words[i >> 2] |= j << (((3 - i) % 4) * 8);
+    }
+    words[words[lengthProperty]] = (asciiBitLength / maxWord) | 0;
+    words[words[lengthProperty]] = asciiBitLength;
+    for (j = 0; j < words[lengthProperty];) {
+        const w = words.slice(j, (j += 16));
+        const oldHash = hash.slice(0);
+        for (i = 0; i < 64; i++) {
+            const w15 = w[i - 15], w2 = w[i - 2];
+            const s0 = rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15 >>> 3);
+            const s1 = rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2 >>> 10);
+            w[i] = i < 16 ? w[i] : (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+            const s1_maj = rightRotate(hash[0], 2) ^ rightRotate(hash[0], 13) ^ rightRotate(hash[0], 22);
+            const maj = (hash[0] & hash[1]) ^ (hash[0] & hash[2]) ^ (hash[1] & hash[2]);
+            const t2 = (s1_maj + maj) | 0;
+            const s1_ch = rightRotate(hash[4], 6) ^ rightRotate(hash[4], 11) ^ rightRotate(hash[4], 25);
+            const ch = (hash[4] & hash[5]) ^ (~hash[4] & hash[6]);
+            const t1 = (hash[7] + s1_ch + ch + k[i] + w[i]) | 0;
+            hash[7] = hash[6];
+            hash[6] = hash[5];
+            hash[5] = hash[4];
+            hash[4] = (hash[3] + t1) | 0;
+            hash[3] = hash[2];
+            hash[2] = hash[1];
+            hash[1] = hash[0];
+            hash[0] = (t1 + t2) | 0;
+        }
+        for (i = 0; i < 8; i++) {
+            hash[i] = (hash[i] + oldHash[i]) | 0;
+        }
+    }
+    const out = new Uint8Array(32);
+    for (i = 0; i < 8; i++) {
+        out[i * 4] = (hash[i] >>> 24) & 255;
+        out[i * 4 + 1] = (hash[i] >>> 16) & 255;
+        out[i * 4 + 2] = (hash[i] >>> 8) & 255;
+        out[i * 4 + 3] = hash[i] & 255;
+    }
+    return out;
+}
+class LocalRuleEngine {
+    /**
+     * Deterministic bucket from 0 to 99 matching backend SHA-256 logic.
+     */
+    getDeterministicBucket(userId, salt = '') {
+        if (!userId) {
+            return Math.floor(Math.random() * 100);
+        }
+        const input = `${userId}:${salt}`;
+        // Match backend/native SHA-256 over UTF-8, including non-ASCII user IDs.
+        const utf8 = encodeURIComponent(input).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+        const bytes = sha256Bytes(utf8);
+        const u32 = ((bytes[0] << 24) >>> 0) +
+            ((bytes[1] << 16) >>> 0) +
+            ((bytes[2] << 8) >>> 0) +
+            (bytes[3] >>> 0);
+        return (u32 % 100) >>> 0;
+    }
+    /**
+     * Compares two semantic version strings.
+     */
+    compareVersions(v1, v2) {
+        const clean1 = (v1 || '').replace(/[^0-9.]/g, '');
+        const clean2 = (v2 || '').replace(/[^0-9.]/g, '');
+        const p1 = clean1.split('.').map(n => parseInt(n, 10) || 0);
+        const p2 = clean2.split('.').map(n => parseInt(n, 10) || 0);
+        const maxLen = Math.max(p1.length, p2.length);
+        for (let i = 0; i < maxLen; i++) {
+            const n1 = p1[i] ?? 0;
+            const n2 = p2[i] ?? 0;
+            if (n1 > n2)
+                return 1;
+            if (n1 < n2)
+                return -1;
+        }
+        return 0;
+    }
+    /**
+     * Resolves nested field access like "metadata.tier".
+     */
+    resolveContextValue(field, context) {
+        if (field in context)
+            return context[field];
+        const parts = field.split('.');
+        let current = context;
+        for (const part of parts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    /**
+     * Evaluates a single condition.
+     */
+    evaluateCondition(condition, context) {
+        const actual = this.resolveContextValue(condition.field, context);
+        const op = (condition.operator || 'equals').toLowerCase();
+        const target = condition.value;
+        switch (op) {
+            case 'equals':
+            case 'eq':
+                if (actual !== undefined && actual !== null && target !== undefined && target !== null) {
+                    return String(actual).trim().toLowerCase() === String(target).trim().toLowerCase();
+                }
+                return actual == target;
+            case 'not_equals':
+            case 'neq':
+                if (actual !== undefined && actual !== null && target !== undefined && target !== null) {
+                    return String(actual).trim().toLowerCase() !== String(target).trim().toLowerCase();
+                }
+                return actual != target;
+            case 'contains':
+                if (actual === undefined || actual === null || target === undefined || target === null)
+                    return false;
+                return String(actual).toLowerCase().includes(String(target).toLowerCase());
+            case 'not_contains':
+                if (actual === undefined || actual === null || target === undefined || target === null)
+                    return true;
+                return !String(actual).toLowerCase().includes(String(target).toLowerCase());
+            case 'gt':
+            case 'gte':
+            case 'lt':
+            case 'lte': {
+                const aNum = Number(actual);
+                const tNum = Number(target);
+                if (isNaN(aNum) || isNaN(tNum))
+                    return false;
+                if (op === 'gt')
+                    return aNum > tNum;
+                if (op === 'gte')
+                    return aNum >= tNum;
+                if (op === 'lt')
+                    return aNum < tNum;
+                if (op === 'lte')
+                    return aNum <= tNum;
+                return false;
+            }
+            case 'in_list':
+            case 'in': {
+                if (actual === undefined || actual === null)
+                    return false;
+                const aStr = String(actual).trim().toLowerCase();
+                if (Array.isArray(target)) {
+                    return target.some(elem => String(elem).trim().toLowerCase() === aStr);
+                }
+                const parts = String(target).split(',').map(s => s.trim().toLowerCase());
+                return parts.includes(aStr);
+            }
+            case 'not_in_list':
+            case 'not_in': {
+                if (actual === undefined || actual === null)
+                    return true;
+                const aStr = String(actual).trim().toLowerCase();
+                if (Array.isArray(target)) {
+                    return !target.some(elem => String(elem).trim().toLowerCase() === aStr);
+                }
+                const parts = String(target).split(',').map(s => s.trim().toLowerCase());
+                return !parts.includes(aStr);
+            }
+            case 'version_gt':
+                return this.compareVersions(actual, target) > 0;
+            case 'version_gte':
+                return this.compareVersions(actual, target) >= 0;
+            case 'version_lt':
+                return this.compareVersions(actual, target) < 0;
+            case 'version_lte':
+                return this.compareVersions(actual, target) <= 0;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Checks if a rule matches given context.
+     */
+    matchesRule(rule, context) {
+        if (!rule.conditions || rule.conditions.length === 0)
+            return true;
+        const isAny = rule.matchType === 'any';
+        return isAny
+            ? rule.conditions.some(c => this.evaluateCondition(c, context))
+            : rule.conditions.every(c => this.evaluateCondition(c, context));
+    }
+    /**
+     * Deterministically selects a variant respecting holdout.
+     */
+    selectDeterministicVariant(userId, salt, variants, fallbackPaywallId, holdoutPercentage = 0) {
+        if (holdoutPercentage > 0) {
+            const holdoutBucket = this.getDeterministicBucket(userId, `${salt}:holdout`);
+            if (holdoutBucket < holdoutPercentage) {
+                return { paywallId: null, abVariant: null, isHoldout: true };
+            }
+        }
+        const validVariants = (variants || []).filter(v => Boolean(v.paywallId));
+        if (validVariants.length === 0) {
+            return { paywallId: fallbackPaywallId, abVariant: 'A', isHoldout: false };
+        }
+        const totalWeight = validVariants.reduce((sum, v) => sum + Math.max(1, v.weight ?? 50), 0);
+        if (totalWeight <= 0) {
+            const first = validVariants[0];
+            return { paywallId: first.paywallId, abVariant: first.variant, isHoldout: false };
+        }
+        const bucket = this.getDeterministicBucket(userId, `${salt}:variant`);
+        const target = Math.floor((bucket * totalWeight) / 100);
+        let cumulative = 0;
+        for (const v of validVariants) {
+            cumulative += Math.max(1, v.weight ?? 50);
+            if (target < cumulative) {
+                return { paywallId: v.paywallId, abVariant: v.variant, isHoldout: false };
+            }
+        }
+        const last = validVariants[validVariants.length - 1];
+        return { paywallId: last.paywallId, abVariant: last.variant, isHoldout: false };
+    }
+    /**
+     * Resolves a trigger in-memory with 0 ms latency.
+     */
+    resolveTrigger(trigger, userId, context) {
+        // 1. Check priority-ordered audience rules
+        const activeRules = [...(trigger.rules || [])].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        for (const rule of activeRules) {
+            if (this.matchesRule(rule, context)) {
+                const { paywallId, abVariant, isHoldout } = this.selectDeterministicVariant(userId, rule.id, rule.variants, rule.paywallId || trigger.paywallId, rule.holdoutPercentage || 0);
+                if (isHoldout) {
+                    return {
+                        show: false,
+                        paywallId: null,
+                        abVariant: null,
+                        matchedRuleName: rule.name,
+                        matchedRuleId: rule.id,
+                        isHoldout: true,
+                        reason: 'rule_holdout'
+                    };
+                }
+                if (paywallId) {
+                    return {
+                        show: true,
+                        paywallId,
+                        abVariant: abVariant || 'A',
+                        matchedRuleName: rule.name,
+                        matchedRuleId: rule.id,
+                        isHoldout: false,
+                        reason: 'rule_matched'
+                    };
+                }
+            }
+        }
+        // 2. Fall back to root trigger variants & holdout
+        const { paywallId, abVariant, isHoldout } = this.selectDeterministicVariant(userId, trigger.key, trigger.variants, trigger.paywallId, trigger.holdoutPercentage || 0);
+        if (isHoldout) {
+            return {
+                show: false,
+                paywallId: null,
+                abVariant: null,
+                matchedRuleName: null,
+                isHoldout: true,
+                reason: 'root_holdout'
+            };
+        }
+        if (paywallId) {
+            return {
+                show: true,
+                paywallId,
+                abVariant: abVariant || 'A',
+                matchedRuleName: null,
+                isHoldout: false,
+                reason: 'root_variant'
+            };
+        }
+        return {
+            show: false,
+            paywallId: null,
+            abVariant: null,
+            matchedRuleName: null,
+            isHoldout: false,
+            reason: 'no_paywall_mapped'
+        };
+    }
+}
+exports.LocalRuleEngine = LocalRuleEngine;

package/lib/hooks/usePaywall.d.ts

@@ -0,0 +1,7 @@
+import { PaywallData, PaywallCallbackActions } from '../models/paywall';
+export declare function usePaywall(): {
+    activePaywall: PaywallData | null;
+    isVisible: boolean;
+    callbacks: PaywallCallbackActions;
+    dismiss: () => void;
+};

package/lib/hooks/usePaywall.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePaywall = usePaywall;
+const react_1 = require("react");
+const MySuperwall_1 = require("../MySuperwall");
+function usePaywall() {
+    const [activePaywall, setActivePaywall] = (0, react_1.useState)(null);
+    const [callbacks, setCallbacks] = (0, react_1.useState)({});
+    (0, react_1.useEffect)(() => {
+        const unregister = MySuperwall_1.MySuperwall.shared.registerPresenter((paywall, actions) => {
+            setActivePaywall(paywall);
+            setCallbacks(actions);
+        });
+        return unregister;
+    }, []);
+    const dismiss = (0, react_1.useCallback)(() => {
+        setActivePaywall(null);
+    }, []);
+    return {
+        activePaywall,
+        isVisible: Boolean(activePaywall),
+        callbacks,
+        dismiss
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * from './models/manifest';
+export * from './models/paywall';
+export * from './engine/localRuleEngine';
+export * from './services/manifestService';
+export * from './services/offlineEventQueue';
+export * from './ui/PaywallModal';
+export * from './hooks/usePaywall';
+import { MySuperwall } from './MySuperwall';
+export { MySuperwall };
+export default MySuperwall;
+export type { MySuperwallInitOptions } from './MySuperwall';

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySuperwall = void 0;
+__exportStar(require("./models/manifest"), exports);
+__exportStar(require("./models/paywall"), exports);
+__exportStar(require("./engine/localRuleEngine"), exports);
+__exportStar(require("./services/manifestService"), exports);
+__exportStar(require("./services/offlineEventQueue"), exports);
+__exportStar(require("./ui/PaywallModal"), exports);
+__exportStar(require("./hooks/usePaywall"), exports);
+const MySuperwall_1 = require("./MySuperwall");
+Object.defineProperty(exports, "MySuperwall", { enumerable: true, get: function () { return MySuperwall_1.MySuperwall; } });
+exports.default = MySuperwall_1.MySuperwall;

package/lib/models/manifest.d.ts

@@ -0,0 +1,76 @@
+export interface ManifestCondition {
+    field: string;
+    operator: string;
+    value: any;
+}
+export interface ManifestVariant {
+    variantId?: string;
+    variantLabel?: string;
+    variant: string;
+    weight: number;
+    paywallId: string | null;
+}
+export interface ManifestRule {
+    experimentId?: string;
+    experimentVersion?: string;
+    audienceId?: string;
+    id: string;
+    name: string;
+    priority: number;
+    matchType: 'all' | 'any';
+    conditions: ManifestCondition[];
+    holdoutPercentage: number;
+    paywallId: string | null;
+    variants: ManifestVariant[];
+}
+export interface ManifestTrigger {
+    experimentId?: string;
+    experimentVersion?: string;
+    audienceId?: string;
+    id: string;
+    key: string;
+    prewarmPriority?: number;
+    holdoutPercentage?: number;
+    paywallId: string | null;
+    variants: ManifestVariant[];
+    rules: ManifestRule[];
+    dismissAction?: {
+        type: string;
+        followUpPaywallId?: string | null;
+    };
+}
+export interface ManifestPaywallProduct {
+    productId: string;
+    variableName?: string;
+}
+export interface FollowUpRule {
+    enabled?: boolean;
+    actionType?: string;
+    triggerKey?: string;
+    delayMs?: number;
+    oncePerSession?: boolean;
+    cooldownMs?: number;
+    maxChainDepth?: number;
+    skipIfPremium?: boolean;
+    preventRepeatPaywall?: boolean;
+}
+export interface ManifestPaywall {
+    publishedVersion?: number;
+    id: string;
+    name: string;
+    templateKey: string;
+    contentJson?: {
+        followUpRules?: Record<string, FollowUpRule>;
+    };
+    html: string;
+    productIds: string[];
+    products: ManifestPaywallProduct[];
+}
+export interface PaywallManifest {
+    ok: boolean;
+    notModified?: boolean;
+    hash?: string;
+    appId?: string;
+    triggers: ManifestTrigger[];
+    paywalls: Record<string, ManifestPaywall>;
+}

package/lib/models/manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/paywall.d.ts

@@ -0,0 +1,36 @@
+import { FollowUpRule, ManifestPaywallProduct } from './manifest';
+export interface ExperimentContext {
+    experimentId: string;
+    experimentVersion: string;
+    audienceId: string;
+    variantId: string;
+    variantLabel: string;
+    paywallId: string;
+    paywallVersion: number;
+}
+export interface PaywallData {
+    attributionScope?: string;
+    presentationId?: string;
+    followUpRules?: Record<string, FollowUpRule>;
+    dismissFollowUpPaywallId?: string;
+    experimentContext?: ExperimentContext;
+    attributionUserId?: string;
+    id: string;
+    name: string;
+    html: string;
+    productIds: string[];
+    products: ManifestPaywallProduct[];
+    triggerKey?: string;
+    abVariant?: string;
+}
+export interface PaywallResult {
+    show: boolean;
+    paywall: PaywallData | null;
+    reason: string;
+}
+export interface PaywallCallbackActions {
+    onPurchase?: (productId: string) => void | Promise<void>;
+    onRestore?: () => void | Promise<void>;
+    onDismiss?: () => void | Promise<void>;
+    onOpenUrl?: (url: string) => void | Promise<void>;
+}

package/lib/models/paywall.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/anonymousIdentity.d.ts

@@ -0,0 +1,6 @@
+/** Stable installation identity, isolated by server and application. */
+export declare class AnonymousIdentity {
+    private static identities;
+    static get(scope: string): Promise<string>;
+    private static load;
+}

package/lib/services/anonymousIdentity.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnonymousIdentity = void 0;
+/** Stable installation identity, isolated by server and application. */
+class AnonymousIdentity {
+    static get(scope) {
+        const existing = this.identities.get(scope);
+        if (existing)
+            return existing;
+        const identity = this.load(scope);
+        this.identities.set(scope, identity);
+        return identity;
+    }
+    static async load(scope) {
+        const key = '@mysuperwall_anonymous_v1:' + encodeURIComponent(scope);
+        let storage;
+        try {
+            storage = require('@react-native-async-storage/async-storage').default;
+        }
+        catch (_) { }
+        try {
+            const saved = await storage?.getItem(key);
+            if (saved?.startsWith('anon_'))
+                return saved;
+        }
+        catch (_) { }
+        const identity = 'anon_' + Date.now().toString(36) + Math.random().toString(36).slice(2);
+        try {
+            await storage?.setItem(key, identity);
+        }
+        catch (_) { }
+        return identity;
+    }
+}
+exports.AnonymousIdentity = AnonymousIdentity;
+AnonymousIdentity.identities = new Map();

package/lib/services/followUpService.d.ts

@@ -0,0 +1,9 @@
+import { FollowUpRule } from '../models/manifest';
+/** Session-scoped policy; all timers and reservations are invalidated on identity/config changes. */
+export declare class FollowUpService {
+    private used;
+    private timers;
+    cancel(): void;
+    reset(): void;
+    schedule(key: string, rule: FollowUpRule, depth: number, premium: boolean, run: () => void): boolean;
+}

package/lib/services/followUpService.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowUpService = void 0;
+/** Session-scoped policy; all timers and reservations are invalidated on identity/config changes. */
+class FollowUpService {
+    constructor() {
+        this.used = new Map();
+        this.timers = new Set();
+    }
+    cancel() { this.timers.forEach(clearTimeout); this.timers.clear(); }
+    reset() { this.cancel(); this.used.clear(); }
+    schedule(key, rule, depth, premium, run) {
+        const number = (value, fallback, max) => typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.min(max, Math.floor(value))) : fallback;
+        if (!rule.enabled || (rule.actionType || 'trigger') !== 'trigger' || !rule.triggerKey?.trim() ||
+            (rule.skipIfPremium && premium) || depth >= Math.max(1, number(rule.maxChainDepth, 2, 5)))
+            return false;
+        const previous = this.used.get(key);
+        if (previous !== undefined && (rule.oncePerSession !== false || Date.now() - previous < number(rule.cooldownMs, 0, 86400000)))
+            return false;
+        this.used.set(key, Date.now());
+        const timer = setTimeout(() => { this.timers.delete(timer); run(); }, number(rule.delayMs, 0, 10000));
+        this.timers.add(timer);
+        return true;
+    }
+}
+exports.FollowUpService = FollowUpService;

package/lib/services/manifestService.d.ts

@@ -0,0 +1,22 @@
+import { PaywallManifest } from '../models/manifest';
+export interface ManifestScope {
+    baseUrl: string;
+    appKey?: string;
+    bundleId?: string;
+    platform?: string;
+    lang?: string;
+    substitutionData?: Record<string, unknown>;
+}
+export declare class ManifestService {
+    private scope;
+    private generation;
+    manifest: PaywallManifest | null;
+    private asyncStorage;
+    constructor();
+    static scopeKey(options: ManifestScope): string;
+    configure(options: ManifestScope): void;
+    private key;
+    loadFromDisk(): Promise<PaywallManifest | null>;
+    saveToDisk(manifest: PaywallManifest): Promise<void>;
+    syncInBackground(options: ManifestScope): Promise<PaywallManifest | null>;
+}