@octovise/react-native-sdk 1.0.0

package/dist/state.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canInit = canInit;
+exports.markInit = markInit;
+exports.isDuplicate = isDuplicate;
+exports.setCurrentMessage = setCurrentMessage;
+exports.clearCurrentMessage = clearCurrentMessage;
+exports.startForegroundListener = startForegroundListener;
+exports.stopForegroundListener = stopForegroundListener;
+exports.reset = reset;
+const react_native_1 = require("react-native");
+const INIT_COOLDOWN_MS = 90 * 1000;
+let lastInitAt = 0;
+let lastShownMessageId = null;
+let appStateSubscription = null;
+function canInit() {
+    if (!lastInitAt)
+        return true;
+    return Date.now() - lastInitAt >= INIT_COOLDOWN_MS;
+}
+function markInit() {
+    lastInitAt = Date.now();
+}
+function isDuplicate(messageId) {
+    if (!messageId)
+        return false;
+    return messageId === lastShownMessageId;
+}
+function setCurrentMessage(messageId) {
+    lastShownMessageId = messageId ?? null;
+}
+function clearCurrentMessage() {
+    lastShownMessageId = null;
+}
+function startForegroundListener(onForeground) {
+    if (appStateSubscription)
+        return;
+    appStateSubscription = react_native_1.AppState.addEventListener('change', (nextState) => {
+        if (nextState === 'active' && canInit()) {
+            markInit();
+            onForeground();
+        }
+    });
+}
+function stopForegroundListener() {
+    appStateSubscription?.remove();
+    appStateSubscription = null;
+}
+function reset() {
+    lastInitAt = 0;
+    lastShownMessageId = null;
+    stopForegroundListener();
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,6 @@
+export declare function inMetricsSample(uid: number | string | null, digits: number[]): boolean;
+export declare function configureTelemetry(uid: number | string): void;
+export declare function setMetricSampleDigits(digits: unknown): void;
+export declare function reportError(name: string, meta?: Record<string, unknown>): void;
+export declare function reportMetric(name: string, value: number, meta?: Record<string, unknown>): void;
+export declare function __resetTelemetryForTests(): void;

package/dist/telemetry.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inMetricsSample = inMetricsSample;
+exports.configureTelemetry = configureTelemetry;
+exports.setMetricSampleDigits = setMetricSampleDigits;
+exports.reportError = reportError;
+exports.reportMetric = reportMetric;
+exports.__resetTelemetryForTests = __resetTelemetryForTests;
+const api_1 = require("./api");
+let sampleDigits = [];
+let userId = null;
+const queue = [];
+let flushTimer = null;
+const FLUSH_MS = 2000;
+const FLUSH_SIZE = 20;
+function inMetricsSample(uid, digits) {
+    if (uid == null || digits.length === 0)
+        return false;
+    const n = Number(uid);
+    if (!Number.isFinite(n))
+        return false;
+    return digits.includes(Math.abs(Math.trunc(n)) % 10);
+}
+function configureTelemetry(uid) {
+    userId = uid;
+}
+function setMetricSampleDigits(digits) {
+    sampleDigits = Array.isArray(digits) ? digits.filter((d) => typeof d === 'number') : [];
+}
+function reportError(name, meta) {
+    enqueue({ kind: 'error', name, meta });
+}
+function reportMetric(name, value, meta) {
+    if (!inMetricsSample(userId, sampleDigits))
+        return;
+    enqueue({ kind: 'metric', name, value, meta });
+}
+function enqueue(e) {
+    queue.push(e);
+    if (queue.length >= FLUSH_SIZE) {
+        flush();
+        return;
+    }
+    if (!flushTimer)
+        flushTimer = setTimeout(flush, FLUSH_MS);
+}
+function flush() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    if (queue.length === 0)
+        return;
+    const events = queue.splice(0, queue.length);
+    (0, api_1.sendTelemetry)(events);
+}
+function __resetTelemetryForTests() {
+    sampleDigits = [];
+    userId = null;
+    queue.length = 0;
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+}

package/dist/toastLayout.d.ts

@@ -0,0 +1,2 @@
+export type ToastLayout = 'imageOnly' | 'textOnly' | 'stacked' | 'carousel';
+export declare function toastLayout(hasImage: boolean, hasText: boolean, imagePosition?: string): ToastLayout;

