@mysuperwall/react-native 0.0.0-stage → 1.2.0

package/lib/services/manifestService.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestService = void 0;
+class ManifestService {
+    constructor() {
+        this.scope = '';
+        this.generation = 0;
+        this.manifest = null;
+        this.asyncStorage = null;
+        try {
+            this.asyncStorage = require('@react-native-async-storage/async-storage').default;
+        }
+        catch (_) { /* Memory-only operation remains supported. */ }
+    }
+    static scopeKey(options) {
+        return JSON.stringify([options.baseUrl.replace(/\/+$/, '') + '/', options.appKey || '',
+            options.bundleId || '', options.platform || 'ios', options.lang || 'en', JSON.stringify(options.substitutionData || {})]);
+    }
+    configure(options) {
+        const scope = ManifestService.scopeKey(options);
+        if (scope !== this.scope) {
+            this.scope = scope;
+            this.generation++;
+            this.manifest = null;
+        }
+    }
+    key(scope) { return '@mysuperwall_manifest_v2:' + encodeURIComponent(scope); }
+    async loadFromDisk() {
+        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) {
+        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) {
+        this.configure(options);
+        const scope = this.scope, generation = this.generation;
+        try {
+            const headers = { '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, substitutionData: options.substitutionData || {} })
+            });
+            if (scope !== this.scope || generation !== this.generation)
+                return null;
+            if (response.status === 304)
+                return this.manifest;
+            if (response.ok) {
+                const data = 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;
+    }
+}
+exports.ManifestService = ManifestService;

package/lib/services/offlineEventQueue.d.ts

@@ -0,0 +1,18 @@
+export declare class OfflineEventQueue {
+    private queueKey;
+    private asyncStorage;
+    private isFlushing;
+    private memoryQueue;
+    private mutation;
+    constructor(scope?: string);
+    private serialized;
+    private read;
+    private write;
+    enqueue(event: Record<string, any>): Promise<void>;
+    flush(options: {
+        baseUrl: string;
+        appKey?: string;
+        bundleId?: string;
+        platform?: string;
+    }): Promise<void>;
+}

package/lib/services/offlineEventQueue.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineEventQueue = void 0;
+function eventId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, char => {
+        const value = Math.floor(Math.random() * 16);
+        return (char === 'x' ? value : (value & 3) | 8).toString(16);
+    });
+}
+class OfflineEventQueue {
+    constructor(scope) {
+        this.queueKey = '@mysuperwall_offline_event_queue_v1';
+        this.asyncStorage = null;
+        this.isFlushing = false;
+        this.memoryQueue = [];
+        this.mutation = Promise.resolve();
+        if (scope)
+            this.queueKey = '@mysuperwall_event_queue_v2:' + encodeURIComponent(scope);
+        try {
+            this.asyncStorage = require('@react-native-async-storage/async-storage').default;
+        }
+        catch (_) {
+            this.asyncStorage = null;
+        }
+    }
+    serialized(operation) {
+        const next = this.mutation.then(operation, operation);
+        this.mutation = next.catch(() => undefined);
+        return next;
+    }
+    async read() {
+        if (!this.asyncStorage)
+            return [...this.memoryQueue];
+        try {
+            const raw = await this.asyncStorage.getItem(this.queueKey);
+            const parsed = raw ? JSON.parse(raw) : [];
+            if (!Array.isArray(parsed))
+                return [];
+            const list = parsed.filter(item => item && typeof item === 'object').map(item => ({ ...item, eventId: item.eventId || eventId() }));
+            this.memoryQueue = list;
+            return list;
+        }
+        catch (_) {
+            this.asyncStorage = null;
+            return [...this.memoryQueue];
+        }
+    }
+    async write(list) {
+        this.memoryQueue = list;
+        if (this.asyncStorage) {
+            try {
+                await this.asyncStorage.setItem(this.queueKey, JSON.stringify(list));
+            }
+            catch (_) {
+                this.asyncStorage = null;
+            }
+        }
+    }
+    async enqueue(event) {
+        // IDs and context are captured before asynchronous persistence, once per event.
+        const captured = JSON.parse(JSON.stringify({ ...event, eventId: event.eventId || eventId(),
+            timestamp: event.timestamp || new Date().toISOString() }));
+        await this.serialized(async () => {
+            const list = await this.read();
+            await this.write([...list, captured].slice(-200));
+        });
+    }
+    async flush(options) {
+        if (this.isFlushing)
+            return;
+        this.isFlushing = true;
+        try {
+            const batch = await this.serialized(async () => {
+                const list = await this.read();
+                await this.write(list); // Persist upgraded legacy IDs before the request.
+                return list.slice(0, 100);
+            });
+            if (!batch.length)
+                return;
+            const base = options.baseUrl.endsWith('/') ? options.baseUrl : `${options.baseUrl}/`;
+            const response = await fetch(`${base}paywall/events/batch`, {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ platform: options.platform || 'react-native', appKey: options.appKey,
+                    bundleId: options.platform === 'android' ? undefined : options.bundleId,
+                    packageName: options.platform === 'android' ? options.bundleId : undefined, events: batch })
+            });
+            if (response.ok) {
+                const sent = new Set(batch.map(event => event.eventId));
+                await this.serialized(async () => {
+                    const current = await this.read();
+                    await this.write(current.filter(event => !sent.has(event.eventId)));
+                });
+            }
+        }
+        catch (_) { /* Retain the original IDs for retry. */ }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+}
+exports.OfflineEventQueue = OfflineEventQueue;

