@zoho_apptics/apptics-js-sdk 1.0.2 → 2.0.0-beta.1

package/dist/cjs/core/db.js

@@ -0,0 +1,467 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+
+const DB_NAME = 'apptics'; // no i18n
+// 3 added the heatmaps store. 4 renamed: each record's order key `seq` to `queue`, the logs store
+// to feedbacklogs and consolelogs to remotelogs. Every upgrade keeps what is already queued.
+const DB_VERSION = 4;
+const OPEN_TIMEOUT_MS = 3000;
+const QUEUES = ['engagements', 'errors', 'feedbacklogs', 'remotelogs', 'heatmaps']; // no i18n
+/** The field, and the index on it, that keeps a queue's records in the order they were added. */
+const QUEUE_KEY = 'queue'; // no i18n
+/** Version 3's names, which the version 4 upgrade moves to the ones above. */
+const OLD_QUEUE_KEY = 'seq'; // no i18n
+const RENAMED_STORES = [['logs', 'feedbacklogs'], ['consolelogs', 'remotelogs']]; // no i18n
+/** The types a feedback entry is stored under: an addFeedbackLog() line, an addDiagnosticsInfo() entry. */
+const FEEDBACK_LOG = 'feedbacklog'; // no i18n
+const FEEDBACK_DIAGNOSTICS = 'feedbackdiagnostics'; // no i18n
+const OLD_FEEDBACK_TYPES = Object.freeze({
+    log: FEEDBACK_LOG, // no i18n
+    diagnostics: FEEDBACK_DIAGNOSTICS, // no i18n
+});
+/** A feedback entry from 1.x or 2.0.0-beta, with the type it is stored under now. */
+function renameFeedbackType(item) {
+    var renamed = item && typeof item.type === 'string' ? OLD_FEEDBACK_TYPES[item.type] : undefined; // no i18n
+    return renamed ? { ...item, type: renamed } : item;
+}
+/** 1.x localStorage keys, read once to bring 1.x data into IndexedDB (see migrateLegacy). */
+const LEGACY_KEYS = Object.freeze({
+    settings: 'apptics-device-info', // no i18n
+    engagements: 'apptics-engagements-transactions', // no i18n
+    errors: 'apptics-errors-transactions', // no i18n
+    logs: 'apptics-log-transactions', // no i18n
+    consolelogs: 'apptics-consolelog-transactions', // no i18n
+});
+/** The localStorage backend's layout, for a browser where IndexedDB will not open. */
+const LOCAL_KEYS = Object.freeze({
+    settings: LEGACY_KEYS.settings,
+    engagements: LEGACY_KEYS.engagements,
+    errors: LEGACY_KEYS.errors,
+    feedbacklogs: 'apptics-feedbacklog-transactions', // no i18n
+    remotelogs: 'apptics-remotelog-transactions', // no i18n
+    heatmaps: 'apptics-heatmap-transactions', // no i18n
+});
+/**
+ * The localStorage backend once kept these two under the 1.x keys. Moved to the new ones on first
+ * use, feedback types renamed on the way, unless something is already there.
+ */
+function moveRenamedLocalKeys() {
+    [[LEGACY_KEYS.logs, LOCAL_KEYS.feedbacklogs], [LEGACY_KEYS.consolelogs, LOCAL_KEYS.remotelogs]].forEach(function (pair) {
+        try {
+            var from = pair[0];
+            var to = pair[1];
+            var old = localStorage.getItem(from);
+            if (old === null) {
+                return;
+            }
+            if (localStorage.getItem(to) === null) {
+                var items = asList(JSON.parse(old));
+                localStorage.setItem(to, JSON.stringify(to === LOCAL_KEYS.feedbacklogs ? items.map(renameFeedbackType) : items));
+            }
+            localStorage.removeItem(from);
+        }
+        catch (err) {
+            // left where it is; the next load tries again
+        }
+    });
+}
+/** Shape guards shared by both backends and the 1.x migration. */
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asDict(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/* ---------------- localStorage backend ---------------- */
+function readJSON(key) {
+    try {
+        const raw = localStorage.getItem(key);
+        return raw === null || raw === '' ? null : JSON.parse(raw); // no i18n
+    }
+    catch (err) {
+        logger.Console.warn('apptics: could not read ' + key + ', treating it as empty'); // no i18n
+        return null;
+    }
+}
+function writeJSON(key, value) {
+    try {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch (err) {
+        logger.Console.warn('apptics: could not write ' + key + ': ' + String(err)); // no i18n
+    }
+}
+function createLocalStorageBackend() {
+    moveRenamedLocalKeys();
+    return {
+        kind: 'localstorage', // no i18n
+        loadSettings() {
+            return Promise.resolve(asDict(readJSON(LOCAL_KEYS.settings)));
+        },
+        putSetting(key, value) {
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
+            all[key] = value;
+            writeJSON(LOCAL_KEYS.settings, all);
+            return Promise.resolve();
+        },
+        deleteSetting(key) {
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
+            delete all[key];
+            writeJSON(LOCAL_KEYS.settings, all);
+            return Promise.resolve();
+        },
+        clearSettings() {
+            writeJSON(LOCAL_KEYS.settings, {});
+            return Promise.resolve();
+        },
+        queueAll(store) {
+            return Promise.resolve(asList(readJSON(LOCAL_KEYS[store])));
+        },
+        queuePut(store, items) {
+            const list = asList(readJSON(LOCAL_KEYS[store]));
+            items.forEach(function (item) {
+                const index = list.findIndex(function (existing) { return existing.id === item.id; });
+                if (index === -1) {
+                    list.push(item);
+                }
+                else {
+                    list[index] = item;
+                }
+            });
+            writeJSON(LOCAL_KEYS[store], list);
+            return Promise.resolve();
+        },
+        queueDelete(store, ids) {
+            const remaining = asList(readJSON(LOCAL_KEYS[store])).filter(function (item) {
+                return ids.indexOf(item.id) === -1;
+            });
+            writeJSON(LOCAL_KEYS[store], remaining);
+            return Promise.resolve();
+        },
+        queueClear(store) {
+            writeJSON(LOCAL_KEYS[store], []);
+            return Promise.resolve();
+        },
+    };
+}
+let lastQueue = 0;
+/**
+ * Strictly increasing, and time-based so tabs interleave in roughly the right order.
+ * Counting up from the last value rather than a counter that wraps keeps insertion order
+ * even when a chatty caller adds more than a thousand items inside one millisecond.
+ */
+function nextQueue() {
+    const base = utils.nowMs() * 1000;
+    lastQueue = base > lastQueue ? base : lastQueue + 1;
+    return lastQueue;
+}
+function request(req) {
+    return new Promise(function (resolve, reject) {
+        req.onsuccess = function () { resolve(req.result); };
+        req.onerror = function () { reject(req.error); };
+    });
+}
+function completed(tx) {
+    return new Promise(function (resolve, reject) {
+        tx.oncomplete = function () { resolve(); };
+        tx.onerror = function () { reject(tx.error); };
+        tx.onabort = function () { reject(tx.error); };
+    });
+}
+/**
+ * The record's `type` for an item with none of its own: heatmap records carry no type, since
+ * their payload is the item itself and the server takes no extra field. Never undefined.
+ */
+const STORE_TYPES = Object.freeze({
+    engagements: 'engagement', // no i18n
+    errors: 'error', // no i18n
+    feedbacklogs: FEEDBACK_LOG,
+    remotelogs: 'remotelog', // no i18n
+    heatmaps: 'heatmap', // no i18n
+});
+function recordType(storeName, item) {
+    return item && typeof item.type === 'string' && item.type !== '' ? item.type : (STORE_TYPES[storeName] || storeName); // no i18n
+}
+/** Puts `item` unless it exists (keepExisting) or replaces it keeping its place. Runs inside `store`'s transaction. */
+function putRecord(store, item, keepExisting) {
+    const id = String(item.id);
+    const lookup = store.get(id);
+    lookup.onsuccess = function () {
+        const existing = lookup.result;
+        if (existing && keepExisting) {
+            return;
+        }
+        store.put({ id: id, queue: existing ? existing.queue : nextQueue(), type: recordType(store.name, item), item: item });
+    };
+}
+/** Our stores, as created by onupgradeneeded. */
+function hasAllStores(db) {
+    return db.objectStoreNames.contains('settings') && QUEUES.every(function (name) {
+        return db.objectStoreNames.contains(name);
+    });
+}
+function deleteDatabase(factory) {
+    return new Promise(function (resolve) {
+        var req = factory.deleteDatabase(DB_NAME);
+        req.onsuccess = function () { resolve(); };
+        req.onerror = function () { resolve(); };
+        req.onblocked = function () { resolve(); };
+    });
+}
+/**
+ * Opens the database, and repairs it once if something else created an "apptics" database
+ * without our stores (then onupgradeneeded never fires and every read would fail).
+ */
+function openIndexedDB(factory = indexedDB, timeoutMs = OPEN_TIMEOUT_MS) {
+    return openOnce(factory, timeoutMs).then(function (db) {
+        if (hasAllStores(db)) {
+            return db;
+        }
+        logger.Console.warn('apptics: the "' + DB_NAME + '" database is missing its stores, recreating it'); // no i18n
+        db.close();
+        return deleteDatabase(factory).then(function () {
+            return openOnce(factory, timeoutMs);
+        }).then(function (fresh) {
+            if (!hasAllStores(fresh)) {
+                fresh.close();
+                throw new Error('indexedDB: stores could not be created'); // no i18n
+            }
+            return fresh;
+        });
+    });
+}
+function openOnce(factory, timeoutMs) {
+    return new Promise(function (resolve, reject) {
+        let settled = false;
+        const fail = function (reason) {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(reason);
+            }
+        };
+        const timer = setTimeout(function () {
+            fail(new Error('indexedDB open timed out')); // no i18n
+        }, timeoutMs);
+        let req;
+        try {
+            req = factory.open(DB_NAME, DB_VERSION);
+        }
+        catch (err) {
+            fail(err);
+            return;
+        }
+        req.onupgradeneeded = function () {
+            upgrade(req.result, req.transaction);
+        };
+        req.onsuccess = function () {
+            if (settled) {
+                req.result.close(); // we already gave up (timeout or blocked)
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            // Another tab running a newer build needs to upgrade the schema, and cannot while this
+            // connection is open. Letting go is the only cooperative answer: holding on blocks that
+            // tab's upgrade until this one is closed, and it spends the whole time with no storage.
+            // This tab keeps working from memory and picks the new schema up on its next load.
+            req.result.onversionchange = function () {
+                logger.Console.warn('apptics: another tab is upgrading the database, closing this connection'); // no i18n
+                req.result.close();
+            };
+            resolve(req.result);
+        };
+        req.onerror = function () {
+            fail(req.error);
+        };
+        req.onblocked = function () {
+            // Another tab is holding an older version open. A build that sets onversionchange
+            // (above) lets go by itself, so this resolves on its own in a moment; the open is left
+            // to run until the timeout rather than abandoned, because giving up here would mean
+            // running with no storage for the rest of the visit.
+            logger.Console.warn('apptics: waiting for another tab to release the database'); // no i18n
+        };
+    });
+}
+/**
+ * Creates what is missing and moves version 3's data to version 4's names, inside the upgrade's
+ * own transaction: either the whole upgrade lands, or the database stays at the old version with
+ * everything still in it.
+ */
+function upgrade(db, tx) {
+    if (!db.objectStoreNames.contains('settings')) { // no i18n
+        db.createObjectStore('settings'); // no i18n
+    }
+    QUEUES.forEach(function (name) {
+        if (!db.objectStoreNames.contains(name)) {
+            db.createObjectStore(name, { keyPath: 'id' }).createIndex(QUEUE_KEY, QUEUE_KEY); // no i18n
+        }
+    });
+    // kept stores: the order key is renamed on every record, and the index with it
+    QUEUES.forEach(function (name) {
+        const store = tx.objectStore(name);
+        if (!store.indexNames.contains(OLD_QUEUE_KEY)) {
+            return;
+        }
+        store.deleteIndex(OLD_QUEUE_KEY);
+        if (!store.indexNames.contains(QUEUE_KEY)) {
+            store.createIndex(QUEUE_KEY, QUEUE_KEY);
+        }
+        eachRecord(store, function (record, cursor) {
+            cursor.update(renamedRecord(record, false, name));
+        });
+    });
+    // renamed stores: every record moves to its new store, then the old store goes
+    RENAMED_STORES.forEach(function (pair) {
+        const from = pair[0];
+        const to = pair[1];
+        if (!db.objectStoreNames.contains(from)) {
+            return;
+        }
+        const source = tx.objectStore(from);
+        const target = tx.objectStore(to);
+        eachRecord(source, function (record) {
+            target.put(renamedRecord(record, to === 'feedbacklogs', to)); // no i18n
+        }, function () {
+            db.deleteObjectStore(from);
+        });
+    });
+}
+/** Calls `each` for every record of `store`, then `done`, inside the transaction `store` is in. */
+function eachRecord(store, each, done) {
+    const req = store.openCursor();
+    req.onsuccess = function () {
+        const cursor = req.result;
+        if (!cursor) {
+            if (done)
+                done();
+            return;
+        }
+        each(cursor.value, cursor);
+        cursor.continue();
+    };
+}
+/** A version 3 record under version 4's names: `queue` for `seq`, and the feedback types renamed. */
+function renamedRecord(record, feedback, storeName) {
+    const queue = typeof record[QUEUE_KEY] === 'number' ? record[QUEUE_KEY] : (typeof record[OLD_QUEUE_KEY] === 'number' ? record[OLD_QUEUE_KEY] : nextQueue()); // no i18n
+    const item = (feedback ? renameFeedbackType(record.item) : record.item);
+    return { id: String(record.id), queue: queue, type: recordType(storeName, item), item: item };
+}
+function createIndexedDBBackend(db) {
+    return {
+        kind: 'indexeddb', // no i18n
+        loadSettings() {
+            const store = db.transaction('settings', 'readonly').objectStore('settings'); // no i18n
+            return Promise.all([request(store.getAllKeys()), request(store.getAll())]).then(function ([keys, values]) {
+                const out = {};
+                keys.forEach(function (key, i) {
+                    out[String(key)] = values[i];
+                });
+                return out;
+            });
+        },
+        putSetting(key, value) {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').put(value, key); // no i18n
+            return completed(tx);
+        },
+        deleteSetting(key) {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').delete(key); // no i18n
+            return completed(tx);
+        },
+        clearSettings() {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').clear(); // no i18n
+            return completed(tx);
+        },
+        queueAll(store) {
+            const index = db.transaction(store, 'readonly').objectStore(store).index(QUEUE_KEY);
+            return request(index.getAll()).then(function (records) {
+                return records.map(function (record) { return record.item; });
+            });
+        },
+        queuePut(store, items) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            const objectStore = tx.objectStore(store);
+            items.forEach(function (item) { putRecord(objectStore, item, false); });
+            return completed(tx);
+        },
+        queueDelete(store, ids) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            const objectStore = tx.objectStore(store);
+            ids.forEach(function (id) { objectStore.delete(id); });
+            return completed(tx);
+        },
+        queueClear(store) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            tx.objectStore(store).clear();
+            return completed(tx);
+        },
+        importAll(settings, queues) {
+            // scope derived from QUEUES, not repeated: the loop below opens every one of them,
+            // and a store left out of the scope throws NotFoundError the moment it is reached
+            const tx = db.transaction(['settings'].concat(QUEUES), 'readwrite'); // no i18n
+            const settingsStore = tx.objectStore('settings'); // no i18n
+            Object.keys(settings).forEach(function (key) {
+                const lookup = settingsStore.get(key);
+                lookup.onsuccess = function () {
+                    if (lookup.result === undefined) {
+                        settingsStore.put(settings[key], key);
+                    }
+                };
+            });
+            QUEUES.forEach(function (name) {
+                const objectStore = tx.objectStore(name);
+                queues[name].forEach(function (item) { putRecord(objectStore, item, true); });
+            });
+            return completed(tx);
+        },
+    };
+}
+function localStorageUsable() {
+    try {
+        const probe = '__apptics_probe__'; // no i18n
+        localStorage.setItem(probe, '1');
+        localStorage.removeItem(probe);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/** IndexedDB when it opens, otherwise localStorage, otherwise null. Never rejects. */
+function openBackend() {
+    const fallback = function (reason) {
+        logger.Console.warn('apptics: IndexedDB unavailable (' + String(reason) + '), using localStorage'); // no i18n
+        return localStorageUsable() ? createLocalStorageBackend() : null;
+    };
+    let factory;
+    try {
+        factory = typeof indexedDB !== 'undefined' ? indexedDB : undefined; // no i18n
+    }
+    catch (err) {
+        factory = undefined; // access can throw in sandboxed frames
+    }
+    if (!factory) {
+        return Promise.resolve(fallback('not supported')); // no i18n
+    }
+    return openIndexedDB(factory).then(createIndexedDBBackend, fallback);
+}
+
+exports.DB_NAME = DB_NAME;
+exports.DB_VERSION = DB_VERSION;
+exports.FEEDBACK_DIAGNOSTICS = FEEDBACK_DIAGNOSTICS;
+exports.FEEDBACK_LOG = FEEDBACK_LOG;
+exports.LEGACY_KEYS = LEGACY_KEYS;
+exports.LOCAL_KEYS = LOCAL_KEYS;
+exports.asDict = asDict;
+exports.asList = asList;
+exports.createIndexedDBBackend = createIndexedDBBackend;
+exports.createLocalStorageBackend = createLocalStorageBackend;
+exports.openBackend = openBackend;
+exports.openIndexedDB = openIndexedDB;
+exports.renameFeedbackType = renameFeedbackType;

package/dist/cjs/core/debug.d.ts

@@ -0,0 +1,22 @@
+/** Whether debug mode is on right now, idle hour included. */
+export declare function debugEnabled(): boolean;
+/**
+ * Pushes the idle hour out. Called wherever something is actually tracked, which is the only
+ * evidence the SDK has that a person is still looking — there is no event for "watching".
+ */
+export declare function noteDebugActivity(): void;
+/**
+ * Turns debug mode off if its hour has run out. Called from the flush timer, which ticks whether
+ * or not anything is happening — a check that only ran on the way into a request would never
+ * fire, because an idle SDK makes no requests.
+ */
+export declare function expireDebugIfIdle(): void;
+/**
+ * Turns debug mode on, at any time: before init(), during start-up or while the SDK runs. The
+ * choice holds over `debug` in init() for the rest of the page's life.
+ */
+export declare function enableDebug(): void;
+/** Turns debug mode off, at any time, with the same hold over `debug` as enableDebug(). */
+export declare function disableDebug(): void;
+/** What init() applies for `debug`: the config's value, unless the app has already chosen. */
+export declare function applyDebugConfig(configured: boolean): void;

package/dist/cjs/core/debug.js

@@ -0,0 +1,88 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./constants.js');
+var state = require('./state.js');
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+
+/**
+ * The switch for debug mode, and the hour that closes it.
+ *
+ * Debug mode is not free on either side: every engagement, exception and log call goes to its
+ * `debug/` twin instead of the ordinary endpoint, which makes the server keep a traceable
+ * record of the request. That is worth it while someone is watching, and pure
+ * cost once they have walked away — and walking away is the normal way a debugging session ends,
+ * not a deliberate switch-off. So the SDK closes it: an hour with nothing tracked turns debug
+ * back off by itself, and anything tracked pushes that hour out again.
+ *
+ * It lives in core because every send asks it: `debug: true` in init(), or enableDebug(), is
+ * enough to turn the twins on, and that alone must expire.
+ */
+/** Whether debug mode is on right now, idle hour included. */
+function debugEnabled() {
+    return state._ZAP._config.debug_api === true && !debugIdle();
+}
+/** True once the idle hour has run out on a debug session nobody is watching. */
+function debugIdle() {
+    return state._ZAP._debugUntil > 0 && utils.nowMs() > state._ZAP._debugUntil;
+}
+/**
+ * Pushes the idle hour out. Called wherever something is actually tracked, which is the only
+ * evidence the SDK has that a person is still looking — there is no event for "watching".
+ */
+function noteDebugActivity() {
+    if (state._ZAP._config.debug_api !== true) {
+        return;
+    }
+    state._ZAP._debugUntil = utils.nowMs() + constants.DEBUG_IDLE_MS;
+}
+/**
+ * Turns debug mode off if its hour has run out. Called from the flush timer, which ticks whether
+ * or not anything is happening — a check that only ran on the way into a request would never
+ * fire, because an idle SDK makes no requests.
+ */
+function expireDebugIfIdle() {
+    if (!debugIdle()) {
+        return;
+    }
+    logger.Console.log('apptics: debug mode has been idle for an hour, switching it off'); // no i18n
+    setDebug(false);
+}
+/**
+ * The app's own choice, from enableDebug() or disableDebug(). It wins over `debug` in init(),
+ * so debug mode can be switched on or off with one call, before init() runs or while the SDK is
+ * running, and an init() or reset() that comes after doesn't switch it back. null until the app
+ * has chosen.
+ */
+var chosen = null;
+/** Turning it on starts the idle hour; turning it off clears it, so the next on gets a whole hour. */
+function setDebug(on) {
+    state._ZAP._config.debug_api = on;
+    state._ZAP._debugUntil = on ? utils.nowMs() + constants.DEBUG_IDLE_MS : 0;
+    logger.Console.log('apptics: debug mode ' + (on ? 'on' : 'off')); // no i18n
+}
+/**
+ * Turns debug mode on, at any time: before init(), during start-up or while the SDK runs. The
+ * choice holds over `debug` in init() for the rest of the page's life.
+ */
+function enableDebug() {
+    chosen = true;
+    setDebug(true);
+}
+/** Turns debug mode off, at any time, with the same hold over `debug` as enableDebug(). */
+function disableDebug() {
+    chosen = false;
+    setDebug(false);
+}
+/** What init() applies for `debug`: the config's value, unless the app has already chosen. */
+function applyDebugConfig(configured) {
+    setDebug(chosen !== null ? chosen : configured);
+}
+
+exports.applyDebugConfig = applyDebugConfig;
+exports.debugEnabled = debugEnabled;
+exports.disableDebug = disableDebug;
+exports.enableDebug = enableDebug;
+exports.expireDebugIfIdle = expireDebugIfIdle;
+exports.noteDebugActivity = noteDebugActivity;

package/dist/cjs/core/env.d.ts

@@ -0,0 +1,28 @@
+import type { AppticsConfig } from '../types.js';
+export declare function isBlockedWS(ua: string): boolean;
+/** Device RAM as the API wants it ("4 GB"). Chromium only; empty elsewhere. */
+export declare function getRam(): string;
+export declare function getConnectionType(): string;
+export declare function getNetworkStatus(): number;
+/**
+ * The battery as a whole percentage, or null where the browser will not say.
+ *
+ * feedbackWebSDK types `battery` as an int and the console shows it next to a report, which is
+ * what makes "it died while I was filling this in" legible. The Battery Status API is behind a
+ * promise and is absent in Firefox and Safari entirely, so this answers null rather than 0 -
+ * a real 0% and "no answer" are different things, and only one of them belongs in a report.
+ */
+export declare function getBatteryPercent(): Promise<number | null>;
+export declare function getOrientation(): number;
+export declare function getDevice(): string;
+export declare function getOS(): string;
+export declare function getBrowser(): string;
+export declare function getBrowserVersion(): number | string;
+export declare function getReferringURL(): string;
+export declare function getTimeZone(): string;
+/** True for crawlers and non-browser environments; the SDK does nothing for them. */
+export declare function is_apptics_disabled(): boolean;
+/** Pure DNT check (no side effects). consent.hasDoNotTrackEnabled() applies NO_TRACKING. */
+export declare function isDntOn(): boolean;
+/** The console snippet's config (window.appticssettings._defaultoptions), if the page defines one. */
+export declare function getSnippetOptions(): AppticsConfig | undefined;