react-native-edgee 1.0.0 → 1.0.2

package/README.md

@@ -423,5 +423,4 @@ MIT
 ## 🆘 Support
 
 - **Issues**: [GitHub Issues](https://github.com/edgee-cloud/react-native-edgee/issues)
-- **Documentation**: [Edgee Docs](https://docs.edgee.cloud)
-- **Community**: [Edgee Discord](https://discord.gg/edgee)
+- **Documentation**: [Edgee Docs](https://docs.edgee.cloud)

package/dist/api.d.ts

@@ -0,0 +1,32 @@
+import { EdgeeConfig } from ".";
+import type { EdgeeFullContext } from "./core/context";
+declare enum EventType {
+    Track = "track",
+    User = "user",
+    Screen = "screen"
+}
+export type EdgeeTrackEvent = {
+    type: EventType.Track;
+    name: string;
+    components: Record<string, boolean> | undefined;
+    data: object;
+    context: EdgeeFullContext;
+};
+export type EdgeeUserEvent = {
+    type: EventType.User;
+    data: object;
+    components: Record<string, boolean> | undefined;
+    context: EdgeeFullContext;
+};
+export type EdgeeScreenEvent = {
+    type: EventType.Screen;
+    name: string;
+    data: object;
+    components: Record<string, boolean> | undefined;
+    context: EdgeeFullContext;
+};
+export type EdgeeEvent = EdgeeTrackEvent | EdgeeUserEvent | EdgeeScreenEvent;
+export declare const createTrackEvent: (params: Omit<EdgeeTrackEvent, "type">) => EdgeeTrackEvent;
+export declare const createUserEvent: (params: Omit<EdgeeUserEvent, "type">) => EdgeeUserEvent;
+export declare const uploadEvent: (url: string, config: EdgeeConfig, event: EdgeeEvent) => Promise<Response>;
+export {};

package/dist/api.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadEvent = exports.createUserEvent = exports.createTrackEvent = void 0;
+var EventType;
+(function (EventType) {
+    EventType["Track"] = "track";
+    EventType["User"] = "user";
+    EventType["Screen"] = "screen";
+})(EventType || (EventType = {}));
+const createTrackEvent = (params) => {
+    return {
+        type: EventType.Track,
+        ...params,
+    };
+};
+exports.createTrackEvent = createTrackEvent;
+const createUserEvent = (params) => {
+    return {
+        type: EventType.User,
+        ...params,
+    };
+};
+exports.createUserEvent = createUserEvent;
+const uploadEvent = async (url, config, event) => {
+    const eventToSend = event;
+    if (eventToSend.type === "track") {
+        const event = {
+            data_collection: {
+                context: eventToSend.context,
+                events: [
+                    {
+                        type: "track",
+                        data: {
+                            name: eventToSend.name,
+                            properties: eventToSend.data,
+                        },
+                        components: eventToSend.components,
+                    },
+                ],
+            },
+        };
+        if (config.debug) {
+            // eslint-disable-next-line no-console
+            console.log("[Edgee RN] sending", { url, event });
+        }
+        return await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
+            },
+            body: JSON.stringify(event),
+        });
+    }
+    else if (eventToSend.type === "user") {
+        const event = {
+            data_collection: {
+                context: eventToSend.context,
+                events: [
+                    {
+                        type: "user",
+                        data: eventToSend.data,
+                        components: eventToSend.components,
+                    },
+                ],
+            },
+        };
+        if (config.debug) {
+            // eslint-disable-next-line no-console
+            console.log("[Edgee RN] sending", { url, event });
+        }
+        return await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
+            },
+            body: JSON.stringify(event),
+        });
+    }
+    else if (eventToSend.type === "screen") {
+        const event = {
+            data_collection: {
+                context: eventToSend.context,
+                events: [
+                    {
+                        type: "track",
+                        data: { ...eventToSend.data, screen_name: eventToSend.name },
+                        components: eventToSend.components,
+                    },
+                ],
+            },
+        };
+        if (config.debug) {
+            // eslint-disable-next-line no-console
+            console.log("[Edgee RN] sending", { url, event });
+        }
+        return await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
+            },
+            body: JSON.stringify(event),
+        });
+    }
+    else {
+        throw new Error("Invalid event type");
+    }
+};
+exports.uploadEvent = uploadEvent;

