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

package/dist/cjs/lifecycle.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @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');
@@ -9,7 +9,6 @@ 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 consent = require('./core/consent.js');
 var index = require('./device/index.js');
 var appversion = require('./device/appversion.js');
 var session = require('./engagement/session.js');
@@ -18,10 +17,10 @@ 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');
-require('./remotelog/index.js');
+var send = require('./remotelog/send.js');
 var index$1 = require('./user/index.js');
 var attempts = require('./core/attempts.js');
-var send = require('./remotelog/send.js');
+var frameworkId = require('./core/framework-id.js');
 
 let listenersAttached = false;
 /** The config init() was last called with; reset() starts again from it. */
@@ -40,16 +39,29 @@ function isBrowser() {
     }
 }
 /**
- * Canonical config: serviceUrl, zak, identifier, appversion.
- * The console snippet uses older names (base_domain, token), which are accepted here.
- * serviceUrl loses any trailing slash, because request paths add their own.
+ * 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_ALIASES).forEach(function (key) {
-        if (utils.isEmpty(settings[key]) && !utils.isEmpty(settings[constants.CONFIG_ALIASES[key]])) {
-            settings[key] = settings[constants.CONFIG_ALIASES[key]];
+    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
@@ -75,21 +87,51 @@ const APPVERSION_PLACEHOLDERS = ['YOUR_APP_VERSION', 'YOUR_BUILD_OR_APP_VERSION'
 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) {
-    var stored = storage.user_defaults.item('appkey'); // no i18n
+    // 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
     }
-    storage.user_defaults.add('appkey', appKey(settings)); // no i18n
 }
 /**
  * Timing an app may tune in init(). Each has a range: a value outside it is ignored with a
@@ -142,18 +184,18 @@ function clearStorage() {
 /**
  * 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 serviceUrl, zak, identifier and appversion and start-up has
+ * 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({ serviceUrl, zak, identifier, appversion })'); // 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
+        logger.Console.warn('Apptics.init: already initialised; call Apptics.reset() to start again'); // no i18n
         return false;
     }
     if (!isBrowser()) {
@@ -162,7 +204,7 @@ function init(config) {
     }
     var settings = normaliseConfig(config);
     var missing = constants.REQUIRED_CONFIG.filter(function (key) {
-        return utils.isEmpty(settings[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
@@ -176,16 +218,14 @@ function init(config) {
     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;
     }
-    // track_session: false records no sessions, as Android's automaticSessionsTrackingStatus
-    state._ZAP._config.track_session = typeof config.track_session === 'boolean' ? config.track_session : constants.AP_CONFIG.track_session; // no i18n
-    // show_logs: the app's own logger lines in the browser console, as Android's showLogs
-    state._ZAP._config.show_logs = typeof config.show_logs === 'boolean' ? config.show_logs : constants.AP_CONFIG.show_logs; // no i18n
     if (typeof config.ignore_do_not_track === 'boolean') { // no i18n
         state._ZAP._config.ignore_do_not_track = config.ignore_do_not_track;
     }
@@ -198,10 +238,14 @@ function init(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
-    // remote logging: the SDK's own diagnostics, sent to console/addlog
-    state._ZAP._config.remote_log = constants.AP_CONFIG.remote_log;
-    if (typeof config.remote_log === 'boolean') { // no i18n
-        state._ZAP._config.remote_log = config.remote_log;
+    // 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
@@ -209,22 +253,38 @@ function init(config) {
     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 configureApiTracking(new ApiTrackingBuilder().' // no i18n
+            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: a no-op unless the app imported the heatmap entry, which sets the hook
+    // 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.enableHeatmap(state._ZAP._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;
@@ -250,6 +310,23 @@ function init(config) {
             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;
@@ -265,42 +342,137 @@ function init(config) {
     });
     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);
-    storage.user_defaults.add('token', state._ZAP._token); // no i18n
     // last known server settings (getupdates) apply before anything is tracked
     index.restoreServerSettings();
-    // required by init(), so _defaultoptions.appversion is always the app's own version, as the
-    // text normaliseConfig made of it: there is no default to fall back to, and the stored value
-    // below is kept only to notice when the version changes
-    var uuid = storage.user_defaults.item('uuid'); // no i18n
-    if (utils.isEmpty(uuid)) {
-        uuid = utils.getNewUUID();
-        storage.user_defaults.add('uuid', uuid); // no i18n
-    }
-    state._ZAP._uuid = uuid;
-    var stored_appversion = storage.user_defaults.item('appversion'); // no i18n
-    if (utils.isEmpty(stored_appversion)) {
-        storage.user_defaults.add('appversion', state._ZAP._defaultoptions.appversion); // no i18n
-        stored_appversion = state._ZAP._defaultoptions.appversion;
-    }
-    var appVersionChanged = stored_appversion != state._ZAP._defaultoptions.appversion;
+    // 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;
-    storage.tracking_preference.update_status(consent.getTrackingStatus());
-    index.checkAndUpdateDeviceInfo();
-    // returning visit: ask the server for its settings now instead of waiting 2 minutes
-    // (first visit: device/add triggers it once the ids exist)
-    index.refreshServerSettings();
+    // 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)) {
-                storage.user_defaults.add('appversion', state._ZAP._defaultoptions.appversion); // no i18n
                 logger.Console.log('init: appversion updated to ' + state._ZAP._defaultoptions.appversion); // no i18n
             }
         }).catch(function (err) {
@@ -351,7 +523,7 @@ function reset() {
     autoApi.enableApiTracking(false);
     autoScreen.enableScreenTracking(false);
     appversion.clearAppVersion();
-    hooks.hooks.enableHeatmap(false);
+    hooks.hooks.trackHeatmap(false);
     hooks.hooks.resetHeatmap();
     hooks.hooks.resetRemoteConfig();
     clearStorage();
@@ -367,7 +539,7 @@ function reset() {
     state._ZAP._apid = ''; // no i18n
     state._ZAP._mapid = ''; // no i18n
     state._ZAP._sending = false;
-    logger.Console.log('apptics.reset()'); // no i18n
+    logger.Console.log('Apptics.reset()'); // no i18n
     // start again with the config init() was called with
     if (lastConfig) {
         init(lastConfig);
@@ -376,7 +548,20 @@ function reset() {
 function isActive() {
     return state._ZAP._ready;
 }
-// Declarative click tracking: <el apeventaction="name" apeventprops='{"k":"v"}'> inside <el apgroupaction="group">
+/**
+ * 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;
@@ -388,15 +573,15 @@ function onDocumentClick(event) {
     if (!start) {
         return;
     }
-    var targetElem = start.closest('[apeventaction]:not([apeventaction=""])'); // no i18n
+    var targetElem = start.closest(trackingSelector('apeventaction')); // no i18n
     if (!targetElem) {
         return;
     }
-    var eventName = targetElem.getAttribute('apeventaction') || ''; // no i18n
-    var groupElem = targetElem.closest('[apgroupaction]'); // no i18n
-    var groupName = (groupElem && groupElem.getAttribute('apgroupaction')) || constants.AP_CONFIG.default_group_name; // no i18n
+    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 = targetElem.getAttribute('apeventprops'); // no i18n
+    var rawProps = trackingAttribute(targetElem, 'apeventprops'); // no i18n
     if (!utils.isEmpty(rawProps)) {
         try {
             eventProps = JSON.parse(rawProps);
@@ -502,8 +687,8 @@ function attachListeners() {
         // 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
-            index.checkAndUpdateDeviceInfo();
-            index.deviceReady().then(function () {
+            // 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();
@@ -525,14 +710,25 @@ function attachListeners() {
             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) {
-            track$1.trackError(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;

package/dist/cjs/remoteconfig/country.d.ts

@@ -0,0 +1,4 @@
+/** The ISO code of a time zone's country, '' for one with none (UTC) or unknown. */
+export declare function timeZoneCountryCode(timeZone: string): string;
+/** The country: the user's, else the time zone's. '' when neither says. */
+export declare function deviceCountry(): string;

