react-native-edgee 1.0.0 → 1.0.1

package/dist/core/query-builder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+class QueryBuilder {
+    constructor(config, store) {
+        this.config = config;
+        this.store = store;
+    }
+    async getUrl() {
+        const { edgeeId, userId } = await this.store.getContext();
+        const params = [];
+        if (edgeeId)
+            params.push(`e=${encodeURIComponent(edgeeId)}`);
+        if (userId)
+            params.push(`u=${encodeURIComponent(userId)}`);
+        return params.length
+            ? `${this.config.host}/_edgee/csevent?${params.join("&")}`
+            : `${this.config.host}/_edgee/csevent`;
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/dist/core/queue.d.ts

@@ -0,0 +1,25 @@
+import { EdgeeConfig } from "..";
+import { EdgeeEvent } from "../api";
+import { EdgeeStore } from "./edgee-store";
+import { QueryBuilder } from "./query-builder";
+export declare class EventQueue {
+    private store;
+    private queryBuilder;
+    private config;
+    private q;
+    private ready;
+    private online;
+    private flushing;
+    private unsubscribe?;
+    constructor(store: EdgeeStore, config: EdgeeConfig, queryBuilder: QueryBuilder);
+    destroy(): void;
+    setReady(val: boolean): void;
+    enqueue(item: EdgeeEvent): void;
+    /**
+     * Send a direct payload (used for consent events)
+     * This bypasses the normal event structure and sends raw payload
+     */
+    sendEvent(payload: any): Promise<void>;
+    private shouldFlush;
+    flush(): Promise<void>;
+}

package/dist/core/queue.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueue = void 0;
+const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
+const api_1 = require("../api");
+class EventQueue {
+    constructor(store, config, queryBuilder) {
+        this.q = [];
+        this.ready = false;
+        this.online = false;
+        this.flushing = false;
+        this.store = store;
+        this.config = config;
+        this.queryBuilder = queryBuilder;
+        // Track connectivity
+        this.unsubscribe = netinfo_1.default.addEventListener((state) => {
+            this.online = !!state.isConnected && !!state.isInternetReachable;
+            if (this.shouldFlush())
+                void this.flush();
+        });
+        void netinfo_1.default.fetch().then((state) => {
+            this.online = !!state.isConnected && !!state.isInternetReachable;
+        });
+        void this.store.getPendingEvents().then((events) => {
+            this.q = events;
+            this.ready = true;
+        });
+    }
+    destroy() {
+        var _a;
+        (_a = this.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    setReady(val) {
+        this.ready = val;
+        if (this.shouldFlush())
+            void this.flush();
+    }
+    enqueue(item) {
+        this.q.push(item);
+        if (this.config.debug) {
+            // eslint-disable-next-line no-console
+            console.log("[Edgee RN] enqueue", item);
+        }
+        void this.store.addEvent(item);
+        if (this.shouldFlush())
+            void this.flush();
+    }
+    /**
+     * Send a direct payload (used for consent events)
+     * This bypasses the normal event structure and sends raw payload
+     */
+    async sendEvent(payload) {
+        if (!this.online) {
+            if (this.config.debug) {
+                console.log("[Edgee RN] Offline - queuing direct payload");
+            }
+            // For direct payloads, we can't easily queue them in the current structure
+            // So we'll send them when we come back online
+            return;
+        }
+        try {
+            const url = await this.queryBuilder.getUrl();
+            if (this.config.debug) {
+                console.log("[Edgee RN] sending direct payload", { url, payload });
+            }
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(this.config.debug ? { "Edgee-Debug": "true" } : {}),
+                },
+                body: JSON.stringify(payload),
+            });
+            const text = await response.text().catch(() => "");
+            if (this.config.debug) {
+                console.log("[Edgee RN] direct payload response", {
+                    status: response.status,
+                    ok: response.ok,
+                    body: text,
+                });
+            }
+            // Handle ID updates from response
+            try {
+                const data = text ? JSON.parse(text) : null;
+                if (data && (data.e || data.u)) {
+                    if (data.e)
+                        await this.store.setEdgeeId(data.e);
+                    if (data.u)
+                        await this.store.setUserId(data.u);
+                }
+            }
+            catch (e) {
+                if (this.config.debug)
+                    console.log("persist ids error", e);
+            }
+        }
+        catch (error) {
+            console.warn("[Edgee RN] Failed to send direct payload:", error);
+            throw error;
+        }
+    }
+    shouldFlush() {
+        return this.ready && this.online && this.q.length > 0;
+    }
+    async flush() {
+        if (this.flushing || !this.shouldFlush())
+            return;
+        this.flushing = true;
+        const items = [...this.q];
+        try {
+            for (const item of items) {
+                const url = await this.queryBuilder.getUrl();
+                const resp = await (0, api_1.uploadEvent)(url, this.config, item);
+                const text = await resp.text().catch(() => "");
+                if (this.config.debug) {
+                    // eslint-disable-next-line no-console
+                    console.log("[Edgee RN] response", {
+                        status: resp.status,
+                        ok: resp.ok,
+                        body: text,
+                    });
+                }
+                try {
+                    const data = text ? JSON.parse(text) : null;
+                    if (data && (data.e || data.u)) {
+                        if (data.e)
+                            await this.store.setEdgeeId(data.e);
+                        if (data.u)
+                            await this.store.setUserId(data.u);
+                    }
+                }
+                catch (e) {
+                    if (this.config.debug)
+                        console.log("persist ids error", e);
+                }
+            }
+            this.q = [];
+            await this.store.clearEvents();
+        }
+        catch (error) {
+            console.log("flush error", error);
+            this.q = [];
+            await this.store.clearEvents();
+        }
+        finally {
+            this.flushing = false;
+            if (this.shouldFlush())
+                void this.flush(); // Drain if new items arrived
+        }
+    }
+}
+exports.EventQueue = EventQueue;

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+export type ConsentStatus = "granted" | "denied" | "pending";
+export type EdgeeConfig = {
+    host: string;
+    debug?: boolean;
+    collectDeviceId?: boolean;
+};
+type Components = Record<string, boolean> | undefined;
+export declare class EdgeeClient {
+    private appState;
+    private store;
+    private queue;
+    private queryBuilder;
+    private appStateSubscription;
+    private config;
+    constructor(config: EdgeeConfig);
+    private handleAppStateChange;
+    track(name: string, data: object, components?: Components): Promise<void>;
+    user(data: object, components?: Components): Promise<void>;
+    screen(screenName: string, data: object, components?: Components): Promise<void>;
+    setConsent(status: ConsentStatus): Promise<void>;
+    getConsent(): ConsentStatus | null;
+    hasConsent(): boolean;
+    canTrack(): boolean;
+    resetConsent(): Promise<void>;
+    onConsentChange(callback: (status: ConsentStatus | null) => void): () => void;
+    /**
+     * Send consent event directly to Edgee (matches web SDK format)
+     */
+    consent(status: ConsentStatus): Promise<void>;
+}
+export * as navigation from "./navigation";
+export { EdgeeAutoTracker, EdgeeProvider, useEdgee, useEdgeeConsent, } from "./react";
+export type { EdgeeClientContext, EdgeeFullContext, EdgeePageContext, } from "./core/context";
+export { clearContextCache, getNativeContext, isNativeModuleAvailable, } from "./native-context";
+export type { EdgeeNativeContext, EdgeeNativeContextConfig, EdgeeReactNativeModule, } from "./types";
+export { ConsentUtils, EdgeeConsent, edgeeConsent } from "./consent";

package/dist/index.js

@@ -0,0 +1,321 @@
+"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.edgeeConsent = exports.EdgeeConsent = exports.ConsentUtils = exports.isNativeModuleAvailable = exports.getNativeContext = exports.clearContextCache = exports.useEdgeeConsent = exports.useEdgee = exports.EdgeeProvider = exports.EdgeeAutoTracker = exports.navigation = exports.EdgeeClient = void 0;
+const react_native_1 = require("react-native");
+const api_1 = require("./api");
+const consent_1 = require("./consent");
+const context_1 = require("./core/context");
+const edgee_store_1 = require("./core/edgee-store");
+const query_builder_1 = require("./core/query-builder");
+const queue_1 = require("./core/queue");
+const native_context_1 = require("./native-context");
+/**
+ * Extract native context properties to include in event data under a sub-object
+ */
+const extractNativeProperties = (nativeContext) => {
+    if (!nativeContext)
+        return {};
+    return {
+        native_context: {
+            // Device information
+            device_id: nativeContext.deviceId,
+            device_name: nativeContext.deviceName,
+            device_type: nativeContext.deviceType,
+            manufacturer: nativeContext.manufacturer,
+            model: nativeContext.model,
+            // System information
+            os_name: nativeContext.osName,
+            os_version: nativeContext.osVersion,
+            // App information
+            app_name: nativeContext.appName,
+            app_version: nativeContext.appVersion,
+            build_number: nativeContext.buildNumber,
+            bundle_id: nativeContext.bundleId,
+            // Hardware capabilities
+            is_tablet: nativeContext.isTablet,
+            is_simulator: nativeContext.isSimulator,
+            is_emulator: nativeContext.isEmulator,
+            is_rooted: nativeContext.isRooted,
+            is_jailbroken: nativeContext.isJailbroken,
+            // System metrics
+            total_memory_mb: nativeContext.totalMemoryMB,
+            free_memory_mb: nativeContext.freeMemoryMB,
+            max_memory_mb: nativeContext.maxMemoryMB,
+            used_memory_mb: nativeContext.usedMemoryMB,
+            available_memory_mb: nativeContext.availableMemoryMB,
+            free_storage_mb: nativeContext.freeStorageMB,
+            total_storage_mb: nativeContext.totalStorageMB,
+            used_storage_mb: nativeContext.usedStorageMB,
+            battery_level: nativeContext.batteryLevel,
+            battery_state: nativeContext.batteryState,
+            system_uptime: nativeContext.systemUptime,
+            low_power_mode: nativeContext.lowPowerMode,
+            // Network information
+            network_type: nativeContext.networkType,
+            carrier_name: nativeContext.carrierName,
+            radio_technology: nativeContext.radioTechnology,
+            // Locale information
+            locale: nativeContext.locale,
+            language: nativeContext.language,
+            country: nativeContext.country,
+            timezone: nativeContext.timezone,
+            // Privacy information
+            advertising_id: nativeContext.advertisingId,
+            ad_tracking_enabled: nativeContext.adTrackingEnabled,
+            tracking_status: nativeContext.trackingStatus,
+            // Additional information
+            user_agent: nativeContext.userAgent,
+            first_install_time: nativeContext.firstInstallTime,
+            last_update_time: nativeContext.lastUpdateTime,
+        },
+    };
+};
+let initialized = false;
+let config = null;
+const STORAGE_KEYS = {
+    edgeeId: "_edgee",
+    userId: "_edgee_u",
+};
+class EdgeeClient {
+    constructor(config) {
+        // current app state
+        this.appState = "unknown";
+        this.appStateSubscription = null;
+        this.handleAppStateChange = (nextAppState) => {
+            if (["inactive", "background"].includes(this.appState) &&
+                nextAppState === "active") {
+                this.track("application_opened", {
+                    from_background: true,
+                });
+            }
+            else if ((this.appState === "active" || this.appState === "unknown") && // Check if appState is 'active' or 'unknown'
+                ["inactive", "background"].includes(nextAppState)) {
+                // Check if next app state is 'inactive' or 'background'
+                this.track("application_backgrounded", {});
+            }
+            this.appState = nextAppState;
+        };
+        this.config = config;
+        this.store = new edgee_store_1.EdgeeStore();
+        void this.store.init();
+        this.queryBuilder = new query_builder_1.QueryBuilder(config, this.store);
+        this.queue = new queue_1.EventQueue(this.store, config, this.queryBuilder);
+        this.appStateSubscription = react_native_1.AppState.addEventListener("change", this.handleAppStateChange);
+        // Initialize consent system
+        void consent_1.ConsentUtils.init();
+    }
+    async track(name, data, components) {
+        // Check consent before tracking
+        if (!consent_1.ConsentUtils.canTrack()) {
+            if (this.config.debug) {
+                console.log(`[Edgee] Event "${name}" not tracked - consent not granted`);
+            }
+            return;
+        }
+        const context = await (0, context_1.getContext)(this.config.collectDeviceId);
+        // Get native context properties if available and collectDeviceId is enabled
+        let nativeProperties = {};
+        if (this.config.collectDeviceId && (0, native_context_1.isNativeModuleAvailable)()) {
+            try {
+                const nativeContext = await (0, native_context_1.getNativeContext)({
+                    collectDeviceId: this.config.collectDeviceId,
+                });
+                nativeProperties = extractNativeProperties(nativeContext);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.warn("[Edgee] Failed to get native context for event properties:", error);
+                }
+            }
+        }
+        // Merge native properties with event data
+        const enhancedData = {
+            ...data,
+            ...nativeProperties,
+        };
+        const event = (0, api_1.createTrackEvent)({
+            name,
+            data: enhancedData,
+            components,
+            context,
+        });
+        this.queue.enqueue(event);
+    }
+    async user(data, components) {
+        // Check consent before tracking
+        if (!consent_1.ConsentUtils.canTrack()) {
+            if (this.config.debug) {
+                console.log(`[Edgee] User event not tracked - consent not granted`);
+            }
+            return;
+        }
+        const context = await (0, context_1.getContext)(this.config.collectDeviceId);
+        // Get native context properties if available and collectDeviceId is enabled
+        let nativeProperties = {};
+        if (this.config.collectDeviceId && (0, native_context_1.isNativeModuleAvailable)()) {
+            try {
+                const nativeContext = await (0, native_context_1.getNativeContext)({
+                    collectDeviceId: this.config.collectDeviceId,
+                });
+                nativeProperties = extractNativeProperties(nativeContext);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.warn("[Edgee] Failed to get native context for user properties:", error);
+                }
+            }
+        }
+        // Merge native properties with user data
+        const enhancedData = {
+            ...data,
+            ...nativeProperties,
+        };
+        const event = (0, api_1.createUserEvent)({
+            data: enhancedData,
+            components,
+            context,
+        });
+        this.queue.enqueue(event);
+    }
+    async screen(screenName, data, components) {
+        // Check consent before tracking
+        if (!consent_1.ConsentUtils.canTrack()) {
+            if (this.config.debug) {
+                console.log(`[Edgee] Screen "${screenName}" not tracked - consent not granted`);
+            }
+            return;
+        }
+        const context = await (0, context_1.getContext)(this.config.collectDeviceId);
+        // Get native context properties if available and collectDeviceId is enabled
+        let nativeProperties = {};
+        if (this.config.collectDeviceId && (0, native_context_1.isNativeModuleAvailable)()) {
+            try {
+                const nativeContext = await (0, native_context_1.getNativeContext)({
+                    collectDeviceId: this.config.collectDeviceId,
+                });
+                nativeProperties = extractNativeProperties(nativeContext);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.warn("[Edgee] Failed to get native context for screen properties:", error);
+                }
+            }
+        }
+        // Merge native properties with screen data
+        const enhancedData = {
+            ...data,
+            screen_name: screenName,
+            ...nativeProperties,
+        };
+        const event = (0, api_1.createTrackEvent)({
+            name: "screen",
+            data: enhancedData,
+            components,
+            context,
+        });
+        this.queue.enqueue(event);
+    }
+    // Consent management methods
+    async setConsent(status) {
+        await consent_1.ConsentUtils.setConsent(status);
+        // Send consent event to server
+        await consent_1.ConsentUtils.sendConsentEvent(this, status);
+        if (this.config.debug) {
+            console.log(`[Edgee] Consent set to: ${status}`);
+        }
+    }
+    getConsent() {
+        return consent_1.ConsentUtils.getConsent();
+    }
+    hasConsent() {
+        return consent_1.ConsentUtils.hasConsent();
+    }
+    canTrack() {
+        return consent_1.ConsentUtils.canTrack();
+    }
+    async resetConsent() {
+        await consent_1.ConsentUtils.reset();
+        if (this.config.debug) {
+            console.log(`[Edgee] Consent reset`);
+        }
+    }
+    onConsentChange(callback) {
+        return consent_1.ConsentUtils.onChange(callback);
+    }
+    /**
+     * Send consent event directly to Edgee (matches web SDK format)
+     */
+    async consent(status) {
+        // Validate consent status
+        if (!["granted", "denied", "pending"].includes(status)) {
+            throw new Error(`Invalid consent: ${status}. Use 'granted', 'denied', or 'pending'`);
+        }
+        // Store consent locally
+        await consent_1.ConsentUtils.setConsent(status);
+        // Send consent event using web SDK format
+        const payload = {
+            data_collection: {
+                consent: status,
+            },
+        };
+        try {
+            await this.queue.sendEvent(payload);
+            if (this.config.debug) {
+                console.log(`[Edgee] Consent sent to server: ${status}`);
+            }
+        }
+        catch (error) {
+            console.warn("[Edgee] Failed to send consent event:", error);
+            throw error;
+        }
+    }
+}
+exports.EdgeeClient = EdgeeClient;
+exports.navigation = __importStar(require("./navigation"));
+var react_1 = require("./react");
+Object.defineProperty(exports, "EdgeeAutoTracker", { enumerable: true, get: function () { return react_1.EdgeeAutoTracker; } });
+Object.defineProperty(exports, "EdgeeProvider", { enumerable: true, get: function () { return react_1.EdgeeProvider; } });
+Object.defineProperty(exports, "useEdgee", { enumerable: true, get: function () { return react_1.useEdgee; } });
+Object.defineProperty(exports, "useEdgeeConsent", { enumerable: true, get: function () { return react_1.useEdgeeConsent; } });
+var native_context_2 = require("./native-context");
+Object.defineProperty(exports, "clearContextCache", { enumerable: true, get: function () { return native_context_2.clearContextCache; } });
+Object.defineProperty(exports, "getNativeContext", { enumerable: true, get: function () { return native_context_2.getNativeContext; } });
+Object.defineProperty(exports, "isNativeModuleAvailable", { enumerable: true, get: function () { return native_context_2.isNativeModuleAvailable; } });
+// Export consent functionality
+var consent_2 = require("./consent");
+Object.defineProperty(exports, "ConsentUtils", { enumerable: true, get: function () { return consent_2.ConsentUtils; } });
+Object.defineProperty(exports, "EdgeeConsent", { enumerable: true, get: function () { return consent_2.EdgeeConsent; } });
+Object.defineProperty(exports, "edgeeConsent", { enumerable: true, get: function () { return consent_2.edgeeConsent; } });