package/dist/consent.d.ts

@@ -0,0 +1,96 @@
+import type { ConsentStatus } from "./index";
+/**
+ * Simple consent manager that works with existing EdgeeClient
+ * Stores consent status and provides utilities for consent management
+ */
+export declare class EdgeeConsent {
+    private consentStatus;
+    private initialized;
+    private onChangeCallbacks;
+    /**
+     * Initialize and load stored consent
+     */
+    init(): Promise<void>;
+    /**
+     * Set consent status
+     */
+    setConsent(status: ConsentStatus): Promise<void>;
+    /**
+     * Get current consent status
+     */
+    getConsent(): ConsentStatus | null;
+    /**
+     * Check if consent has been set
+     */
+    hasConsent(): boolean;
+    /**
+     * Check if consent is granted
+     */
+    isGranted(): boolean;
+    /**
+     * Check if consent is denied
+     */
+    isDenied(): boolean;
+    /**
+     * Check if consent is pending
+     */
+    isPending(): boolean;
+    /**
+     * Check if we should allow tracking
+     */
+    canTrack(): boolean;
+    /**
+     * Listen for consent changes
+     */
+    onChange(callback: (status: ConsentStatus | null) => void): () => void;
+    /**
+     * Reset consent (remove stored value)
+     */
+    reset(): Promise<void>;
+    private isValidStatus;
+}
+/**
+ * Global consent instance
+ * This allows you to manage consent across your app without passing it around
+ */
+export declare const edgeeConsent: EdgeeConsent;
+/**
+ * Consent utilities
+ */
+export declare const ConsentUtils: {
+    /**
+     * Initialize consent (call this once in your app)
+     */
+    init(): Promise<void>;
+    /**
+     * Set consent status
+     */
+    setConsent(status: ConsentStatus): Promise<void>;
+    /**
+     * Get current consent
+     */
+    getConsent(): ConsentStatus | null;
+    /**
+     * Check if can track
+     */
+    canTrack(): boolean;
+    /**
+     * Check consent status
+     */
+    hasConsent(): boolean;
+    isGranted(): boolean;
+    isDenied(): boolean;
+    isPending(): boolean;
+    /**
+     * Listen for changes
+     */
+    onChange(callback: (status: ConsentStatus | null) => void): () => void;
+    /**
+     * Reset consent
+     */
+    reset(): Promise<void>;
+    /**
+     * Send consent event to Edgee using the new consent method
+     */
+    sendConsentEvent(edgeeClient: any, status: ConsentStatus): Promise<void>;
+};