package/dist/cjs/remoteconfig/country.js

@@ -0,0 +1,73 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var state = require('../core/state.js');
+var env = require('../core/env.js');
+var tzCountries = require('./tz-countries.js');
+
+/**
+ * The country of this device, for remote config's `country` criteria, by its English name as the
+ * console lists it ("India").
+ *
+ * The one AppticsUser.setUser registered comes first. Otherwise it is the country of the
+ * browser's time zone, which is the device clock's: Asia/Kolkata (or Chrome's Asia/Calcutta) is
+ * India, whatever language the browser is in. A browser has no other source short of asking for
+ * the user's location, which is a permission prompt. A zone shared by several countries is the
+ * one tzdata names for it.
+ */
+/** Zone -> ISO code, unpacked on first use. */
+var byZone = null;
+function zones() {
+    if (byZone !== null) {
+        return byZone;
+    }
+    var out = {};
+    tzCountries.TZ_COUNTRIES.split(';').forEach(function (entry) {
+        var colon = entry.indexOf(':'); // no i18n
+        var code = entry.slice(0, colon);
+        entry.slice(colon + 1).split('|').forEach(function (group) {
+            // "Area/City,City", or bare names with no area ("Cuba,Egypt")
+            var slash = group.indexOf('/'); // no i18n
+            var area = slash === -1 ? '' : group.slice(0, slash + 1); // no i18n
+            group.slice(area.length).split(',').forEach(function (city) {
+                out[area + city] = code;
+            });
+        });
+    });
+    byZone = out;
+    return out;
+}
+/** The ISO code of a time zone's country, '' for one with none (UTC) or unknown. */
+function timeZoneCountryCode(timeZone) {
+    var all = zones();
+    return Object.prototype.hasOwnProperty.call(all, timeZone) ? all[timeZone] : ''; // no i18n
+}
+/** IN -> India, in English; the code itself where the browser has no region names. */
+function regionName(code) {
+    try {
+        var names = new Intl.DisplayNames(['en'], { type: 'region' }); // no i18n
+        return names.of(code) || code;
+    }
+    catch (err) {
+        return code;
+    }
+}
+/** The country: the user's, else the time zone's. '' when neither says. */
+function deviceCountry() {
+    var named = String(state._ZAP._user_info.country || '').trim(); // no i18n
+    if (named !== '') {
+        return named;
+    }
+    var timeZone = ''; // no i18n
+    try {
+        timeZone = String(env.getTimeZone() || ''); // no i18n
+    }
+    catch (err) {
+        timeZone = ''; // no i18n
+    }
+    var code = timeZoneCountryCode(timeZone);
+    return code === '' ? '' : regionName(code); // no i18n
+}
+
+exports.deviceCountry = deviceCountry;
+exports.timeZoneCountryCode = timeZoneCountryCode;

package/dist/cjs/remoteconfig/custom.d.ts

@@ -1,10 +1,10 @@
-/** The value set for a custom criteria key, or undefined when none is. */
-export declare function customConditionValue(key: string): string | undefined;
+/** The values set for a condition, by its name; empty when none are. */
+export declare function customConditionValues(conditionname: string): string[];
 /**
- * Sets what this device is for a custom criteria, or removes it with an empty value. Re-applies
- * the stored rules as soon as storage is ready, so the next read sees the new result without a
- * fetch.
+ * Sets what this device is for a custom condition, by its name, as comma separated values; an
+ * empty value removes it. Re-applies the stored rules once storage is ready, so the next read sees
+ * the new result without a fetch.
  */
-export declare function setCustomConditionValue(key: string, value: string | number | boolean | null | undefined): void;
-/** reset(): forgets the values set on this page; the stored ones go with the rest of storage. */
+export declare function setCustomConditionValue(conditionname: string, value: string | number | boolean | null | undefined): void;
+/** reset(): forgets the values set on this page. */
 export declare function clearCustomConditionValues(): void;