package/dist/toastLayout.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toastLayout = toastLayout;
+function toastLayout(hasImage, hasText, imagePosition) {
+    if (hasImage && !hasText)
+        return 'imageOnly';
+    if (!hasImage)
+        return 'textOnly';
+    const pos = imagePosition || 'left';
+    return pos === 'top' || pos === 'bottom' ? 'stacked' : 'carousel';
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+export interface NavAdapter {
+    navigate: (routeName: string, params?: Record<string, string>) => void;
+    getCurrentScreen?: () => string | null;
+    subscribeScreenChange?: (cb: (screenName: string, params?: Record<string, unknown>) => void) => () => void;
+}
+export interface OctoRNConfig {
+    apiKey: string;
+    userId: number | string;
+    userHash?: string;
+    baseUrl?: string;
+    appVersion?: string;
+    onCTA?: (url: string) => void;
+    nav?: NavAdapter;
+    onEvent?: (event: EventType, meta: Partial<EventMeta>, sendId: number) => void;
+    registerPushToken?: boolean;
+}
+export interface EntitySignal {
+    type: string;
+    id?: number | null;
+    ref?: string | null;
+}
+export interface InAppMessage {
+    id?: string;
+    _send_id?: number;
+    __timing?: {
+        t0: number;
+        tCheck: number;
+    };
+    layout: 'modal' | 'toast';
+    position?: 'center' | 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    mobile_position?: 'top' | 'center' | 'bottom';
+    size?: 'small' | 'medium' | 'large';
+    text_size?: 'small' | 'medium' | 'large';
+    text_align?: 'left' | 'center' | 'right';
+    title?: string;
+    body?: string;
+    image?: string;
+    image_position?: 'left' | 'right' | 'top' | 'bottom';
+    image_fit?: 'cover' | 'contain';
+    image_bg?: string;
+    cta: {
+        label: string;
+        url: string;
+        align?: 'left' | 'center' | 'right';
+        devices?: ('web' | 'mobile')[];
+    };
+    click_mode?: 'cta' | 'full' | 'none';
+    dismiss_label?: string;
+    colors?: {
+        primary?: string;
+        background?: string;
+        text?: string;
+    };
+}
+export type EventType = 'impression' | 'click' | 'dismiss' | 'received';
+export interface EventMeta {
+    duration_ms: number;
+    time_to_first_interaction_ms: number | null;
+    close_method?: 'cta' | 'dismiss_button' | 'backdrop' | 'close_button';
+    device: 'mobile';
+    platform: 'ios' | 'android';
+    image_loaded: boolean;
+    latency?: import('./latency').LatencyBreakdown;
+    image_url?: string;
+}
+export interface PushPayload {
+    source: 'octovise';
+    send_id: string;
+    campaign_id: string;
+    title: string;
+    body: string;
+    image_url?: string;
+    image_layout?: 'inline' | 'hero';
+    deep_link?: string;
+    channel_id?: string;
+    collapse_key?: string;
+}
+export declare function parsePushSendId(raw: unknown): number;

package/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePushSendId = parsePushSendId;
+function parsePushSendId(raw) {
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "1.0.0";

package/dist/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = '1.0.0';

package/ios/OctoviseNotificationExtension/NotificationService.swift

@@ -0,0 +1,128 @@
+/**
+ * Notification Service Extension for Octovise push notifications on iOS.
+ *
+ * This runs in a separate process (even when the app is killed) and has
+ * ~30 seconds to modify the notification before iOS displays it.
+ *
+ * Responsibilities:
+ * - Download the image and attach it as a media attachment
+ * - Track "received" event via POST /event
+ * - Only processes notifications where data.source == "octovise"
+ *
+ * Setup: the client adds this extension target to their Xcode project and
+ * sets the App Group so it can read the SDK config from shared UserDefaults.
+ */
+
+import UserNotifications
+
+class NotificationService: UNNotificationServiceExtension {
+
+    private var contentHandler: ((UNNotificationContent) -> Void)?
+    private var bestAttemptContent: UNMutableNotificationContent?
+
+    override func didReceive(
+        _ request: UNNotificationRequest,
+        withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
+    ) {
+        self.contentHandler = contentHandler
+        bestAttemptContent = request.content.mutableCopy() as? UNMutableNotificationContent
+
+        guard let content = bestAttemptContent,
+              let source = request.content.userInfo["source"] as? String,
+              source == "octovise" else {
+            // Not ours — pass through unmodified
+            contentHandler(request.content)
+            return
+        }
+
+        let userInfo = request.content.userInfo
+
+        // Track received (fire-and-forget)
+        trackReceived(userInfo: userInfo)
+
+        // Download and attach image
+        guard let imageUrlString = userInfo["image_url"] as? String,
+              let imageUrl = URL(string: imageUrlString) else {
+            contentHandler(content)
+            return
+        }
+
+        downloadImage(from: imageUrl) { attachment in
+            if let attachment = attachment {
+                content.attachments = [attachment]
+            }
+            contentHandler(content)
+        }
+    }
+
+    override func serviceExtensionTimeWillExpire() {
+        // iOS is about to kill us — deliver what we have
+        if let content = bestAttemptContent {
+            contentHandler?(content)
+        }
+    }
+
+    // MARK: - Image Download
+
+    private func downloadImage(from url: URL, completion: @escaping (UNNotificationAttachment?) -> Void) {
+        let task = URLSession.shared.downloadTask(with: url) { localUrl, response, error in
+            guard let localUrl = localUrl, error == nil else {
+                completion(nil)
+                return
+            }
+
+            // Move to a temp file with proper extension
+            let ext = url.pathExtension.isEmpty ? "jpg" : url.pathExtension
+            let tempUrl = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString)
+                .appendingPathExtension(ext)
+
+            do {
+                try FileManager.default.moveItem(at: localUrl, to: tempUrl)
+                let attachment = try UNNotificationAttachment(identifier: "octovise-image", url: tempUrl)
+                completion(attachment)
+            } catch {
+                completion(nil)
+            }
+        }
+        task.resume()
+    }
+
+    // MARK: - Event Tracking
+
+    private func trackReceived(userInfo: [AnyHashable: Any]) {
+        // Read SDK config from shared App Group UserDefaults
+        guard let defaults = UserDefaults(suiteName: "group.octovise.sdk"),
+              let baseUrl = defaults.string(forKey: "base_url"),
+              let apiKey = defaults.string(forKey: "api_key"),
+              let userId = defaults.string(forKey: "user_id"),
+              let sendIdStr = userInfo["send_id"] as? String,
+              let sendId = Int(sendIdStr) else {
+            return
+        }
+
+        let payload: [String: Any] = [
+            "user_id": userId,
+            "send_id": sendId,
+            "event": "received",
+            "meta": [
+                "device": "mobile",
+                "platform": "ios",
+            ],
+        ]
+
+        guard let url = URL(string: "\(baseUrl)/event"),
+              let body = try? JSONSerialization.data(withJSONObject: payload) else {
+            return
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
+        request.httpBody = body
+        request.timeoutInterval = 5
+
+        URLSession.shared.dataTask(with: request).resume()
+    }
+}

package/ios/OctoviseSDK/OctoPushModule.m

@@ -0,0 +1,6 @@
+// Objective-C bridge for RN to find the Swift module
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(OctoPushModule, NSObject)
+RCT_EXTERN_METHOD(configure:(NSString *)apiKey userId:(NSString *)userId baseUrl:(NSString *)baseUrl)
+@end

package/ios/OctoviseSDK/OctoPushModule.swift

@@ -0,0 +1,27 @@
+/**
+ * React Native bridge module for iOS.
+ * Persists SDK config to shared App Group UserDefaults so the
+ * Notification Service Extension can access them.
+ */
+
+import Foundation
+
+@objc(OctoPushModule)
+class OctoPushModule: NSObject {
+
+    @objc
+    func configure(_ apiKey: String, userId: String, baseUrl: String) {
+        guard let defaults = UserDefaults(suiteName: "group.octovise.sdk") else {
+            return
+        }
+        defaults.set(apiKey, forKey: "api_key")
+        defaults.set(userId, forKey: "user_id")
+        defaults.set(baseUrl, forKey: "base_url")
+        defaults.synchronize()
+    }
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@octovise/react-native-sdk",
+  "version": "1.0.0",
+  "description": "Octovise SDK for React Native — in-app messaging (push notifications in v1.1)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@react-native-firebase/messaging": ">=18",
+    "react": ">=18",
+    "react-native": ">=0.72",
+    "react-native-safe-area-context": ">=4"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-firebase/messaging": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/react-native": "^12.9.0",
+    "@types/jest": "^29.5.12",
+    "@types/react": "^18",
+    "jest": "^29.7.0",
+    "react": "^18",
+    "react-native": "^0.74",
+    "react-native-safe-area-context": "^5.8.0",
+    "react-test-renderer": "^18.2.0",
+    "ts-jest": "^29.1.5",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "dist/",
+    "android/",
+    "ios/",
+    "react-native.config.js",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maurogallardo-cell/octovise-react-native-sdk.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react-native",
+    "in-app-messaging",
+    "push-notifications",
+    "octovise",
+    "sdk"
+  ]
+}

package/react-native.config.js

@@ -0,0 +1,16 @@
+// Tell RN autolinking to skip the native (Android/iOS) modules for now.
+// The Kotlin/Swift sources in android/ and ios/ are intended to be built
+// as a proper RN native module in v2 (with build.gradle + podspec).
+//
+// For v1, the SDK is JS-only: in-app messaging works via fetch() + Modal/Animated.
+// Push notifications (which need the native modules) are disabled by default.
+// Setting platforms to null prevents autolinking from trying to compile
+// the Kotlin/Swift sources without a proper module setup.
+module.exports = {
+  dependency: {
+    platforms: {
+      android: null,
+      ios: null,
+    },
+  },
+}