@openreplay/tracker 17.0.1 → 17.1.0

package/dist/cjs/entry.js

@@ -3894,12 +3894,12 @@ function getInlineOptions(mode, logger) {
         case InlineCssMode.Unset:
             const isLocalhost = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?/.test(window.location.href);
             if (isLocalhost) {
-                logger(`Enabling InlineCssMode by default on localhost to preserve css styles, refer to ${localhostStylesDoc} for details, set InlineCssMode to 0 to skip this behavior`);
+                logger(`Enabling InlineCssMode.PlainFetched by default on localhost to preserve css styles, refer to ${localhostStylesDoc} for details, set InlineCssMode to 0 to skip this behavior`);
                 return {
                     inlineRemoteCss: true,
                     inlinerOptions: {
-                        forceFetch: false,
-                        forcePlain: false,
+                        forceFetch: true,
+                        forcePlain: true,
                     },
                 };
             }
@@ -4383,6 +4383,9 @@ const proto = {
     startIframe: 'start tracker inside frame',
     // checking updates
     polling: 'hello-how-are-you-im-under-the-water-please-help-me',
+    // happens if tab is old and has outdated token but
+    // not communicating with backend to update it (for whatever reason)
+    reset: 'reset-your-session-please',
 };
 class App {
     constructor(projectKey, sessionToken, options, signalError, insideIframe) {
@@ -4399,7 +4402,7 @@ class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '17.0.1'; // TODO: version compatability check inside each plugin.
+        this.version = '17.1.0'; // TODO: version compatability check inside each plugin.
         this.socketMode = false;
         this.compressionThreshold = 24 * 1000;
         this.bc = null;
@@ -4633,6 +4636,19 @@ class App {
             }
         };
         this.startTimeout = null;
+        this.restart = () => {
+            this.stop(false);
+            this.waitStatus(ActivityState.NotActive).then(() => {
+                this.allowAppStart();
+                this.start(this.prevOpts, true)
+                    .then((r) => {
+                    this.debug.info('Session restart', r);
+                })
+                    .catch((e) => {
+                    this.debug.error('Session restart failed', e);
+                });
+            });
+        };
         this.send = (message, urgent = false) => {
             if (this.activityState === ActivityState.NotActive) {
                 return;
@@ -4794,7 +4810,12 @@ class App {
         });
         this.session.attachUpdateCallback(({ userID, metadata }) => {
             if (userID != null) {
-                // TODO: nullable userID
+                if (!userID ||
+                    typeof userID !== 'string' ||
+                    userID.trim().length === 0) {
+                    this.debug.warn('Invalid userID (must be type string), ignoring.');
+                    return;
+                }
                 this.send(UserID(userID));
             }
             if (metadata != null) {
@@ -4869,6 +4890,12 @@ class App {
                         });
                     }
                 }
+                if (ev.data.line === proto.reset) {
+                    const newToken = ev.data.token;
+                    this.debug.log('Received reset signal from another tab');
+                    this.session.setSessionToken(newToken, this.projectKey);
+                    this.restart();
+                }
             };
         }
     }
@@ -5441,9 +5468,10 @@ class App {
             // Reset session metadata only if requested directly
             this.session.reset();
         }
+        const userId = startOpts.userID ? startOpts.userID.trim() : undefined;
         this.session.assign({
             // MBTODO: maybe it would make sense to `forceNew` if the `userID` was changed
-            userID: startOpts.userID,
+            userID: userId || undefined,
             metadata: startOpts.metadata,
         });
         const timestamp = now();
@@ -5510,6 +5538,12 @@ class App {
             }
             this.delay = delay;
             this.session.setSessionToken(token, this.projectKey);
+            if (sessionToken && sessionToken !== token) {
+                this.bc?.postMessage({
+                    type: proto.reset,
+                    token: token,
+                });
+            }
             this.session.setUserInfo({
                 userBrowser,
                 userCity,
@@ -7400,9 +7434,9 @@ function axiosSpy (app, instance, opts, sanitize, stringify) {
     });
 }
 function isAxiosError(payload) {
-    return isObject(payload) && payload.isAxiosError === true;
+    return isObject$1(payload) && payload.isAxiosError === true;
 }
-function isObject(thing) {
+function isObject$1(thing) {
     return thing !== null && typeof thing === 'object';
 }
 
@@ -8816,6 +8850,969 @@ function webAnimations(app, options = {}) {
     });
 }
 