package/lib/ui/PaywallModal.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { PaywallData, PaywallCallbackActions } from '../models/paywall';
+export interface PaywallModalProps extends PaywallCallbackActions {
+    visible: boolean;
+    paywall: PaywallData | null;
+    onClose: () => void;
+}
+export declare const PaywallModal: FC<PaywallModalProps>;

package/lib/ui/PaywallModal.js

@@ -0,0 +1,136 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaywallModal = void 0;
+const react_1 = __importStar(require("react"));
+const MySuperwall_1 = require("../MySuperwall");
+const react_native_1 = require("react-native");
+const PaywallModal = props => {
+    if (!props.visible || !props.paywall)
+        return null;
+    // Remount the displayed session when HTML or attribution changes, even if the
+    // paywall ID stays the same. Freeze the payload to the HTML sent to WebView.
+    const captured = JSON.parse(JSON.stringify(props.paywall));
+    const sessionKey = JSON.stringify(captured);
+    return react_1.default.createElement(PaywallModalContent, { key: sessionKey, ...props, paywall: captured });
+};
+exports.PaywallModal = PaywallModal;
+const PaywallModalContent = ({ visible, paywall, onClose, onPurchase, onRestore, onDismiss, onOpenUrl }) => {
+    const shown = (0, react_1.useRef)(false);
+    const dismissed = (0, react_1.useRef)(false);
+    if (!visible || !paywall)
+        return null;
+    const track = (type, productId) => {
+        void MySuperwall_1.MySuperwall.shared.trackPaywallEvent(type, paywall, productId);
+    };
+    const dismiss = () => {
+        if (dismissed.current)
+            return;
+        dismissed.current = true;
+        track('paywall_dismissed');
+        onClose();
+        void onDismiss?.();
+    };
+    let WebViewComponent = null;
+    try {
+        WebViewComponent = require('react-native-webview').WebView;
+    }
+    catch (_) {
+        console.warn('[MySuperwall] react-native-webview is required to render paywalls.');
+        return null;
+    }
+    const injectedJavaScript = `
+    window.MySuperWall = {
+      postMessage: function(msg) {
+        if (window.ReactNativeWebView && window.ReactNativeWebView.postMessage) {
+          window.ReactNativeWebView.postMessage(typeof msg === 'string' ? msg : JSON.stringify(msg));
+        }
+      }
+    };
+    true;
+  `;
+    const handleMessage = (event) => {
+        try {
+            const data = JSON.parse(event.nativeEvent.data);
+            const action = typeof data.action === 'string' ? data.action : data.type;
+            const type = typeof action === 'string' ? action.toLowerCase() : '';
+            switch (type) {
+                case 'purchase': {
+                    const productId = data.productId || data.product_id;
+                    if (typeof productId === 'string' && productId.trim()) {
+                        track('purchase_started', productId);
+                        if (onPurchase)
+                            onPurchase(productId);
+                    }
+                    break;
+                }
+                case 'restore': {
+                    track('restore_started');
+                    if (onRestore)
+                        onRestore();
+                    break;
+                }
+                case 'close':
+                case 'dismiss': {
+                    dismiss();
+                    break;
+                }
+                case 'open_url':
+                case 'openurl': {
+                    if (typeof data.url === 'string' && data.url.trim() && onOpenUrl)
+                        onOpenUrl(data.url);
+                    break;
+                }
+            }
+        }
+        catch (_) { }
+    };
+    return (react_1.default.createElement(react_native_1.Modal, { visible: visible, animationType: "slide", transparent: false, onRequestClose: dismiss },
+        react_1.default.createElement(react_native_1.SafeAreaView, { style: styles.container },
+            react_1.default.createElement(WebViewComponent, { originWhitelist: ['*'], source: { html: paywall.html, baseUrl: 'https://mysuperwall.com' }, injectedJavaScriptBeforeContentLoaded: injectedJavaScript, onMessage: handleMessage, onLoad: () => { if (!shown.current) {
+                    shown.current = true;
+                    track('paywall_shown');
+                } }, style: styles.webview, javaScriptEnabled: true, domStorageEnabled: true, bounces: false }))));
+};
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: '#000000'
+    },
+    webview: {
+        flex: 1,
+        backgroundColor: 'transparent'
+    }
+});

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@mysuperwall/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.0",
+  "description": "React Native SDK for MySuperWall paywalls, targeting and offline rule evaluation",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "mysuperwall",
+    "paywall",
+    "remote-config",
+    "in-app-purchases"
+  ],
+  "author": "MySuperwall",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=17.0.0",
+    "react-native": ">=0.64.0",
+    "react-native-webview": ">=11.0.0",
+    "@react-native-async-storage/async-storage": ">=1.15.0"
+  },
+  "react-native": "src/index.ts",
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@types/node": "^22.0.0",
+    "react": "18.2.0",
+    "@types/react": "^18.2.0",
+    "react-native": "0.73.4",
+    "react-native-webview": "13.8.1",
+    "@react-native-async-storage/async-storage": "1.21.0"
+  },
+  "homepage": "https://mysuperwall.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Unevenn/mysuperwall_react_native.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}