@mysuperwall/react-native 0.0.0-stage → 1.1.0

package/src/engine/localRuleEngine.ts

@@ -0,0 +1,375 @@
+import { ManifestCondition, ManifestRule, ManifestTrigger, ManifestVariant } from '../models/manifest';
+
+/**
+ * Pure TypeScript SHA-256 hash to ensure 0-dependency, 0-native-bridge execution on Hermes & JSC.
+ */
+function sha256Bytes(ascii: string): Uint8Array {
+  function rightRotate(value: number, amount: number) {
+    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: number[] = [];
+  const asciiBitLength = ascii[lengthProperty] * 8;
+
+  const hash: number[] = [];
+  const k: number[] = [];
+  let primeCounter = 0;
+
+  const isComposite: Record<number, boolean> = {};
+  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;
+}
+
+export interface RuleEngineResolution {
+  matchedRuleId?: string;
+  show: boolean;
+  paywallId: string | null;
+  abVariant: string | null;
+  matchedRuleName: string | null;
+  isHoldout: boolean;
+  reason: string;
+}
+
+export class LocalRuleEngine {
+  /**
+   * Deterministic bucket from 0 to 99 matching backend SHA-256 logic.
+   */
+  getDeterministicBucket(userId?: string | null, salt: string = ''): number {
+    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) => 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?: string | null, v2?: string | null): number {
+    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: string, context: Record<string, any>): any {
+    if (field in context) return context[field];
+    const parts = field.split('.');
+    let current: any = 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: ManifestCondition, context: Record<string, any>): boolean {
+    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: ManifestRule, context: Record<string, any>): boolean {
+    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: string | null | undefined,
+    salt: string,
+    variants: ManifestVariant[],
+    fallbackPaywallId: string | null,
+    holdoutPercentage: number = 0
+  ): { paywallId: string | null; abVariant: string | null; isHoldout: boolean } {
+    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: ManifestTrigger,
+    userId: string | null | undefined,
+    context: Record<string, any>
+  ): RuleEngineResolution {
+    // 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'
+    };
+  }
+}

package/src/hooks/usePaywall.ts