+/**
+ * Detects client browser, OS, and device information
+ */
+function uaParse(sWindow) {
+    const unknown = '-';
+    // Screen detection
+    let width = 0;
+    let height = 0;
+    let screenSize = '';
+    if (sWindow.screen.width) {
+        width = sWindow.screen.width;
+        height = sWindow.screen.height;
+        screenSize = `${width} x ${height}`;
+    }
+    // Browser detection
+    const nVer = sWindow.navigator.appVersion ?? '0';
+    const nAgt = sWindow.navigator.userAgent ?? 'unknown';
+    let browser = sWindow.navigator.appName ?? "unknown";
+    let version = String(parseFloat(nVer));
+    let nameOffset;
+    let verOffset;
+    let ix;
+    // Browser detection logic
+    if ((verOffset = nAgt.indexOf('YaBrowser')) !== -1) {
+        browser = 'Yandex';
+        version = nAgt.substring(verOffset + 10);
+    }
+    else if ((verOffset = nAgt.indexOf('SamsungBrowser')) !== -1) {
+        browser = 'Samsung';
+        version = nAgt.substring(verOffset + 15);
+    }
+    else if ((verOffset = nAgt.indexOf('UCBrowser')) !== -1) {
+        browser = 'UC Browser';
+        version = nAgt.substring(verOffset + 10);
+    }
+    else if ((verOffset = nAgt.indexOf('OPR')) !== -1) {
+        browser = 'Opera';
+        version = nAgt.substring(verOffset + 4);
+    }
+    else if ((verOffset = nAgt.indexOf('Opera')) !== -1) {
+        browser = 'Opera';
+        version = nAgt.substring(verOffset + 6);
+        if ((verOffset = nAgt.indexOf('Version')) !== -1) {
+            version = nAgt.substring(verOffset + 8);
+        }
+    }
+    else if ((verOffset = nAgt.indexOf('Edge')) !== -1) {
+        browser = 'Microsoft Legacy Edge';
+        version = nAgt.substring(verOffset + 5);
+    }
+    else if ((verOffset = nAgt.indexOf('Edg')) !== -1) {
+        browser = 'Microsoft Edge';
+        version = nAgt.substring(verOffset + 4);
+    }
+    else if ((verOffset = nAgt.indexOf('MSIE')) !== -1) {
+        browser = 'Microsoft Internet Explorer';
+        version = nAgt.substring(verOffset + 5);
+    }
+    else if ((verOffset = nAgt.indexOf('Chrome')) !== -1) {
+        browser = 'Chrome';
+        version = nAgt.substring(verOffset + 7);
+    }
+    else if ((verOffset = nAgt.indexOf('Safari')) !== -1) {
+        browser = 'Safari';
+        version = nAgt.substring(verOffset + 7);
+        if ((verOffset = nAgt.indexOf('Version')) !== -1) {
+            version = nAgt.substring(verOffset + 8);
+        }
+    }
+    else if ((verOffset = nAgt.indexOf('Firefox')) !== -1) {
+        browser = 'Firefox';
+        version = nAgt.substring(verOffset + 8);
+    }
+    else if (nAgt.indexOf('Trident/') !== -1) {
+        browser = 'Microsoft Internet Explorer';
+        version = nAgt.substring(nAgt.indexOf('rv:') + 3);
+    }
+    else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) < (verOffset = nAgt.lastIndexOf('/'))) {
+        browser = nAgt.substring(nameOffset, verOffset);
+        version = nAgt.substring(verOffset + 1);
+        if (browser.toLowerCase() === browser.toUpperCase()) {
+            browser = sWindow.navigator.appName;
+        }
+    }
+    // Trim the version string
+    if ((ix = version.indexOf(';')) !== -1) {
+        version = version.substring(0, ix);
+    }
+    if ((ix = version.indexOf(' ')) !== -1) {
+        version = version.substring(0, ix);
+    }
+    if ((ix = version.indexOf(')')) !== -1) {
+        version = version.substring(0, ix);
+    }
+    let majorVersion = parseInt(version, 10);
+    if (isNaN(majorVersion)) {
+        version = String(parseFloat(nVer));
+        majorVersion = parseInt(nVer, 10);
+    }
+    // Mobile detection
+    const mobile = /Mobile|mini|Fennec|Android|iP(ad|od|hone)/.test(nVer);
+    // Cookie detection
+    let cookieEnabled = sWindow.navigator.cookieEnabled || false;
+    if (typeof navigator.cookieEnabled === 'undefined' && !cookieEnabled) {
+        sWindow.document.cookie = 'testcookie';
+        cookieEnabled = sWindow.document.cookie.indexOf('testcookie') !== -1;
+    }
+    // OS detection
+    let os = unknown;
+    const clientStrings = [
+        { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },
+        { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },
+        { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },
+        { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },
+        { s: 'Windows Vista', r: /Windows NT 6.0/ },
+        { s: 'Windows Server 2003', r: /Windows NT 5.2/ },
+        { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },
+        { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },
+        { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },
+        { s: 'Windows 98', r: /(Windows 98|Win98)/ },
+        { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },
+        { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+        { s: 'Windows CE', r: /Windows CE/ },
+        { s: 'Windows 3.11', r: /Win16/ },
+        { s: 'Android', r: /Android/ },
+        { s: 'Open BSD', r: /OpenBSD/ },
+        { s: 'Sun OS', r: /SunOS/ },
+        { s: 'Chrome OS', r: /CrOS/ },
+        { s: 'Linux', r: /(Linux|X11(?!.*CrOS))/ },
+        { s: 'iOS', r: /(iPhone|iPad|iPod)/ },
+        { s: 'Mac OS X', r: /Mac OS X/ },
+        { s: 'Mac OS', r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+        { s: 'QNX', r: /QNX/ },
+        { s: 'UNIX', r: /UNIX/ },
+        { s: 'BeOS', r: /BeOS/ },
+        { s: 'OS/2', r: /OS\/2/ },
+        {
+            s: 'Search Bot',
+            r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/,
+        },
+    ];
+    // Find matching OS
+    for (const client of clientStrings) {
+        if (client.r.test(nAgt)) {
+            os = client.s;
+            break;
+        }
+    }
+    // OS Version detection
+    let osVersion = unknown;
+    if (/Windows/.test(os)) {
+        const matches = /Windows (.*)/.exec(os);
+        if (matches && matches[1]) {
+            osVersion = matches[1];
+            // Handle Windows 10/11 detection with newer API if available
+            if (osVersion === '10' && 'userAgentData' in sWindow.navigator) {
+                const nav = navigator;
+                if (nav.userAgentData) {
+                    nav.userAgentData
+                        .getHighEntropyValues(['platformVersion'])
+                        .then((ua) => {
+                        const version = parseInt(ua.platformVersion.split('.')[0], 10);
+                        osVersion = version < 13 ? '10' : '11';
+                    })
+                        .catch(() => {
+                        // ignore errors and keep osVersion as is
+                    });
+                }
+            }
+        }
+        os = 'Windows';
+    }
+    // OS version detection for Mac/Android/iOS
+    switch (os) {
+        case 'Mac OS':
+        case 'Mac OS X':
+        case 'Android': {
+            const matches = /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([\.\_\d]+)/.exec(nAgt);
+            osVersion = matches && matches[1] ? matches[1] : unknown;
+            break;
+        }
+        case 'iOS': {
+            const matches = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+            if (matches && matches[1]) {
+                osVersion = `${matches[1]}.${matches[2]}.${parseInt(matches[3] || '0', 10)}`;
+            }
+            break;
+        }
+    }
+    // Return client data
+    return {
+        screen: screenSize,
+        width,
+        height,
+        browser,
+        browserVersion: version,
+        browserMajorVersion: majorVersion,
+        mobile,
+        os,
+        osVersion,
+        cookies: cookieEnabled,
+    };
+}
+function isObject(item) {
+    const isNull = item === null;
+    return Boolean(item && typeof item === 'object' && !Array.isArray(item) && !isNull);
+}
+function getUTCOffsetString() {
+    const date = new Date();
+    const offsetMinutes = date.getTimezoneOffset();
+    const hours = Math.abs(Math.floor(offsetMinutes / 60));
+    const minutes = Math.abs(offsetMinutes % 60);
+    const sign = offsetMinutes <= 0 ? '+' : '-';
+    const hoursStr = hours.toString().padStart(2, '0');
+    const minutesStr = minutes.toString().padStart(2, '0');
+    return `UTC${sign}${hoursStr}:${minutesStr}`;
+}
+
+const refKey = '$__or__initial_ref__$';
+const distinctIdKey = '$__or__distinct_device_id__$';
+const utmParamsKey = '$__or__utm_params__$';
+const superPropKey = '$__or__super_properties__$';
+const userIdKey = '$__or__user_id__$';
+const win = 'window' in globalThis
+    ? window
+    : {
+        navigator: { userAgent: '' },
+        screen: {},
+        document: {
+            cookie: '',
+        },
+        location: { search: '' },
+    };
+const doc = 'document' in globalThis ? document : { referrer: '' };
+const searchEngineList = [
+    'google',
+    'bing',
+    'yahoo',
+    'baidu',
+    'yandex',
+    'duckduckgo',
+    'ecosia',
+    'ask',
+    'aol',
+    'wolframalpha',
+    'startpage',
+    'swisscows',
+    'qwant',
+    'lycos',
+    'dogpile',
+    'info',
+    'teoma',
+    'webcrawler',
+    'naver',
+    'seznam',
+    'perplexity',
+];
+class ConstantProperties {
+    constructor(localStorage, sessionStorage) {
+        this.localStorage = localStorage;
+        this.sessionStorage = sessionStorage;
+        this.user_id = null;
+        this.setUserId = (user_id) => {
+            this.user_id = user_id;
+            this.sessionStorage.setItem(userIdKey, user_id ?? '');
+        };
+        this.resetUserId = (hard) => {
+            this.user_id = null;
+            if (hard) {
+                this.deviceId = this.getDistinctDeviceId(true);
+            }
+        };
+        this.getDistinctDeviceId = (force) => {
+            const potentialStored = this.localStorage.getItem(distinctIdKey);
+            if (potentialStored && !force) {
+                return potentialStored;
+            }
+            else {
+                const distinctId = `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+                this.localStorage.setItem(distinctIdKey, distinctId);
+                return distinctId;
+            }
+        };
+        this.getReferrer = () => {
+            const potentialStored = this.sessionStorage.getItem(refKey);
+            if (potentialStored) {
+                return potentialStored;
+            }
+            else {
+                const ref = doc.referrer;
+                this.sessionStorage.setItem(refKey, ref);
+                return ref;
+            }
+        };
+        this.parseUTM = () => {
+            const potentialStored = this.sessionStorage.getItem(utmParamsKey);
+            if (potentialStored) {
+                const obj = JSON.parse(potentialStored);
+                this.utmSource = obj.utm_source;
+                this.utmMedium = obj.utm_medium;
+                this.utmCampaign = obj.utm_campaign;
+            }
+            else {
+                const searchParams = new URLSearchParams(win.location.search);
+                this.utmSource = searchParams.get('utm_source') || null;
+                this.utmMedium = searchParams.get('utm_medium') || null;
+                this.utmCampaign = searchParams.get('utm_campaign') || null;
+                const obj = {
+                    utm_source: this.utmSource,
+                    utm_medium: this.utmMedium,
+                    utm_campaign: this.utmCampaign,
+                };
+                this.sessionStorage.setItem(utmParamsKey, JSON.stringify(obj));
+            }
+        };
+        this.getSearchEngine = (ref) => {
+            for (const searchEngine of searchEngineList) {
+                if (ref.includes(searchEngine)) {
+                    return searchEngine;
+                }
+            }
+            return null;
+        };
+        this.getSuperProperties = () => {
+            const potentialStored = this.localStorage.getItem(superPropKey);
+            if (potentialStored) {
+                return JSON.parse(potentialStored);
+            }
+            else {
+                return {};
+            }
+        };
+        this.saveSuperProperties = (props) => {
+            this.localStorage.setItem(superPropKey, JSON.stringify(props));
+        };
+        this.clearSuperProperties = () => {
+            this.localStorage.setItem(superPropKey, JSON.stringify({}));
+        };
+        const { width, height, browser, browserVersion, browserMajorVersion, os, osVersion, mobile } = uaParse(win);
+        const storedUserId = this.sessionStorage.getItem(userIdKey);
+        if (storedUserId) {
+            this.user_id = storedUserId;
+        }
+        this.os = os;
+        this.osVersion = osVersion;
+        this.browser = `${browser}`;
+        this.browserVersion = `${browserVersion} (${browserMajorVersion})`;
+        this.platform = mobile ? 'mobile' : 'desktop';
+        this.screenHeight = height;
+        this.screenWidth = width;
+        this.initialReferrer = this.getReferrer();
+        this.deviceId = this.getDistinctDeviceId();
+        this.searchEngine = this.getSearchEngine(this.initialReferrer);
+        this.parseUTM();
+    }
+    get all() {
+        return {
+            os: this.os,
+            os_version: this.osVersion,
+            browser: this.browser,
+            browser_version: this.browserVersion,
+            platform: this.platform,
+            screen_height: this.screenHeight,
+            screen_width: this.screenWidth,
+            initial_referrer: this.initialReferrer,
+            utm_source: this.utmSource,
+            utm_medium: this.utmMedium,
+            utm_campaign: this.utmCampaign,
+            user_id: this.user_id,
+            distinct_id: this.deviceId,
+            sdk_edition: 'web',
+            sdk_version: '17.1.0',
+            timezone: getUTCOffsetString(),
+            search_engine: this.searchEngine,
+        };
+    }
+    get defaultPropertyKeys() {
+        return Object.keys(this.all);
+    }
+    get distinctId() {
+        return this.deviceId;
+    }
+}
+
+const mutationTypes = {
+    identity: 'identity',
+    deleteUser: 'delete_user',
+    setProperty: 'set_property',
+    setPropertyOnce: 'set_property_once',
+    appendProperty: 'append_property',
+    appendUniqueProperty: 'append_unique_property',
+    incrementProperty: 'increment_property',
+};
+const categories = {
+    people: 'user_actions',
+    events: 'events',
+};
+const createEvent = (category, type, timestamp, payload) => {
+    if (category === categories.people) {
+        return {
+            category,
+            data: {
+                type,
+                user_id: payload.user_id,
+                payload: payload.properties,
+                timestamp,
+            },
+        };
+    }
+    else {
+        if (!payload) {
+            throw new Error('Payload is required for event creation');
+        }
+        return {
+            category,
+            data: {
+                name: payload.name,
+                payload: payload.properties,
+                timestamp,
+            },
+        };
+    }
+};
+
+const reservedProps = ['properties', 'token', 'timestamp'];
+class Events {
+    constructor(constantProperties, getTimestamp, batcher) {
+        this.constantProperties = constantProperties;
+        this.getTimestamp = getTimestamp;
+        this.batcher = batcher;
+        this.ownProperties = {};
+        /**
+         * Add event to batch with option to send it immediately,
+         * properties are optional and will not be saved as super prop
+         * */
+        this.sendEvent = (eventName, properties, options) => {
+            // add properties
+            const eventProps = {};
+            if (properties) {
+                if (!isObject(properties)) {
+                    throw new Error('Properties must be an object');
+                }
+                Object.entries(properties).forEach(([key, value]) => {
+                    if (!this.constantProperties.defaultPropertyKeys.includes(key)) {
+                        eventProps[key] = value;
+                    }
+                });
+            }
+            const eventPayload = {
+                name: eventName,
+                properties: { ...this.ownProperties, ...eventProps },
+            };
+            const event = createEvent(categories.events, undefined, this.getTimestamp(), eventPayload);
+            if (options?.send_immediately) {
+                void this.batcher.sendImmediately(event);
+            }
+            else {
+                this.batcher.addEvent(event);
+            }
+        };
+        /**
+         * creates super property for all events
+         * */
+        this.setProperty = (nameOrProperties, value) => {
+            let changed = false;
+            if (isObject(nameOrProperties)) {
+                Object.entries(nameOrProperties).forEach(([key, val]) => {
+                    if (!this.constantProperties.defaultPropertyKeys.includes(key)) {
+                        this.ownProperties[key] = val;
+                        changed = true;
+                    }
+                });
+            }
+            if (typeof nameOrProperties === 'string' && value !== undefined) {
+                if (!this.constantProperties.defaultPropertyKeys.includes(nameOrProperties)) {
+                    this.ownProperties[nameOrProperties] = value;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                this.constantProperties.saveSuperProperties(this.ownProperties);
+            }
+        };
+        /**
+         * set super property only if it doesn't exist yet
+         * */
+        this.setPropertiesOnce = (nameOrProperties, value) => {
+            let changed = false;
+            if (isObject(nameOrProperties)) {
+                Object.entries(nameOrProperties).forEach(([key, val]) => {
+                    if (!this.ownProperties[key] && !reservedProps.includes(key)) {
+                        this.ownProperties[key] = val;
+                        changed = true;
+                    }
+                });
+            }
+            if (typeof nameOrProperties === 'string' && value !== undefined) {
+                if (!this.ownProperties[nameOrProperties] && !reservedProps.includes(nameOrProperties)) {
+                    this.ownProperties[nameOrProperties] = value;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                this.constantProperties.saveSuperProperties(this.ownProperties);
+            }
+        };
+        /**
+         * removes properties from list of super properties
+         * */
+        this.unsetProperties = (properties) => {
+            let changed = false;
+            if (Array.isArray(properties)) {
+                properties.forEach((key) => {
+                    if (this.ownProperties[key] && !reservedProps.includes(key)) {
+                        delete this.ownProperties[key];
+                        changed = true;
+                    }
+                });
+            }
+            else if (this.ownProperties[properties] && !reservedProps.includes(properties)) {
+                delete this.ownProperties[properties];
+                changed = true;
+            }
+            if (changed) {
+                this.constantProperties.saveSuperProperties(this.ownProperties);
+            }
+        };
+        /** clears all super properties */
+        this.reset = () => {
+            this.ownProperties = {};
+            this.constantProperties.clearSuperProperties();
+        };
+        /** mixpanel compatibility */
+        this.register = this.setProperty;
+        this.register_once = this.setPropertiesOnce;
+        this.unregister = this.unsetProperties;
+        this.track = this.sendEvent;
+        this.ownProperties = this.constantProperties.getSuperProperties();
+    }
+}
+
+class People {
+    constructor(constantProperties, getTimestamp, onId, batcher) {
+        this.constantProperties = constantProperties;
+        this.getTimestamp = getTimestamp;
+        this.onId = onId;
+        this.batcher = batcher;
+        this.ownProperties = {};
+        this.identify = (user_id, options) => {
+            if (!user_id || typeof user_id !== 'string') {
+                throw new Error('OR SDK: user_id (string) is required for .identify()');
+            }
+            // if user exists already, reset properties
+            if (this.constantProperties.user_id && this.constantProperties.user_id !== user_id) {
+                this.reset();
+            }
+            this.constantProperties.setUserId(user_id);
+            if (!options?.fromTracker) {
+                this.onId(user_id);
+            }
+            const identityEvent = createEvent(categories.people, mutationTypes.identity, this.getTimestamp(), { user_id });
+            this.batcher.addEvent(identityEvent);
+        };
+        /** Resets user id and own properties
+         *
+         * !hard reset will destroy persistent device id!
+         * */
+        this.reset = (hard) => {
+            this.constantProperties.resetUserId(hard);
+            this.ownProperties = {};
+        };
+        /**
+         *  Will delete user and its data from backend, then reset all local properties
+         */
+        this.deleteUser = () => {
+            const removedUser = this.constantProperties.user_id;
+            if (!removedUser)
+                return;
+            this.constantProperties.setUserId(null);
+            this.ownProperties = {};
+            const deleteEvent = createEvent(categories.people, mutationTypes.deleteUser, undefined, {
+                user_id: removedUser,
+            });
+            this.batcher.addEvent(deleteEvent);
+            this.reset();
+        };
+        /**
+         * set user properties, overwriting existing ones
+         * */
+        this.setProperties = (propertyOrObj, value) => {
+            if (!propertyOrObj) {
+                throw new Error('OR SDK: no user properties provided to set');
+            }
+            const properties = {};
+            if (typeof propertyOrObj === 'string' && propertyOrObj && value) {
+                properties[propertyOrObj] = value;
+            }
+            else if (isObject(propertyOrObj)) {
+                Object.assign(properties, propertyOrObj);
+            }
+            else {
+                throw new Error('OR SDK: invalid user properties provided to set');
+            }
+            Object.entries(properties).forEach(([key, value]) => {
+                if (!this.constantProperties.defaultPropertyKeys.includes(key)) {
+                    this.ownProperties[key] = value;
+                }
+            });
+            const setEvent = createEvent(categories.people, mutationTypes.setProperty, undefined, {
+                user_id: this.user_id,
+                properties,
+            });
+            this.batcher.addEvent(setEvent);
+        };
+        /**
+         * Set property if it doesn't exist yet
+         * */
+        this.setPropertiesOnce = (properties) => {
+            if (!isObject(properties)) {
+                throw new Error('Properties must be an object');
+            }
+            Object.entries(properties).forEach(([key, value]) => {
+                if (!this.constantProperties.defaultPropertyKeys.includes(key) && !this.ownProperties[key]) {
+                    this.ownProperties[key] = value;
+                }
+            });
+            const setEvent = createEvent(categories.people, mutationTypes.setPropertyOnce, undefined, {
+                user_id: this.user_id,
+                properties,
+            });
+            this.batcher.addEvent(setEvent);
+        };
+        /**
+         * Add value to property (will turn string prop into array)
+         * */
+        this.appendValues = (key, value) => {
+            if (!this.constantProperties.defaultPropertyKeys.includes(key) && this.ownProperties[key]) {
+                if (Array.isArray(this.ownProperties[key])) {
+                    this.ownProperties[key].push(value);
+                }
+                else {
+                    this.ownProperties[key] = [this.ownProperties[key], value];
+                }
+            }
+            const appendEvent = createEvent(categories.people, mutationTypes.appendProperty, undefined, {
+                properties: { [key]: value },
+                user_id: this.user_id,
+            });
+            this.batcher.addEvent(appendEvent);
+        };
+        /**
+         * Add unique values to property (will turn string prop into array)
+         * */
+        this.appendUniqueValues = (key, value) => {
+            if (!this.ownProperties[key])
+                return;
+            if (Array.isArray(this.ownProperties[key])) {
+                if (!this.ownProperties[key].includes(value)) {
+                    this.appendValues(key, value);
+                }
+            }
+            else if (this.ownProperties[key] !== value) {
+                this.appendValues(key, value);
+            }
+            const unionEvent = createEvent(categories.people, mutationTypes.appendUniqueProperty, undefined, {
+                properties: { [key]: value },
+                user_id: this.user_id,
+            });
+            this.batcher.addEvent(unionEvent);
+        };
+        /**
+         * Adds value (incl. negative) to existing numerical property
+         * */
+        this.increment = (key, value) => {
+            if (!this.ownProperties[key]) {
+                this.ownProperties[key] = 0;
+            }
+            if (this.ownProperties[key] && typeof this.ownProperties[key] !== 'number') {
+                throw new Error('OR SDK: Property must be a number to increment');
+            }
+            // @ts-ignore
+            this.ownProperties[key] += value;
+            const incrementEvent = createEvent(categories.people, mutationTypes.incrementProperty, undefined, {
+                user_id: this.user_id,
+                properties: { [key]: value },
+            });
+            this.batcher.addEvent(incrementEvent);
+        };
+        /** mixpanel compatibility */
+        this.union = this.appendUniqueValues;
+        this.set = this.setProperties;
+        this.set_once = this.setPropertiesOnce;
+        this.append = this.appendValues;
+        this.incrementBy = this.increment;
+    }
+    get user_id() {
+        return this.constantProperties.user_id;
+    }
+}
+
+/**
+ * Creates batches of events, then sends them at intervals.
+ */
+class Batcher {
+    constructor(backendUrl, getToken, init) {
+        this.backendUrl = backendUrl;
+        this.getToken = getToken;
+        this.init = init;
+        this.autosendInterval = 5 * 1000;
+        this.retryTimeout = 3 * 1000;
+        this.retryLimit = 3;
+        this.apiEdp = '/v1/sdk/i';
+        this.batch = {
+            [categories.people]: [],
+            [categories.events]: [],
+        };
+        this.intervalId = null;
+    }
+    getBatches() {
+        this.batch[categories.people] = this.dedupePeopleEvents();
+        const finalData = { data: this.batch };
+        return finalData;
+    }
+    addEvent(event) {
+        this.batch[event.category].push(event.data);
+    }
+    sendImmediately(event) {
+        this.sendBatch({ [event.category]: [event.data] });
+    }
+    /**
+     *
+     * Essentially we're dividing the batch by identify events and squash all same category events into one in each part,
+     * taking priority to the last one
+     */
+    dedupePeopleEvents() {
+        const peopleEvents = this.batch[categories.people];
+        const finalEvents = [];
+        const currentPart = [];
+        for (let event of peopleEvents) {
+            if (event.type === 'identity') {
+                if (currentPart.length > 0) {
+                    finalEvents.push(...this.squashPeopleEvents(currentPart), event);
+                    currentPart.length = 0;
+                }
+                else {
+                    finalEvents.push(event);
+                }
+            }
+            else {
+                currentPart.push(event);
+            }
+        }
+        if (currentPart.length > 0) {
+            finalEvents.push(...this.squashPeopleEvents(currentPart));
+        }
+        return finalEvents;
+    }
+    squashPeopleEvents(events) {
+        if (!events || events.length === 0) {
+            return [];
+        }
+        const uniqueEventsByType = new Map();
+        for (let event of events) {
+            const prev = uniqueEventsByType.get(event.type);
+            if (prev) {
+                if (event.type === 'increment_property') {
+                    const previousValues = Object.entries(prev.payload);
+                    const currentValues = Object.entries(event.payload);
+                    const uniqueKeys = new Set([...previousValues.map(([key]) => key), ...currentValues.map(([key]) => key)]);
+                    const mergedPayload = {};
+                    uniqueKeys.forEach((key) => {
+                        const prevValue = typeof prev.payload[key] === 'number' ? prev.payload[key] : 0;
+                        const currValue = typeof event.payload[key] === 'number' ? event.payload[key] : 0;
+                        mergedPayload[key] = prevValue + currValue;
+                    });
+                    uniqueEventsByType.set(event.type, {
+                        type: event.type,
+                        timestamp: event.timestamp,
+                        payload: mergedPayload,
+                    });
+                    continue;
+                }
+                // merge payloads, taking priority to the latest one
+                uniqueEventsByType.set(event.type, {
+                    type: event.type,
+                    timestamp: event.timestamp,
+                    payload: { ...(prev.payload ?? {}), ...(event.payload ?? {}) },
+                });
+            }
+            else {
+                uniqueEventsByType.set(event.type, event);
+            }
+        }
+        return Array.from(uniqueEventsByType.values());
+    }
+    sendBatch(batch) {
+        const sentBatch = batch;
+        let attempts = 0;
+        const send = () => {
+            const token = this.getToken();
+            if (!token) {
+                return;
+            }
+            attempts++;
+            return fetch(`${this.backendUrl}${this.apiEdp}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(sentBatch),
+            })
+                .then((response) => {
+                if (response.status === 403) {
+                    this.init().then(() => {
+                        send();
+                    });
+                }
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+            })
+                .catch(() => {
+                if (attempts < this.retryLimit) {
+                    setTimeout(() => void send(), this.retryTimeout);
+                }
+            });
+        };
+        void send();
+    }
+    startAutosend() {
+        this.intervalId = setInterval(() => {
+            this.flush();
+        }, this.autosendInterval);
+    }
+    flush() {
+        const categories = Object.keys(this.batch);
+        const isEmpty = categories.every((category) => this.batch[category].length === 0);
+        if (isEmpty) {
+            return;
+        }
+        this.sendBatch(this.getBatches());
+        categories.forEach((key) => {
+            this.batch[key] = [];
+        });
+    }
+    stop() {
+        this.flush();
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+}
+
+const STORAGEKEY = '__or_sdk_analytics_token';
+class Analytics {
+    /**
+     * @param localStorage Class or Object that implements Storage-like interface that stores
+     * values persistently like window.localStorage or any other file-based storage
+     *
+     * @param sessionStorage Class or Object that implements Storage-like interface that stores values
+     * on per-session basis like window.sessionStorage or any other in-memory storage
+     *
+     * @param getToken Function that returns token to bind events to a session
+     *
+     * @param getTimestamp returns current timestamp
+     *
+     * @param setUserId callback for people.identify
+     *
+     * @param standalone if true, analytics will manage its own token (instead of using with openreplay tracker session)
+     * */
+    constructor(options) {
+        this.token = null;
+        this.standalone = false;
+        this._getToken = () => {
+            if (this.standalone) {
+                return this.token;
+            }
+            return this.getToken();
+        };
+        this._getTimestamp = () => {
+            if (this.standalone) {
+                return Date.now();
+            }
+            return this.getTimestamp();
+        };
+        this.init = async () => {
+            if (!this.standalone) {
+                this.batcher.startAutosend();
+                return;
+            }
+            else {
+                const defaultFields = this.constantProperties.all;
+                const apiEdp = '/v1/sdk/start';
+                const data = {
+                    projectKey: this.projectKey,
+                    defaultFields,
+                };
+                const resp = await fetch(apiEdp, {
+                    method: 'POST',
+                    body: JSON.stringify(data),
+                });
+                if (!resp.ok) {
+                    throw new Error(`HTTP error! status: ${resp.status}`);
+                }
+                const result = await resp.json();
+                if (result.token) {
+                    this.token = result.token;
+                    this.sessionStorage.setItem(STORAGEKEY, result.token);
+                }
+                else {
+                    throw new Error('No token received from server');
+                }
+            }
+        };
+        this.reset = () => {
+            this.people.reset(true);
+            this.events.reset();
+            this.batcher.stop();
+            if (this.standalone) {
+                this.token = null;
+                this.sessionStorage.setItem(STORAGEKEY, '');
+            }
+        };
+        /**
+         * COMPATIBILITY LAYER
+         * */
+        /**
+         * Identify a user with an id (e.g. email, username, etc.)
+         * will bind all events and properties (including device_id) to this user
+         *
+         * you will need to manually call people.reset() to clear the id on logout event
+         * */
+        this.identify = (user_id) => {
+            return this.people.identify(user_id);
+        };
+        /**
+         * Add event to batch with option to send it immediately,
+         * properties are optional and will not be saved as super prop
+         * */
+        this.track = (eventName, properties, options) => {
+            return this.events.track(eventName, properties, options);
+        };
+        this.sessionStorage = options.sessionStorage || sessionStorage;
+        this.localStorage = options.localStorage || localStorage;
+        this.backendUrl = options.ingestPoint;
+        this.projectKey = options.projectKey;
+        this.getToken = options.getToken || (() => '');
+        this.getTimestamp = options.getTimestamp || (() => Date.now());
+        this.setUserId = options.setUserId || (() => { });
+        this.standalone = !options.notStandalone;
+        this.token = this.sessionStorage.getItem(STORAGEKEY);
+        this.constantProperties = new ConstantProperties(this.localStorage, this.sessionStorage);
+        this.batcher = new Batcher(this.backendUrl, this._getToken, this.init);
+        this.events = new Events(this.constantProperties, this._getTimestamp, this.batcher);
+        this.people = new People(this.constantProperties, this._getTimestamp, this.setUserId, this.batcher);
+        if (options.notStandalone) {
+            this.init();
+        }
+    }
+}
+
 const Messages = _Messages;
 const DOCS_SETUP = '/en/sdk';
 function processOptions(obj) {
@@ -8857,6 +9854,7 @@ class API {
     constructor(options) {
         this.options = options;
         this.app = null;
+        this.analytics = null;
         this.crossdomainMode = false;
         this.checkDoNotTrack = () => {
             return (this.options.respectDoNotTrack &&
@@ -8867,7 +9865,7 @@ class API {
         this.signalStartIssue = (reason, missingApi) => {
             const doNotTrack = this.checkDoNotTrack();
             console.log("Tracker couldn't start due to:", JSON.stringify({
-                trackerVersion: '17.0.1',
+                trackerVersion: '17.1.0',
                 projectKey: this.options.projectKey,
                 doNotTrack,
                 reason: missingApi.length ? `missing api: ${missingApi.join(',')}` : reason,
@@ -8879,6 +9877,22 @@ class API {
             }
             this.app.restartCanvasTracking();
         };
+        this.getSessionURL = (options) => {
+            if (this.app === null) {
+                return undefined;
+            }
+            return this.app.getSessionURL(options);
+        };
+        this.setUserID = (id) => {
+            if (typeof id === 'string' && this.app !== null) {
+                this.app.session.setUserID(id);
+                this.analytics?.people.identify(id, { fromTracker: true });
+            }
+        };
+        this.userID = (id) => {
+            deprecationWarn("'userID' method", "'setUserID' method", '/');
+            this.setUserID(id);
+        };
         this.handleError = (e, metadata = {}) => {
             if (this.app === null) {
                 return;
@@ -8901,6 +9915,21 @@ class API {
             }
             this.app.send(Incident(options.label ?? '', options.startTime, options.endTime ?? options.startTime));
         };
+        this.analyticsToken = null;
+        /**
+         * Use custom token for analytics events without session recording
+         * */
+        this.setAnalyticsToken = (token) => {
+            this.analyticsToken = token;
+        };
+        this.getAnalyticsToken = () => {
+            if (this.analyticsToken) {
+                return this.analyticsToken;
+            }
+            else {
+                return this.app?.session.getSessionToken() ?? '';
+            }
+        };
         this.crossdomainMode = Boolean(inIframe() && options.crossdomain?.enabled);
         if (!IN_BROWSER || !processOptions(options)) {
             return;
@@ -8959,6 +9988,24 @@ class API {
         }
         const app = new App(options.projectKey, options.sessionToken, options, this.signalStartIssue, this.crossdomainMode);
         this.app = app;
+        if (options.projectKey && options.analytics?.active) {
+            const isSaas = !options.ingestPoint || options.ingestPoint.includes('api.openreplay.com');
+            const defaultEdp = 'https://api.openreplay.com/ingest';
+            this.analytics = new Analytics({
+                localStorage: options.localStorage ?? localStorage,
+                sessionStorage: options.sessionStorage ?? sessionStorage,
+                getToken: () => this.getAnalyticsToken(),
+                getTimestamp: () => this.app?.timestamp() ?? Date.now(),
+                setUserId: (id) => {
+                    this.app?.session.setUserID(id);
+                },
+                notStandalone: true,
+                ingestPoint: isSaas
+                    ? defaultEdp
+                    : (options.analytics?.ingestPoint ?? options.ingestPoint ?? defaultEdp),
+                projectKey: options.projectKey,
+            });
+        }
         if (!this.crossdomainMode) {
             // no need to send iframe viewport data since its a node for us
             Viewport(app, options.urls);
@@ -9038,6 +10085,9 @@ class API {
             if (this.app === null) {
                 return Promise.reject("Browser doesn't support required api, or doNotTrack is active.");
             }
+            if (startOpts?.userID) {
+                this.analytics?.people.identify(startOpts.userID, { fromTracker: true });
+            }
             return this.app.start(startOpts);
         }
         else {
@@ -9145,21 +10195,6 @@ class API {
         deprecationWarn("'sessionID' method", "'getSessionID' method", '/');
         return this.getSessionID();
     }
-    getSessionURL(options) {
-        if (this.app === null) {
-            return undefined;
-        }
-        return this.app.getSessionURL(options);
-    }
-    setUserID(id) {
-        if (typeof id === 'string' && this.app !== null) {
-            this.app.session.setUserID(id);
-        }
-    }
-    userID(id) {
-        deprecationWarn("'userID' method", "'setUserID' method", '/');
-        this.setUserID(id);
-    }
     setUserAnonymousID(id) {
         if (typeof id === 'string' && this.app !== null) {
             this.app.send(UserAnonymousID(id));
@@ -9446,8 +10481,10 @@ class TrackerSingleton {
 }
 const tracker = new TrackerSingleton();
 
+exports.Analytics = Analytics;
 exports.App = App;
 exports.Messages = Messages;
 exports.default = API;
+exports.openReplay = tracker;
 exports.tracker = tracker;
 //# sourceMappingURL=entry.js.map