package/dist/consent.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentUtils = exports.edgeeConsent = exports.EdgeeConsent = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const CONSENT_STORAGE_KEY = "_edgee_consent";
+/**
+ * Simple consent manager that works with existing EdgeeClient
+ * Stores consent status and provides utilities for consent management
+ */
+class EdgeeConsent {
+    constructor() {
+        this.consentStatus = null;
+        this.initialized = false;
+        this.onChangeCallbacks = [];
+    }
+    /**
+     * Initialize and load stored consent
+     */
+    async init() {
+        // Prevent multiple initializations
+        if (this.initialized) {
+            return;
+        }
+        try {
+            const stored = await async_storage_1.default.getItem(CONSENT_STORAGE_KEY);
+            if (stored && this.isValidStatus(stored)) {
+                this.consentStatus = stored;
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            console.warn("[Edgee Consent] Failed to load:", error);
+            this.initialized = true;
+        }
+    }
+    /**
+     * Set consent status
+     */
+    async setConsent(status) {
+        if (!this.isValidStatus(status)) {
+            throw new Error(`Invalid consent: ${status}. Use 'granted', 'denied', or 'pending'`);
+        }
+        this.consentStatus = status;
+        try {
+            await async_storage_1.default.setItem(CONSENT_STORAGE_KEY, status);
+            // Notify callbacks
+            this.onChangeCallbacks.forEach((callback) => {
+                try {
+                    callback(status);
+                }
+                catch (error) {
+                    console.warn("[Edgee Consent] Callback error:", error);
+                }
+            });
+        }
+        catch (error) {
+            console.warn("[Edgee Consent] Failed to store:", error);
+        }
+    }
+    /**
+     * Get current consent status
+     */
+    getConsent() {
+        return this.consentStatus;
+    }
+    /**
+     * Check if consent has been set
+     */
+    hasConsent() {
+        return this.consentStatus !== null;
+    }
+    /**
+     * Check if consent is granted
+     */
+    isGranted() {
+        return this.consentStatus === "granted";
+    }
+    /**
+     * Check if consent is denied
+     */
+    isDenied() {
+        return this.consentStatus === "denied";
+    }
+    /**
+     * Check if consent is pending
+     */
+    isPending() {
+        return this.consentStatus === "pending";
+    }
+    /**
+     * Check if we should allow tracking
+     */
+    canTrack() {
+        return this.initialized && this.consentStatus === "granted";
+    }
+    /**
+     * Listen for consent changes
+     */
+    onChange(callback) {
+        this.onChangeCallbacks.push(callback);
+        // Return unsubscribe function
+        return () => {
+            const index = this.onChangeCallbacks.indexOf(callback);
+            if (index > -1) {
+                this.onChangeCallbacks.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Reset consent (remove stored value)
+     */
+    async reset() {
+        this.consentStatus = null;
+        try {
+            await async_storage_1.default.removeItem(CONSENT_STORAGE_KEY);
+            // Notify callbacks
+            this.onChangeCallbacks.forEach((callback) => {
+                try {
+                    callback(null);
+                }
+                catch (error) {
+                    console.warn("[Edgee Consent] Callback error:", error);
+                }
+            });
+        }
+        catch (error) {
+            console.warn("[Edgee Consent] Failed to clear:", error);
+        }
+    }
+    isValidStatus(status) {
+        return (typeof status === "string" &&
+            ["granted", "denied", "pending"].includes(status));
+    }
+}
+exports.EdgeeConsent = EdgeeConsent;
+/**
+ * Global consent instance
+ * This allows you to manage consent across your app without passing it around
+ */
+exports.edgeeConsent = new EdgeeConsent();
+/**
+ * Consent utilities
+ */
+exports.ConsentUtils = {
+    /**
+     * Initialize consent (call this once in your app)
+     */
+    async init() {
+        return exports.edgeeConsent.init();
+    },
+    /**
+     * Set consent status
+     */
+    async setConsent(status) {
+        return exports.edgeeConsent.setConsent(status);
+    },
+    /**
+     * Get current consent
+     */
+    getConsent() {
+        return exports.edgeeConsent.getConsent();
+    },
+    /**
+     * Check if can track
+     */
+    canTrack() {
+        return exports.edgeeConsent.canTrack();
+    },
+    /**
+     * Check consent status
+     */
+    hasConsent() {
+        return exports.edgeeConsent.hasConsent();
+    },
+    isGranted() {
+        return exports.edgeeConsent.isGranted();
+    },
+    isDenied() {
+        return exports.edgeeConsent.isDenied();
+    },
+    isPending() {
+        return exports.edgeeConsent.isPending();
+    },
+    /**
+     * Listen for changes
+     */
+    onChange(callback) {
+        return exports.edgeeConsent.onChange(callback);
+    },
+    /**
+     * Reset consent
+     */
+    async reset() {
+        return exports.edgeeConsent.reset();
+    },
+    /**
+     * Send consent event to Edgee using the new consent method
+     */
+    async sendConsentEvent(edgeeClient, status) {
+        try {
+            // Use the new consent method if available
+            if (edgeeClient.consent) {
+                await edgeeClient.consent(status);
+            }
+            else {
+                // Fallback: use track event with special consent flag
+                await edgeeClient.track("_consent_update", {
+                    consent_status: status,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        catch (error) {
+            console.warn("[Edgee Consent] Failed to send consent event:", error);
+        }
+    },
+};

package/dist/core/context.d.ts

@@ -0,0 +1,41 @@
+export interface EdgeeClientContext {
+    screen_width: number;
+    screen_height: number;
+    screen_density: number;
+    platform: string;
+    app_name?: string;
+    app_version?: string;
+    build_number?: string;
+    bundle_id?: string;
+    device_name?: string;
+    device_type?: string;
+    manufacturer?: string;
+    model?: string;
+    os_name?: string;
+    os_version?: string;
+    locale?: string;
+    language?: string;
+    country?: string;
+    timezone?: string;
+    network_type?: string;
+    carrier_name?: string;
+    is_tablet?: boolean;
+    is_simulator?: boolean;
+    is_emulator?: boolean;
+    total_memory_mb?: number;
+    battery_level?: number;
+    ad_tracking_enabled?: boolean;
+}
+export interface EdgeePageContext {
+    title: string;
+    path: string;
+    url: string | undefined;
+}
+export interface EdgeeFullContext {
+    client: EdgeeClientContext;
+    page: EdgeePageContext;
+}
+/**
+ * Get comprehensive context including native device information
+ */
+export declare const getContext: (collectDeviceId?: boolean) => Promise<EdgeeFullContext>;

package/dist/core/context.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContext = void 0;
+const react_native_1 = require("react-native");
+const native_context_1 = require("../native-context");
+/**
+ * Get comprehensive context including native device information
+ */
+const getContext = async (collectDeviceId = false) => {
+    var _a;
+    const url = (_a = (await react_native_1.Linking.getInitialURL())) !== null && _a !== void 0 ? _a : undefined;
+    let clientContext;
+    if ((0, native_context_1.isNativeModuleAvailable)()) {
+        try {
+            const nativeContext = await (0, native_context_1.getNativeContext)({ collectDeviceId });
+            clientContext = buildClientContextFromNative(nativeContext);
+        }
+        catch (error) {
+            console.warn("Failed to get native context, falling back to basic context:", error);
+            clientContext = getFallbackClientContext();
+        }
+    }
+    else {
+        clientContext = getFallbackClientContext();
+    }
+    return {
+        client: clientContext,
+        page: {
+            title: "Home",
+            path: "/",
+            url,
+        },
+    };
+};
+exports.getContext = getContext;
+/**
+ * Build client context from native context data
+ */
+function buildClientContextFromNative(nativeContext) {
+    return {
+        // Core screen information (always available)
+        screen_width: nativeContext.screenWidth,
+        screen_height: nativeContext.screenHeight,
+        screen_density: nativeContext.screenDensity,
+        platform: nativeContext.deviceType,
+        // Extended app information
+        app_name: nativeContext.appName,
+        app_version: nativeContext.appVersion,
+        build_number: nativeContext.buildNumber,
+        bundle_id: nativeContext.bundleId,
+        // Device information
+        device_name: nativeContext.deviceName,
+        device_type: nativeContext.deviceType,
+        manufacturer: nativeContext.manufacturer,
+        model: nativeContext.model,
+        // System information
+        os_name: nativeContext.osName,
+        os_version: nativeContext.osVersion,
+        // Locale information
+        locale: nativeContext.locale,
+        language: nativeContext.language,
+        country: nativeContext.country,
+        timezone: nativeContext.timezone,
+        // Network information
+        network_type: nativeContext.networkType,
+        carrier_name: nativeContext.carrierName,
+        // Hardware capabilities
+        is_tablet: nativeContext.isTablet,
+        is_simulator: nativeContext.isSimulator,
+        is_emulator: nativeContext.isEmulator,
+        // System metrics
+        total_memory_mb: nativeContext.totalMemoryMB,
+        battery_level: nativeContext.batteryLevel,
+        // Privacy information
+        ad_tracking_enabled: nativeContext.adTrackingEnabled,
+    };
+}
+/**
+ * Get fallback client context when native module is not available
+ */
+function getFallbackClientContext() {
+    const { width, height } = react_native_1.Dimensions.get("window");
+    const density = react_native_1.PixelRatio.get();
+    return {
+        screen_width: width,
+        screen_height: height,
+        screen_density: density,
+        platform: react_native_1.Platform.OS,
+    };
+}

package/dist/core/edgee-store.d.ts

@@ -0,0 +1,21 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { EdgeeEvent } from "../api";
+export declare class EdgeeStore {
+    edgeeId: string | null;
+    userId: string | null;
+    store: typeof AsyncStorage;
+    pendingEvents: EdgeeEvent[];
+    constructor();
+    init(): Promise<void>;
+    getEdgeeId(): Promise<string | null>;
+    getUserId(): Promise<string | null>;
+    setEdgeeId(edgeeId: string): Promise<void>;
+    setUserId(userId: string): Promise<void>;
+    getContext(): Promise<{
+        edgeeId: string | null;
+        userId: string | null;
+    }>;
+    addEvent(event: EdgeeEvent): Promise<void>;
+    getPendingEvents(): Promise<EdgeeEvent[]>;
+    clearEvents(): Promise<void>;
+}

package/dist/core/edgee-store.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeeStore = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+class EdgeeStore {
+    constructor() {
+        this.store = async_storage_1.default;
+        this.pendingEvents = [];
+        this.edgeeId = null;
+        this.userId = null;
+    }
+    async init() {
+        var _a, _b, _c;
+        this.edgeeId = (_a = (await this.store.getItem("_edgee"))) !== null && _a !== void 0 ? _a : "";
+        this.userId = (_b = (await this.store.getItem("_edgee_u"))) !== null && _b !== void 0 ? _b : "";
+        this.pendingEvents = JSON.parse((_c = (await this.store.getItem("_edgee_events"))) !== null && _c !== void 0 ? _c : "[]");
+    }
+    async getEdgeeId() {
+        return this.edgeeId;
+    }
+    async getUserId() {
+        return this.userId;
+    }
+    async setEdgeeId(edgeeId) {
+        this.edgeeId = edgeeId;
+        await this.store.setItem("_edgee", edgeeId);
+    }
+    async setUserId(userId) {
+        this.userId = userId;
+        await this.store.setItem("_edgee_u", userId);
+    }
+    async getContext() {
+        return {
+            edgeeId: this.edgeeId,
+            userId: this.userId,
+        };
+    }
+    async addEvent(event) {
+        this.pendingEvents.push(event);
+        await this.store.setItem("_edgee_events", JSON.stringify(this.pendingEvents));
+    }
+    async getPendingEvents() {
+        return this.pendingEvents;
+    }
+    async clearEvents() {
+        this.pendingEvents = [];
+        await this.store.removeItem("_edgee_events");
+    }
+}
+exports.EdgeeStore = EdgeeStore;

package/dist/core/query-builder.d.ts

@@ -0,0 +1,8 @@
+import { EdgeeConfig } from "..";
+import { EdgeeStore } from "./edgee-store";
+export declare class QueryBuilder {
+    private config;
+    private store;
+    constructor(config: EdgeeConfig, store: EdgeeStore);
+    getUrl(): Promise<string>;
+}