package/dist/native-context.d.ts

@@ -0,0 +1,13 @@
+import type { EdgeeNativeContext, EdgeeNativeContextConfig } from "./types";
+/**
+ * Get comprehensive device and app context from native modules
+ */
+export declare function getNativeContext(config?: EdgeeNativeContextConfig): Promise<EdgeeNativeContext>;
+/**
+ * Clear cached context (useful for testing or when context might change)
+ */
+export declare function clearContextCache(): void;
+/**
+ * Check if native module is available
+ */
+export declare function isNativeModuleAvailable(): boolean;

package/dist/native-context.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeContext = getNativeContext;
+exports.clearContextCache = clearContextCache;
+exports.isNativeModuleAvailable = isNativeModuleAvailable;
+const react_native_1 = require("react-native");
+const LINKING_ERROR = `The package 'react-native-edgee' doesn't seem to be linked. Make sure: \n\n` +
+    react_native_1.Platform.select({ ios: "- You have run 'pod install'\n", default: "" }) +
+    "- You rebuilt the app after installing the package\n" +
+    "- You are not using Expo managed workflow\n";
+const EdgeeReactNative = react_native_1.NativeModules.EdgeeReactNative
+    ? react_native_1.NativeModules.EdgeeReactNative
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+let cachedContext = null;
+let contextPromise = null;
+/**
+ * Get comprehensive device and app context from native modules
+ */
+async function getNativeContext(config = {}) {
+    // Return cached context if available and no device ID collection requested
+    if (cachedContext && !config.collectDeviceId) {
+        return cachedContext;
+    }
+    // Return ongoing promise if one exists
+    if (contextPromise) {
+        return contextPromise;
+    }
+    contextPromise = EdgeeReactNative.getContextInfo(config)
+        .then((context) => {
+        // Cache context if no sensitive data (device ID) was requested
+        if (!config.collectDeviceId) {
+            cachedContext = context;
+        }
+        contextPromise = null;
+        return context;
+    })
+        .catch((error) => {
+        contextPromise = null;
+        console.warn("Failed to get native context:", error);
+        // Return fallback context
+        return getFallbackContext();
+    });
+    return contextPromise;
+}
+/**
+ * Get fallback context when native module is not available
+ */
+function getFallbackContext() {
+    const { width, height } = require("react-native").Dimensions.get("window");
+    const { scale } = require("react-native").PixelRatio.get();
+    return {
+        // App information
+        appName: "Unknown App",
+        appVersion: "1.0.0",
+        buildNumber: "1",
+        bundleId: "com.unknown.app",
+        // Device information
+        deviceName: react_native_1.Platform.OS === "ios" ? "iPhone" : "Android Device",
+        deviceType: react_native_1.Platform.OS,
+        manufacturer: react_native_1.Platform.OS === "ios" ? "Apple" : "Unknown",
+        model: "Unknown",
+        // System information
+        osName: react_native_1.Platform.OS === "ios" ? "iOS" : "Android",
+        osVersion: react_native_1.Platform.Version.toString(),
+        // Locale and timezone
+        locale: "en-US",
+        language: "en",
+        country: "US",
+        timezone: "America/New_York",
+        // Screen information
+        screenWidth: Math.round(width * scale),
+        screenHeight: Math.round(height * scale),
+        screenDensity: scale,
+        // Network information
+        networkType: "unknown",
+        // Hardware capabilities
+        isTablet: false,
+        // System metrics
+        totalMemoryMB: 0,
+        // Privacy information
+        adTrackingEnabled: false,
+        trackingStatus: "unknown",
+    };
+}
+/**
+ * Clear cached context (useful for testing or when context might change)
+ */
+function clearContextCache() {
+    cachedContext = null;
+    contextPromise = null;
+}
+/**
+ * Check if native module is available
+ */
+function isNativeModuleAvailable() {
+    try {
+        return !!react_native_1.NativeModules.EdgeeReactNative;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/navigation/expo-router.d.ts

@@ -0,0 +1,4 @@
+import type { EdgeeClient } from "../index";
+export declare function EdgeeExpoRouterTracker({ edgee, }: {
+    edgee: Pick<EdgeeClient, "screen">;
+}): null;