@@ -0,0 +1,27 @@
+import { useState, useEffect, useCallback } from 'react';
+import { MySuperwall } from '../MySuperwall';
+import { PaywallData, PaywallCallbackActions } from '../models/paywall';
+
+export function usePaywall() {
+  const [activePaywall, setActivePaywall] = useState<PaywallData | null>(null);
+  const [callbacks, setCallbacks] = useState<PaywallCallbackActions>({});
+
+  useEffect(() => {
+    const unregister = MySuperwall.shared.registerPresenter((paywall, actions) => {
+      setActivePaywall(paywall);
+      setCallbacks(actions);
+    });
+    return unregister;
+  }, []);
+
+  const dismiss = useCallback(() => {
+    setActivePaywall(null);
+  }, []);
+
+  return {
+    activePaywall,
+    isVisible: Boolean(activePaywall),
+    callbacks,
+    dismiss
+  };
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+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/src/models/manifest.ts

@@ -0,0 +1,81 @@
+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/src/models/paywall.ts

@@ -0,0 +1,40 @@
+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/src/services/anonymousIdentity.ts

@@ -0,0 +1,28 @@
+interface IdentityStorage {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+}
+
+/** Stable installation identity, isolated by server and application. */
+export class AnonymousIdentity {
+  private static identities = new Map<string, Promise<string>>();
+  static get(scope: string): Promise<string> {
+    const existing = this.identities.get(scope);
+    if (existing) return existing;
+    const identity = this.load(scope);
+    this.identities.set(scope, identity);
+    return identity;
+  }
+  private static async load(scope: string): Promise<string> {
+    const key = '@mysuperwall_anonymous_v1:' + encodeURIComponent(scope);
+    let storage: IdentityStorage | undefined;
+    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;
+  }
+}

package/src/services/followUpService.ts

@@ -0,0 +1,21 @@
+import { FollowUpRule } from '../models/manifest';
+
+/** Session-scoped policy; all timers and reservations are invalidated on identity/config changes. */
+export class FollowUpService {
+  private used = new Map<string, number>();
+  private timers = new Set<ReturnType<typeof setTimeout>>();
+  cancel(): void { this.timers.forEach(clearTimeout); this.timers.clear(); }
+  reset(): void { this.cancel(); this.used.clear(); }
+  schedule(key: string, rule: FollowUpRule, depth: number, premium: boolean, run: () => void): boolean {
+    const number = (value: unknown, fallback: number, max: number) =>
+      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;
+  }
+}

package/src/services/manifestService.ts

@@ -0,0 +1,63 @@
+import { PaywallManifest } from '../models/manifest';
+
+export interface ManifestScope {
+  baseUrl: string; appKey?: string; bundleId?: string; platform?: string; lang?: string;
+}
+
+export class ManifestService {
+  private scope = '';
+  private generation = 0;
+  public manifest: PaywallManifest | null = null;
+  private asyncStorage: any = null;
+  constructor() {
+    try { this.asyncStorage = require('@react-native-async-storage/async-storage').default; }
+    catch (_) { /* Memory-only operation remains supported. */ }
+  }
+  static scopeKey(options: ManifestScope): string {
+    return JSON.stringify([options.baseUrl.replace(/\/+$/, '') + '/', options.appKey || '',
+      options.bundleId || '', options.platform || 'ios', options.lang || 'en']);
+  }
+  configure(options: ManifestScope): void {
+    const scope = ManifestService.scopeKey(options);
+    if (scope !== this.scope) { this.scope = scope; this.generation++; this.manifest = null; }
+  }
+  private key(scope: string): string { return '@mysuperwall_manifest_v2:' + encodeURIComponent(scope); }
+  async loadFromDisk(): Promise<PaywallManifest | null> {
+    const scope = this.scope, generation = this.generation;
+    if (!scope || !this.asyncStorage) return this.manifest;
+    try {
+      const raw = await this.asyncStorage.getItem(this.key(scope));
+      if (scope !== this.scope || generation !== this.generation) return null;
+      const parsed = raw ? JSON.parse(raw) : null;
+      this.manifest = parsed?.ok && parsed.paywalls && Array.isArray(parsed.triggers) ? parsed : null;
+    } catch (_) { /* Never adopt a legacy or malformed cache. */ }
+    return this.manifest;
+  }
+  async saveToDisk(manifest: PaywallManifest): Promise<void> {
+    const scope = this.scope;
+    if (!scope) return;
+    this.manifest = manifest;
+    try { await this.asyncStorage?.setItem(this.key(scope), JSON.stringify(manifest)); } catch (_) {}
+  }
+  async syncInBackground(options: ManifestScope): Promise<PaywallManifest | null> {
+    this.configure(options);
+    const scope = this.scope, generation = this.generation;
+    try {
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+      if (this.manifest?.hash) headers['If-None-Match'] = `"${this.manifest.hash}"`;
+      const response = await fetch(options.baseUrl.replace(/\/+$/, '') + '/paywall/manifest', {
+        method: 'POST', headers, body: JSON.stringify({ platform: options.platform || 'ios',
+          appKey: options.appKey, bundleId: options.platform === 'android' ? undefined : options.bundleId,
+          packageName: options.platform === 'android' ? options.bundleId : undefined, lang: options.lang || 'en', hash: this.manifest?.hash })
+      });
+      if (scope !== this.scope || generation !== this.generation) return null;
+      if (response.status === 304) return this.manifest;
+      if (response.ok) {
+        const data: PaywallManifest = await response.json();
+        if (scope !== this.scope || generation !== this.generation) return null;
+        if (!data.notModified && data.ok && data.paywalls && Array.isArray(data.triggers)) await this.saveToDisk(data);
+      }
+    } catch (_) { /* Keep this scope's cache on transient failure. */ }
+    return scope === this.scope && generation === this.generation ? this.manifest : null;
+  }
+}