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

package/dist/cjs/lifecycle.js

@@ -0,0 +1,734 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./core/constants.js');
+var state = require('./core/state.js');
+var logger = require('./core/logger.js');
+var utils = require('./core/utils.js');
+var storage = require('./core/storage.js');
+var hooks = require('./core/hooks.js');
+var debug = require('./core/debug.js');
+var env = require('./core/env.js');
+var index = require('./device/index.js');
+var appversion = require('./device/appversion.js');
+var session = require('./engagement/session.js');
+var autoApi = require('./engagement/auto-api.js');
+var autoScreen = require('./engagement/auto-screen.js');
+var track = require('./engagement/track.js');
+var track$1 = require('./errors/track.js');
+var scheduler = require('./scheduler.js');
+var send = require('./remotelog/send.js');
+var index$1 = require('./user/index.js');
+var attempts = require('./core/attempts.js');
+var frameworkId = require('./core/framework-id.js');
+
+let listenersAttached = false;
+/** The config init() was last called with; reset() starts again from it. */
+let lastConfig = null;
+/** Bumped by every init(); a start() from an earlier init() that was reset in between does nothing. */
+let generation = 0;
+function isBrowser() {
+    if (typeof window === 'undefined' || typeof document === 'undefined' || typeof Promise === 'undefined') { // no i18n
+        return false;
+    }
+    try {
+        return typeof indexedDB !== 'undefined' || !!window.localStorage; // no i18n
+    }
+    catch (err) {
+        return false; // storage access can throw in sandboxed frames
+    }
+}
+/**
+ * The config as the SDK keeps it: base_url, auth_key and app_domain under their inside names
+ * (serviceUrl, zak, identifier; see CONFIG_KEYS), and appversion as text. An earlier name of a
+ * key is still read when the key itself is not given, with a warning naming the key to use.
+ * The base url loses any trailing slash, because request paths add their own.
+ */
+function normaliseConfig(config) {
+    var settings = Object.assign({}, config);
+    Object.keys(constants.CONFIG_KEYS).forEach(function (key) {
+        var inside = constants.CONFIG_KEYS[key];
+        if (!utils.isEmpty(config[key])) {
+            settings[inside] = config[key];
+            return;
+        }
+        delete settings[inside];
+        Object.keys(constants.RETIRED_CONFIG_NAMES).forEach(function (old) {
+            if (constants.RETIRED_CONFIG_NAMES[old] !== key || utils.isEmpty(config[old])) {
+                return;
+            }
+            logger.warnAlways('Apptics.init: ' + old + ' is now ' + key + '; rename it in your config'); // no i18n
+            if (utils.isEmpty(settings[inside])) {
+                settings[inside] = config[old];
+            }
+        });
+    });
+    if (!utils.isEmpty(settings.serviceUrl)) {
+        settings.serviceUrl = String(settings.serviceUrl).replace(/\/+$/, ''); // no i18n
+    }
+    settings.appversion = appVersionText(settings.appversion);
+    return settings;
+}
+/**
+ * The version as the text it is stored and sent as: a string trimmed, a finite number as its digits.
+ * Anything else — blank, NaN, an object — is '', which init() reports as missing.
+ */
+function appVersionText(value) {
+    if (typeof value === 'number') { // no i18n
+        return isFinite(value) ? String(value) : ''; // no i18n
+    }
+    return typeof value === 'string' ? value.trim() : ''; // no i18n
+}
+/**
+ * The placeholders the console's snippets and the docs show for appversion. Starting with one
+ * would register a version that was never shipped, and every visit after it would report under it.
+ */
+const APPVERSION_PLACEHOLDERS = ['YOUR_APP_VERSION', 'YOUR_BUILD_OR_APP_VERSION', 'YOUR_APPVERSION']; // no i18n
+function isAppVersionPlaceholder(version) {
+    return APPVERSION_PLACEHOLDERS.indexOf(version.toUpperCase()) !== -1;
+}
+/**
+ * The framework id this SDK reports to serviceUrl. The id built into the package is the one
+ * sdk-apptics.zoho.com issued at publish time, and localzoho servers don't know it: any
+ * localzoho serviceUrl reports 5970 instead, the id apptics.localzoho.com issued for 2.0.0-beta
+ * (Browser), so the same package also runs there.
+ */
+const LOCALZOHO_FRAMEWORK_ID = 5970;
+function frameworkIdFor(serviceUrl) {
+    var host = serviceUrl;
+    try {
+        host = new URL(serviceUrl).hostname;
+    }
+    catch (err) {
+        // not a url: judge the text as it is
+    }
+    return host.indexOf('localzoho') !== -1 ? LOCALZOHO_FRAMEWORK_ID : frameworkId.FRAMEWORK_ID; // no i18n
+}
+/** Which app this browser's stored data belongs to, before app/addversion has named it. */
+function appKey(settings) {
+    return settings.serviceUrl + '|' + settings.identifier; // no i18n
+}
+/**
+ * The app version stored data belongs to, read before app/addversion replaces it: what tells a
+ * new release of the app from a reload. '' on a first visit.
+ */
+var previousAppVersion = ''; // no i18n
+/**
+ * Data stored for another app on this origin is discarded before anything else reads it,
+ * including the stored app/addversion answer that would otherwise hand out that app's ids.
+ */
+function discardOtherAppData(settings) {
+    // which app it is, and which version, are in app_version_info (serviceUrl, identifier and
+    // appversion): no keys of their own. 2.0.0-beta's appkey and appversion are read this once
+    var info = storage.user_defaults.item('app_version_info') || {}; // no i18n
+    var stored = !utils.isEmpty(info.serviceUrl) && !utils.isEmpty(info.identifier)
+        ? appKey(info)
+        : storage.user_defaults.item('appkey'); // no i18n
+    previousAppVersion = String((!utils.isEmpty(info.appversion) ? info.appversion : storage.user_defaults.item('appversion')) || ''); // no i18n
+    storage.user_defaults.add('appkey', undefined); // no i18n
+    storage.user_defaults.add('appversion', undefined); // no i18n
+    if (!utils.isEmpty(stored) && stored !== appKey(settings)) {
+        logger.Console.log('init: stored data belongs to another app, resetting'); // no i18n
+        clearStorage();
+        previousAppVersion = ''; // no i18n
+    }
+}
+/**
+ * Timing an app may tune in init(). Each has a range: a value outside it is ignored with a
+ * warning rather than applied, since a 10 ms flush interval would hammer the server.
+ */
+const TUNABLE = Object.freeze([
+    { key: 'batch_flush_interval', min: 1000, max: 3600000 }, // no i18n
+    { key: 'getupdates_interval', min: 10000, max: 86400000 }, // no i18n
+    { key: 'batch_size', min: 1, max: 500 }, // no i18n
+    { key: 'batch_request_timeout', min: 1, max: 30 }, // no i18n
+    { key: 'min_session_duration', min: 0, max: 60000 }, // no i18n
+    { key: 'heatmap_max_per_session', min: 0, max: 10000 }, // no i18n
+]);
+/** Reads the tunable timings out of the config. Anything missing goes back to its default. */
+function applyIntervals(config) {
+    TUNABLE.forEach(function (rule) {
+        var value = config[rule.key];
+        // every init() decides these on its own, so a value from an earlier one never lingers
+        state._ZAP._config[rule.key] = constants.AP_CONFIG[rule.key];
+        if (utils.isEmpty(value)) {
+            return;
+        }
+        var num = Number(value);
+        if (!isFinite(num) || num < rule.min || num > rule.max) {
+            logger.warnAlways('Apptics.init: ' + rule.key + ' must be between ' + rule.min + ' and ' + rule.max + ', keeping ' + state._ZAP._config[rule.key]); // no i18n
+            return;
+        }
+        state._ZAP._config[rule.key] = num;
+        logger.Console.log('Apptics.init: ' + rule.key + ' set to ' + num); // no i18n
+    });
+    // inactiveduration lives on state, not in _config
+    state._ZAP.inactiveduration = constants.DEFAULT_INACTIVE_MINUTES;
+    if (!utils.isEmpty(config.inactiveduration)) {
+        var minutes = Number(config.inactiveduration);
+        if (!isFinite(minutes) || minutes < 1 || minutes > 1440) {
+            logger.warnAlways('Apptics.init: inactiveduration must be between 1 and 1440 minutes, keeping ' + state._ZAP.inactiveduration); // no i18n
+        }
+        else {
+            state._ZAP.inactiveduration = minutes;
+            logger.Console.log('Apptics.init: inactiveduration set to ' + minutes); // no i18n
+        }
+    }
+}
+function clearStorage() {
+    attempts.clearAttempts();
+    storage.user_defaults.clear();
+    storage.engagement_transactions.clear();
+    storage.error_transactions.clear();
+}
+/**
+ * Starts the SDK. The config object is required: pass it directly, or let the console snippet
+ * supply it (auto-init reads window.appticssettings._defaultoptions and calls init with it).
+ * Returns true when the config has base_url, auth_key, app_domain and appversion and start-up has
+ * begun (see ready()), false when it was already running, the config is missing or incomplete, or
+ * there is no browser. Start-up calls app/addversion with those four, which answers with aaid, the
+ * portal and project ids and the rest; then device/add registers the browser, as in 1.x.
+ */
+function init(config) {
+    if (!config || typeof config !== 'object') { // no i18n
+        logger.warnAlways('Apptics.init: a config object is required, e.g. Apptics.init({ base_url, auth_key, app_domain, appversion })'); // no i18n
+        return false;
+    }
+    if (state._ZAP._initialised) {
+        logger.Console.warn('Apptics.init: already initialised; call Apptics.reset() to start again'); // no i18n
+        return false;
+    }
+    if (!isBrowser()) {
+        logger.warnAlways('Apptics.init: skipped, no browser with storage and Promise support'); // no i18n
+        return false;
+    }
+    var settings = normaliseConfig(config);
+    var missing = constants.REQUIRED_CONFIG.filter(function (key) {
+        return utils.isEmpty(settings[constants.CONFIG_KEYS[key] || key]);
+    });
+    if (missing.length > 0) {
+        logger.warnAlways('Apptics.init: missing required config: ' + missing.join(', ')); // no i18n
+        return false;
+    }
+    if (isAppVersionPlaceholder(settings.appversion)) {
+        logger.warnAlways('Apptics.init: appversion is still the placeholder "' + settings.appversion // no i18n
+            + '"; replace it with your app\'s version or build number, e.g. \'2.4.0\''); // no i18n
+        return false;
+    }
+    state._ZAP._defaultoptions = settings;
+    // every request goes to serviceUrl; there is no other host to learn about
+    state._ZAP._defaultoptions.base_domain = settings.serviceUrl;
+    // decided per init(), so a reset() or a page on another host never keeps the last one
+    state._ZAP._frameworkID = frameworkIdFor(settings.serviceUrl);
+    // marks the SDK as started for the checks that need it; app/addversion replaces it with aaid
+    state._ZAP._token = settings.identifier;
+    // console_log: the SDK's own activity in the browser console
+    if (!utils.isEmpty(config.console_log)) {
+        state._ZAP._config.debug = !!config.console_log;
+    }
+    if (typeof config.ignore_do_not_track === 'boolean') { // no i18n
+        state._ZAP._config.ignore_do_not_track = config.ignore_do_not_track;
+    }
+    // debug: debug mode, the debug endpoints. Same payloads, but the answer says where to trace the
+    // request. debug_api is its earlier name and still works; debug wins when both are given
+    state._ZAP._config.debug_api = typeof config.debug === 'boolean' ? config.debug // no i18n
+        : typeof config.debug_api === 'boolean' ? config.debug_api : constants.AP_CONFIG.debug_api; // no i18n
+    // starts (or clears) the idle hour that closes debug mode on its own
+    // an enableDebug() or disableDebug() call the app already made wins over the config
+    debug.applyDebugConfig(state._ZAP._config.debug_api);
+    // what to call this device in the debug stream; see devicename in core/transport.ts
+    state._ZAP._config.device_name = typeof config.device_name === 'string' ? config.device_name : constants.AP_CONFIG.device_name; // no i18n
+    // the SDK no longer reports its own failures to the Remote Logger page: only the lines an app
+    // logs with AppticsLogger go there
+    if (config.remote_log !== undefined) {
+        logger.warnAlways('Apptics.init: remote_log is no longer read; the Remote Logger page shows the lines your app logs with AppticsLogger'); // no i18n
+    }
+    // AppticsLogger lines go to the Remote Logger page only, never to the browser console
+    if (config.show_logs !== undefined) {
+        logger.warnAlways('Apptics.init: show_logs is no longer read; AppticsLogger lines are not printed to the browser console'); // no i18n
+    }
+    // automatic api tracking: the app's own requests, wrapped. Which hosts it records is
+    // configureApiTracking's to say; the two keys that once did it are refused out loud rather
+    // than quietly ignored, since an app relying on them would otherwise record hosts it meant not to
+    state._ZAP._config.track_api = constants.AP_CONFIG.track_api;
+    ['track_api_hosts', 'track_api_exclude_hosts'].forEach(function (key) {
+        if (config[key] !== undefined) {
+            logger.warnAlways('Apptics.init: ' + key + ' is no longer supported; use AppticsApi.configure(new AppticsApi.ApiTrackingBuilder().' // no i18n
+                + (key === 'track_api_hosts' ? 'allowOnlyDomains' : 'ignoreDomains') + '(...).build())'); // no i18n
+        }
+    });
+    // screen recording is set up in the console now, and arrives with getsdkconfig
+    ['DC', 'quartz_workspace_key', 'quartz_department_key'].forEach(function (key) {
+        if (config[key] !== undefined) {
+            logger.warnAlways('Apptics.init: ' + key + ' is no longer read; screen recording in the feedback form is set up from the Apptics console'); // no i18n
+        }
+    });
+    // sessions are what everything else is recorded in; an app that wants nothing tracked uses
+    // AppticsSettings.setTrackingStatus instead
+    if (config.track_session !== undefined) {
+        logger.warnAlways('Apptics.init: track_session is no longer read; sessions are always recorded. To stop tracking, use AppticsSettings.setTrackingStatus(AppticsSettings.AP_TRACKING_STATUS.NO_TRACKING)'); // no i18n
+    }
+    if (typeof config.track_api === 'boolean') { // no i18n
+        state._ZAP._config.track_api = config.track_api;
+    }
+    autoApi.enableApiTracking(state._ZAP._config.track_api);
+    // heatmap capture: switched through the hook heatmap/track.ts sets
+    state._ZAP._config.track_heatmap = typeof config.track_heatmap === 'boolean' // no i18n
+        ? config.track_heatmap
+        : constants.AP_CONFIG.track_heatmap;
+    hooks.hooks.trackHeatmap(state._ZAP._config.track_heatmap);
+    // automatic screen tracking, on unless the config says false: switched on by start(), once a
+    // screen view can be stored
+    state._ZAP._config.track_screen = typeof config.track_screen === 'boolean' ? config.track_screen : constants.AP_CONFIG.track_screen; // no i18n
+    state._ZAP._config.screen_routes = screenRouteRules(config.screen_routes);
+    // a theme in the config wins; without one, what AppticsFeedback.setFeedbackTheme set stays
+    if (config.feedback_theme === 'light' || config.feedback_theme === 'dark' || config.feedback_theme === 'auto') { // no i18n
+        state._ZAP._config.feedback_theme = config.feedback_theme;
+    }
+    applyIntervals(config);
+    lastConfig = config;
+    state._ZAP._initialised = true;
+    state._ZAP._ready = false;
+    state._ZAP._pending = [];
+    var myGeneration = ++generation;
+    state._ZAP._readyPromise = storage.storageReady().then(function (backend) {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        if (!backend) {
+            logger.warnAlways('Apptics.init: no usable storage (IndexedDB or localStorage), not starting'); // no i18n
+            state._ZAP._initialised = false;
+            state._ZAP._token = ''; // no i18n
+            state._ZAP._pending = [];
+            return false;
+        }
+        discardOtherAppData(state._ZAP._defaultoptions);
+        // app/addversion is the first call and everything waits on it: it is what turns the four
+        // values init() was given into aaid, the portal and project ids every url carries, and
+        // appreleaseversionid, which metaWebSDKV2 refuses a payload without
+        return appversion.registerAppVersion().then(function (registered) {
+            if (myGeneration !== generation) {
+                return false;
+            }
+            if (!registered && appversion.appVersionFailedForNetwork()) {
+                // a first visit with no network: start once it is back, keeping what the app
+                // tracks until then queued, rather than giving up for the rest of the page
+                logger.warnAlways('Apptics.init: offline, so app/addversion is tried again when the browser is back online; calls made until then are kept'); // no i18n
+                return registerWhenOnline(myGeneration).then(function (ok) {
+                    if (myGeneration !== generation) {
+                        return false;
+                    }
+                    if (!ok) {
+                        state._ZAP._initialised = false;
+                        state._ZAP._token = ''; // no i18n
+                        state._ZAP._pending = [];
+                        return false;
+                    }
+                    return start(config, myGeneration);
+                });
+            }
+            if (!registered) {
+                logger.warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
+                state._ZAP._initialised = false;
+                state._ZAP._token = ''; // no i18n
+                state._ZAP._pending = [];
+                return false;
+            }
+            return start(config, myGeneration);
+        });
+    }).catch(function (err) {
+        logger.Console.error('Apptics.init: start-up failed', err); // no i18n
+        return false;
+    });
+    return true;
+}
+/** How often a start-up waiting on the network tries app/addversion again, besides on `online`. */
+const OFFLINE_RETRY_MS = 60 * 1000;
+/**
+ * app/addversion again once the network is back: on the `online` event, and every minute for a
+ * network that came back without one. Resolves true once registered, false when the server
+ * refuses it or a reset()/new init() took over.
+ */
+function registerWhenOnline(myGeneration) {
+    return new Promise(function (resolve) {
+        var timer = null;
+        var trying = false;
+        function done(ok) {
+            window.removeEventListener('online', attempt); // no i18n
+            if (timer !== null)
+                clearInterval(timer);
+            resolve(ok);
+        }
+        function attempt() {
+            if (myGeneration !== generation) {
+                done(false);
+                return;
+            }
+            if (trying || navigator.onLine === false) {
+                return;
+            }
+            trying = true;
+            appversion.registerAppVersion().then(function (registered) {
+                trying = false;
+                if (registered) {
+                    done(true);
+                }
+                else if (!appversion.appVersionFailedForNetwork()) {
+                    logger.warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
+                    done(false);
+                }
+            });
+        }
+        window.addEventListener('online', attempt); // no i18n
+        timer = setInterval(attempt, OFFLINE_RETRY_MS);
+    });
+}
+/**
+ * screen_routes as init() keeps it: each entry checked, an exact path cleaned up, a regex given as
+ * a string compiled. An entry that cannot be used is left out, and said, rather than matching
+ * something its author did not mean.
+ */
+function screenRouteRules(routes) {
+    if (!Array.isArray(routes)) {
+        return [];
+    }
+    var out = [];
+    routes.forEach(function (route) {
+        if (typeof route === 'string') { // no i18n
+            if (route.trim() !== '') { // no i18n
+                out.push({ kind: 'pattern', pattern: route.trim() }); // no i18n
+            }
+            return;
+        }
+        var rule = route && typeof route === 'object' ? route : null; // no i18n
+        var name = rule && typeof rule.name === 'string' ? rule.name.trim() : ''; // no i18n
+        if (rule && name !== '' && typeof rule.equals === 'string' && rule.equals.trim() !== '') { // no i18n
+            out.push({ kind: 'equals', path: autoScreen.routePath(rule.equals.trim()), name: name }); // no i18n
+            return;
+        }
+        if (rule && name !== '' && rule.regex !== undefined) {
+            var regex = null;
+            if (rule.regex instanceof RegExp) {
+                regex = rule.regex;
+            }
+            else if (typeof rule.regex === 'string' && rule.regex !== '') { // no i18n
+                try {
+                    regex = new RegExp(rule.regex);
+                }
+                catch (err) {
+                    regex = null;
+                }
+            }
+            if (regex) {
+                out.push({ kind: 'regex', regex: regex, name: name }); // no i18n
+                return;
+            }
+        }
+        logger.warnAlways('Apptics.init: screen_routes entry ' + safeJson(route) + ' is left out: give a route pattern, { equals, name } or { regex, name }'); // no i18n
+    });
+    return out;
+}
+/** An entry as the warning shows it: a RegExp as its source, which JSON.stringify would hide. */
+function safeJson(value) {
+    try {
+        return JSON.stringify(value, function (_key, one) { return one instanceof RegExp ? String(one) : one; }) || String(value);
+    }
+    catch (err) {
+        return String(value);
+    }
+}
+/** Resolves true once start-up has finished, false if init() refused or storage is unusable. */
+function ready() {
+    return state._ZAP._readyPromise || Promise.resolve(false);
+}
+function start(config, myGeneration) {
+    // this tab's lock, before any screen view: it is how other tabs tell this one is still open
+    session.holdTabLock();
+    // app/addversion named the app; data stored for another one was discarded before it ran
+    state._ZAP._token = String(state._ZAP._defaultoptions.aaid);
+    // last known server settings (getupdates) apply before anything is tracked
+    index.restoreServerSettings();
+    // a new release of the app, against the version the stored data was for (see
+    // discardOtherAppData): a first visit has none, and is no change
+    var appVersionChanged = previousAppVersion !== '' && previousAppVersion != state._ZAP._defaultoptions.appversion; // no i18n
+    state._ZAP._ignoreDnt = state._ZAP._config.ignore_do_not_track;
+    // the visitor's own stored choice, not getTrackingStatus(): that answers NO_TRACKING while Do
+    // Not Track is on, and storing it made one such visit switch tracking off for good
+    storage.tracking_preference.update_status(storage.tracking_preference.opt_in_status());
+    // the uuid and device info, and a registration on a first visit, under a lock shared with the
+    // site's other tabs (see prepareDevice)
+    return index.prepareDevice().then(function () {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        return startTracking(appVersionChanged, myGeneration);
+    });
+}
+/** The rest of start-up, once the device is set up. */
+function startTracking(appVersionChanged, myGeneration) {
+    // no getsdkconfig here, straight after app/addversion: it is asked for once device/add has
+    // succeeded (registerDeviceWithApptics), then every getupdates_interval. A returning visit
+    // starts from the settings saved by the last one (restoreServerSettings, in start())
+    if (appVersionChanged) {
+        state._ZAP._device_info.appversionid = ''; // no i18n
+        index.updateDeviceWithApptics(state._ZAP._device_info).then(function (result) {
+            if (utils.isSuccess(result)) {
+                logger.Console.log('init: appversion updated to ' + state._ZAP._defaultoptions.appversion); // no i18n
+            }
+        }).catch(function (err) {
+            logger.Console.log('init: error updating appversion: ' + err); // no i18n
+        });
+    }
+    // attempt to resolve connection type
+    state._ZAP._device_info.connectionType = env.getConnectionType();
+    attachListeners();
+    state._ZAP._properties.orientation = env.getOrientation();
+    index$1.getUserInfo();
+    return session.checkAndUpdateSession().then(function () {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        scheduler.startTimers();
+        send.sendStoredLogs();
+        state._ZAP._ready = true;
+        // replay calls made while storage was loading, in order
+        var pending = state._ZAP._pending;
+        state._ZAP._pending = [];
+        pending.forEach(function (call) {
+            try {
+                call();
+            }
+            catch (err) {
+                logger.Console.error('apptics: buffered call failed', err); // no i18n
+            }
+        });
+        // after the replay, so a inScreen() the app made during start-up keeps its place, and
+        // the first automatic view is the page as it is now
+        autoScreen.enableScreenTracking(state._ZAP._config.track_screen);
+        // a no-op unless the remote-config entry was imported, which sets the hook
+        hooks.hooks.remoteConfigStarted();
+        window.appticsReadyStatus = true;
+        if (typeof window.appticsReady == 'function') { // no i18n
+            window.appticsReady();
+        }
+        return true;
+    });
+}
+/** Clears stored identity and queues, then starts again from the snippet. */
+function reset() {
+    generation++;
+    scheduler.stopTimers();
+    // the wrappers come off with everything else; the init() below puts them back if the config
+    // asked for them, so a reset that has no config to restore leaves XHR and fetch untouched
+    autoApi.enableApiTracking(false);
+    autoScreen.enableScreenTracking(false);
+    appversion.clearAppVersion();
+    hooks.hooks.trackHeatmap(false);
+    hooks.hooks.resetHeatmap();
+    hooks.hooks.resetRemoteConfig();
+    clearStorage();
+    state._ZAP._initialised = false;
+    state._ZAP._ready = false;
+    state._ZAP._pending = [];
+    state._ZAP._readyPromise = null;
+    state._ZAP._device_info = {};
+    state._ZAP._user_info = {};
+    state._ZAP._current_screen = {};
+    state._ZAP._current_session = {};
+    state._ZAP._uuid = ''; // no i18n
+    state._ZAP._apid = ''; // no i18n
+    state._ZAP._mapid = ''; // no i18n
+    state._ZAP._sending = false;
+    logger.Console.log('Apptics.reset()'); // no i18n
+    // start again with the config init() was called with
+    if (lastConfig) {
+        init(lastConfig);
+    }
+}
+function isActive() {
+    return state._ZAP._ready;
+}
+/**
+ * A click-tracking attribute, in either spelling: `apeventaction`, or `data-apeventaction`, which
+ * is valid HTML and what React and TypeScript accept without declaring the attribute.
+ */
+function trackingAttribute(el, name) {
+    var value = el.getAttribute(name);
+    return value !== null && value !== '' ? value : el.getAttribute('data-' + name); // no i18n
+}
+/** `[name]` and `[data-name]`, empty values left out, for closest(). */
+function trackingSelector(name) {
+    return '[' + name + ']:not([' + name + '=""]),[data-' + name + ']:not([data-' + name + '=""])'; // no i18n
+}
+// Declarative click tracking: <el apeventaction="name" apeventprops='{"k":"v"}'> inside <el apgroupaction="group">,
+// or the same attributes with a data- prefix
+function onDocumentClick(event) {
+    if (!window.appticsReadyStatus || !isActive()) {
+        return;
+    }
+    var start = event.target;
+    if (start && typeof start.closest !== 'function') { // no i18n
+        start = start.parentElement;
+    }
+    if (!start) {
+        return;
+    }
+    var targetElem = start.closest(trackingSelector('apeventaction')); // no i18n
+    if (!targetElem) {
+        return;
+    }
+    var eventName = trackingAttribute(targetElem, 'apeventaction') || ''; // no i18n
+    var groupElem = targetElem.closest(trackingSelector('apgroupaction')); // no i18n
+    var groupName = (groupElem && trackingAttribute(groupElem, 'apgroupaction')) || constants.AP_CONFIG.default_group_name; // no i18n
+    var eventProps = {};
+    var rawProps = trackingAttribute(targetElem, 'apeventprops'); // no i18n
+    if (!utils.isEmpty(rawProps)) {
+        try {
+            eventProps = JSON.parse(rawProps);
+        }
+        catch (err) {
+            logger.Console.warn('apptics: invalid JSON in apeventprops for "' + eventName + '", sending no properties'); // no i18n
+            eventProps = {};
+        }
+    }
+    if (!utils.isEmpty(eventName)) {
+        track.trackEvent(eventName, groupName, eventProps);
+    }
+}
+/**
+ * Page is in the background but still there: close the open screen and send what's queued.
+ * By keepalive, because hidden is often the last moment before the tab closes, and a send still
+ * waiting on its answer would hold the queue as pagehide tries to send it.
+ */
+function onPageHidden() {
+    if (!isActive())
+        return;
+    session.updateScreenWithEndtime();
+    scheduler.flush(true);
+    logger.Console.log('page hidden: closing the open screen and flushing'); // no i18n
+}
+/**
+ * The tab is closing, or the page is being replaced or frozen into the back/forward cache.
+ * The session ends here, and everything queued goes out by keepalive, since a normal
+ * request would be cancelled with the page.
+ */
+function onPageClosing() {
+    if (!isActive())
+        return;
+    logger.Console.log('page closing: ending the session and sending what is queued'); // no i18n
+    session.updateScreenWithEndtime();
+    send.forgetStoredLogs();
+    session.endCurrentSession().then(function () {
+        return scheduler.flush(true);
+    });
+}
+function attachListeners() {
+    if (listenersAttached) {
+        return;
+    }
+    listenersAttached = true;
+    // listen for connection change events (only available in w3c implementation)
+    var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.addEventListener) {
+        connection.addEventListener('change', function () {
+            state._ZAP._device_info.connectionType = env.getConnectionType();
+        });
+    }
+    // Track when the window loses focus (user switches to another window or application)
+    window.addEventListener('blur', function () {
+        if (!isActive())
+            return;
+        logger.Console.log('Window lost focus, user switched to another window or application'); // no i18n
+        session.updateLastActiveTimeOfSession();
+    });
+    // Track when the window gains focus (user switches back to the window)
+    window.addEventListener('focus', function () {
+        if (!isActive())
+            return;
+        logger.Console.log('Window regained focus, user switched back to the window'); // no i18n
+        session.checkAndUpdateSession();
+        scheduler.startTimers();
+    });
+    // IndexedDB writes are async, so unload work starts on pagehide rather than beforeunload
+    window.addEventListener('pagehide', onPageClosing); // no i18n
+    // back/forward cache: pagehide ended the session, so coming back starts a new one
+    window.addEventListener('pageshow', function (event) {
+        if (!isActive() || !event.persisted)
+            return;
+        logger.Console.log('restored from the back/forward cache: starting a new session'); // no i18n
+        // the screen the page was left on starts a new view, in the new session
+        session.checkAndUpdateSession().then(track.resumeScreen);
+        scheduler.startTimers();
+    });
+    document.addEventListener('visibilitychange', function () {
+        if (!isActive())
+            return;
+        if (document.visibilityState === 'hidden') { // no i18n
+            onPageHidden();
+            return;
+        }
+        // back in view: the server's tracking flags may have changed while we were away
+        logger.Console.log('page visible: refreshing the server settings'); // no i18n
+        // hiding ended the screen view; the screen the user is back on starts a new one, after the
+        // session is settled so the view belongs to the right one
+        session.checkAndUpdateSession().then(track.resumeScreen);
+        index.refreshServerSettings();
+    });
+    // if we are running in cordova use ondeviceready otherwise onload
+    window.addEventListener(window.cordova ? 'deviceready' : 'load', function () {
+        if (isActive())
+            session.checkAndUpdateSession();
+    }, { passive: true });
+    // Always send pending requests when the connection comes back online
+    window.addEventListener('online', function () {
+        if (!isActive())
+            return;
+        // a first visit that started offline has no device ids yet, and nothing can be sent
+        // until it has them: register before flushing, and flush once that has landed
+        if (index.needsDevice()) {
+            logger.Console.log('back online: registering this device before sending'); // no i18n
+            // the same locked path as start-up, so two tabs coming back online register it once
+            index.prepareDevice().then(index.deviceReady).then(function () {
+                if (!isActive())
+                    return;
+                scheduler.flush();
+                // the lines logged while offline are waiting too, and log/add needs the same ids
+                send.sendStoredLogs();
+            });
+            return;
+        }
+        scheduler.flush();
+        send.sendStoredLogs();
+    }, { passive: true });
+    if (window.screen && window.screen.orientation && typeof window.screen.orientation.addEventListener === 'function') { // no i18n
+        window.screen.orientation.addEventListener('change', function () {
+            state._ZAP._properties.orientation = env.getOrientation();
+        });
+    }
+    window.addEventListener('unhandledrejection', function (event) {
+        if (isActive() && state._ZAP._isGlobalErrorTracking) {
+            track$1.trackError(event);
+        }
+    });
+    // in the capture phase: a <script>, <img> or <link> that fails to load fires `error` on the
+    // element, and it does not bubble, so a bubbling listener never hears of it. One listener
+    // hears both kinds, the window's own errors included, so none is counted twice
+    window.addEventListener('error', function (event) {
+        if (!isActive() || !state._ZAP._isGlobalErrorTracking) {
+            return;
+        }
+        var target = event.target;
+        if (target && target !== window && typeof target.tagName === 'string') { // no i18n
+            // named by describeTarget: Event "error" on <script src="...">
+            track$1.trackError({ type: 'error', reason: event }); // no i18n
+            return;
+        }
+        track$1.trackError(event);
+    }, true);
+    window.addEventListener('click', onDocumentClick, true); // no i18n
+}
+
+exports.init = init;
+exports.ready = ready;
+exports.reset = reset;
+exports.screenRouteRules = screenRouteRules;