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

package/dist/cjs/index.js

@@ -1,10 +1,11 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var constants = require('./core/constants.js');
 var guard = require('./core/guard.js');
+var logger = require('./core/logger.js');
 var lifecycle = require('./lifecycle.js');
 var autoApi = require('./engagement/auto-api.js');
 var track = require('./engagement/track.js');
@@ -17,17 +18,22 @@ var index = require('./user/index.js');
 var consent = require('./core/consent.js');
 var scheduler = require('./scheduler.js');
 var track$2 = require('./heatmap/track.js');
-require('./heatmap/send.js');
-var autoInit = require('./auto-init.js');
+var send = require('./heatmap/send.js');
+var hooks = require('./core/hooks.js');
 var debug = require('./core/debug.js');
 
+// flush() and the flush timer send heatmap records through this hook. Set here, from a named
+// import, rather than by heatmap/send.ts on being imported: the package's sideEffects list names
+// only the CDN bundle, so a bundler drops a bare `import './heatmap/send.js'`, and with it every
+// heatmap send, while capture carries on filling the queue
+hooks.hooks.sendHeatmaps = send.sendHeatmapData;
 /*
  * Every public call below is a function of its own, with the parameter names the console shows
  * on hover, forwarding to its guard()ed implementation (see forward).
  */
 const initGuarded = guard.guard('Apptics.init', lifecycle.init); // no i18n
 const readyGuarded = guard.guard('Apptics.ready', lifecycle.ready); // no i18n
-const flushGuarded = guard.guard('Apptics.flush', scheduler.flush); // no i18n
+const flushGuarded = guard.guard('Apptics.flush', scheduler.calledFlush); // no i18n
 const resetGuarded = guard.guard('Apptics.reset', lifecycle.reset); // no i18n
 /**
  * Debug mode, on or off; works before init(), and wins over `debug` in init(). On, engagement,
@@ -37,13 +43,23 @@ const resetGuarded = guard.guard('Apptics.reset', lifecycle.reset); // no i18n
  */
 const enableDebugGuarded = guard.guard('Apptics.enableDebug', debug.enableDebug); // no i18n
 const disableDebugGuarded = guard.guard('Apptics.disableDebug', debug.disableDebug); // no i18n
+/** The renamed calls already warned about: once per page each, not once per call. */
+var warnedRenamed = {};
+/** An earlier name of a call still works, with a console warning naming the call to use. */
+function renamed(old, current) {
+    if (warnedRenamed[old]) {
+        return;
+    }
+    warnedRenamed[old] = true;
+    logger.warnAlways(old + ' is now ' + current + '; rename it in your code'); // no i18n
+}
 /** Android's Apptics: starting the SDK, and what applies to all of it. */
 const Apptics = {
-    /** Starts the SDK. The config object is required; the console snippet supplies it via auto-init. */
+    /** Starts the SDK with the app's config object, which is required. */
     init: function init(config) { return guard.forward(initGuarded, arguments); },
     /** Resolves true once the SDK is running, false if it can't start. */
     ready: function ready() { return guard.forward(readyGuarded, arguments); },
-    /** Sends stored engagements, errors and heatmap records now. */
+    /** Sends stored engagements, errors and heatmap records now; at most once every 15 seconds. */
     flush: function flush() { return guard.forward(flushGuarded, arguments); },
     /** Clears stored identity, queued data and remote config values, then starts again. */
     reset: function reset() { return guard.forward(resetGuarded, arguments); },
@@ -51,19 +67,23 @@ const Apptics = {
     disableDebug: function disableDebug() { return guard.forward(disableDebugGuarded, arguments); },
 };
 /**
- * Android's AppticsEvents: `addEvent(name, group?, properties?)`, or
+ * Android's AppticsEvents: `addEvent(name, group, properties?)`, or
  * `addEvent(AppticsEvent.DefinedEvents.X, properties?)`.
  */
 const addEventGuarded = guard.guard('AppticsEvent.addEvent', track.trackEvent); // no i18n
+const setClickTrackingGuarded = guard.guard('AppticsEvent.setClickTracking', lifecycle.setClickTracking); // no i18n
 const AppticsEvent = {
     /** Apptics' defined events, as Android's DefinedEvents, to log with addEvent. */
     DefinedEvents: definedEvents.DefinedEvents,
     addEvent: function addEvent(eventName, groupName, properties) {
         return guard.forward(addEventGuarded, arguments);
     },
+    /** Turns click tracking from markup (apeventaction) on or off; the `track_click` config flag sets it at start-up. */
+    setClickTracking: function setClickTracking(enabled) { return guard.forward(setClickTrackingGuarded, arguments); },
 };
 const inScreenGuarded = guard.guard('AppticsScreen.inScreen', track.inScreenAt); // no i18n
 const outScreenGuarded = guard.guard('AppticsScreen.outScreen', track.outScreenAt); // no i18n
+const setScreenTrackingGuarded = guard.guard('AppticsScreen.setScreenTracking', lifecycle.setScreenTracking); // no i18n
 /** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
 const AppticsScreen = {
     /**
@@ -85,11 +105,13 @@ const AppticsScreen = {
     outScreen: function outScreen(id) {
         outScreenGuarded(id, utils.nowMs());
     },
+    /** Turns automatic screen tracking on or off; the `track_screen` config flag sets it at start-up. */
+    setScreenTracking: function setScreenTracking(enabled) { return guard.forward(setScreenTrackingGuarded, arguments); },
 };
 const endTrackApiGuarded = guard.guard('AppticsApi.endTrackApi', track.endTrackApiAt); // no i18n
 const startTrackApiGuarded = guard.guard('AppticsApi.startTrackApi', track.startTrackApi); // no i18n
 const configureGuarded = guard.guard('AppticsApi.configure', apiRules.configureApiTracking); // no i18n
-const enableApiTrackingGuarded = guard.guard('AppticsApi.enableApiTracking', autoApi.enableApiTracking); // no i18n
+const setApiTrackingGuarded = guard.guard('AppticsApi.setApiTracking', autoApi.enableApiTracking); // no i18n
 /** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
 const AppticsApi = {
     /** Begins timing one call: returns the id endTrackApi takes. */
@@ -103,17 +125,27 @@ const AppticsApi = {
     ApiTrackingBuilder: apiRules.ApiTrackingBuilder,
     /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
     configure: function configure(config) { return guard.forward(configureGuarded, arguments); },
-    /** Turns automatic API tracking on or off; the `track_api` config flag is the usual way to set it. */
-    enableApiTracking: function enableApiTracking(enabled) { return guard.forward(enableApiTrackingGuarded, arguments); },
+    /** Turns automatic API tracking on or off; the `track_api` config flag sets it at start-up. */
+    setApiTracking: function setApiTracking(enabled) { return guard.forward(setApiTrackingGuarded, arguments); },
+    /** @deprecated the earlier name of setApiTracking, which it calls, with a warning */
+    enableApiTracking: function enableApiTracking(enabled) {
+        renamed('AppticsApi.enableApiTracking', 'AppticsApi.setApiTracking'); // no i18n
+        return guard.forward(setApiTrackingGuarded, arguments);
+    },
 };
 const trackErrorGuarded = guard.guard('AppticsError.trackError', track$1.trackError); // no i18n
-const trackGlobalErrorHandlerGuarded = guard.guard('AppticsError.trackGlobalErrorHandler', track$1.trackGlobalErrorHandler); // no i18n
+const setErrorTrackingGuarded = guard.guard('AppticsError.setErrorTracking', track$1.setErrorTracking); // no i18n
 /** Errors: the ones the app caught, and the switch for the uncaught ones tracked on their own. */
 const AppticsError = {
     /** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
     trackError: function trackError(error, properties) { return guard.forward(trackErrorGuarded, arguments); },
-    /** Turns the automatic tracking of uncaught errors and unhandled rejections on or off. */
-    trackGlobalErrorHandler: function trackGlobalErrorHandler(enabled) { return guard.forward(trackGlobalErrorHandlerGuarded, arguments); },
+    /** Turns the automatic tracking of uncaught errors and unhandled rejections on or off; the `track_error` config flag sets it at start-up. */
+    setErrorTracking: function setErrorTracking(enabled) { return guard.forward(setErrorTrackingGuarded, arguments); },
+    /** @deprecated the earlier name of setErrorTracking, which it calls, with a warning */
+    trackGlobalErrorHandler: function trackGlobalErrorHandler(enabled) {
+        renamed('AppticsError.trackGlobalErrorHandler', 'AppticsError.setErrorTracking'); // no i18n
+        return guard.forward(setErrorTrackingGuarded, arguments);
+    },
 };
 const setUserGuarded = guard.guard('AppticsUser.setUser', index.setUser); // no i18n
 const getUserGuarded = guard.guard('AppticsUser.getUser', index.getUser); // no i18n
@@ -125,10 +157,16 @@ const AppticsUser = {
     getUser: function getUser() { return guard.forward(getUserGuarded, arguments); },
     UserBuilder: index.UserBuilder,
 };
-const trackHeatmapGuarded = guard.guard('AppticsHeatmap.trackHeatmap', track$2.trackHeatmap); // no i18n
-/** Heatmap capture: AppticsHeatmap.trackHeatmap() starts or stops recording clicks and scrolls. */
+const setHeatmapTrackingGuarded = guard.guard('AppticsHeatmap.setHeatmapTracking', track$2.trackHeatmap); // no i18n
+/** Heatmap capture: AppticsHeatmap.setHeatmapTracking() starts or stops recording clicks and scrolls. */
 const AppticsHeatmap = {
-    trackHeatmap: function trackHeatmap(on) { return guard.forward(trackHeatmapGuarded, arguments); },
+    /** Starts or stops recording clicks and scrolls; the `track_heatmap` config flag sets it at start-up. */
+    setHeatmapTracking: function setHeatmapTracking(enabled) { return guard.forward(setHeatmapTrackingGuarded, arguments); },
+    /** @deprecated the earlier name of setHeatmapTracking, which it calls, with a warning */
+    trackHeatmap: function trackHeatmap(on) {
+        renamed('AppticsHeatmap.trackHeatmap', 'AppticsHeatmap.setHeatmapTracking'); // no i18n
+        return guard.forward(setHeatmapTrackingGuarded, arguments);
+    },
 };
 const setTrackingStatusGuarded = guard.guard('AppticsSettings.setTrackingStatus', consent.setTrackingStatus); // no i18n
 const getTrackingStatusGuarded = guard.guard('AppticsSettings.getTrackingStatus', consent.getTrackingStatus); // no i18n
@@ -149,7 +187,6 @@ const apptics = {
     AppticsSettings,
     AppticsHeatmap,
 };
-autoInit.scheduleAutoInit(Apptics);
 
 exports.Apptics = Apptics;
 exports.AppticsApi = AppticsApi;

package/dist/cjs/lifecycle.d.ts

@@ -1,8 +1,7 @@
 import { type ScreenRouteRule } from './core/constants.js';
 import type { AppticsConfig } from './types.js';
 /**
- * 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).
+ * Starts the SDK. The config object is required: the SDK starts only when the app calls this.
  * 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
@@ -19,3 +18,15 @@ export declare function screenRouteRules(routes: unknown): ScreenRouteRule[];
 export declare function ready(): Promise<boolean>;
 /** Clears stored identity and queues, then starts again from the snippet. */
 export declare function reset(): void;
+/**
+ * AppticsEvent.setClickTracking: click tracking from markup on or off, as the `track_click`
+ * config sets it. The listener stays; it checks the switch on every click.
+ */
+export declare function setClickTracking(enabled?: boolean): void;
+/**
+ * AppticsScreen.setScreenTracking: automatic screen tracking on or off, as the `track_screen`
+ * config sets it. Applied now once the SDK is running; before that it is only noted, and start()
+ * switches tracking to it. Like the other switches, the next init() (a reset() too) goes back to
+ * what its config says.
+ */
+export declare function setScreenTracking(enabled?: boolean): void;

package/dist/cjs/lifecycle.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var constants = require('./core/constants.js');
@@ -116,10 +116,15 @@ 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.
+ *
+ * Another app is a different base_url, app_domain or auth_key from the ones the stored data was
+ * registered with. Everything goes, the queues included, and start-up runs as on a first visit:
+ * app/addversion, device/add and the rest. Resolves once the store is empty.
  */
 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
+    // which app it is, and which version, are in app_version_info (serviceUrl, identifier, a
+    // fingerprint of zak, 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)
@@ -127,11 +132,17 @@ function discardOtherAppData(settings) {
     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
-    }
+    var otherApp = !utils.isEmpty(stored) && stored !== appKey(settings);
+    // a build that kept no fingerprint cannot tell: hasAppVersion() registers again, and records one
+    var otherKey = !utils.isEmpty(info.zakhash) && info.zakhash !== appversion.keyFingerprint(settings.zak);
+    if (!otherApp && !otherKey) {
+        return Promise.resolve();
+    }
+    logger.Console.log('init: stored data was registered with another ' + (otherApp ? 'base_url or app_domain' : 'auth_key') + ', clearing it and starting as a first visit'); // no i18n
+    previousAppVersion = ''; // no i18n
+    // the remote config values read from the store, which is about to go
+    hooks.hooks.resetRemoteConfig();
+    return clearStorage();
 }
 /**
  * Timing an app may tune in init(). Each has a range: a value outside it is ignored with a
@@ -175,15 +186,20 @@ function applyIntervals(config) {
         }
     }
 }
+/** Everything the SDK stores: settings, ids and every queue. Resolves once it is all gone. */
 function clearStorage() {
     attempts.clearAttempts();
     storage.user_defaults.clear();
-    storage.engagement_transactions.clear();
-    storage.error_transactions.clear();
+    return Promise.all([
+        storage.engagement_transactions, storage.error_transactions, storage.heatmap_transactions, storage.remotelog_transactions, storage.feedbacklog_transactions,
+    ].map(function (queue) {
+        return queue.clear();
+    })).then(function () {
+        return undefined;
+    });
 }
 /**
- * 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).
+ * Starts the SDK. The config object is required: the SDK starts only when the app calls this.
  * 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
@@ -281,6 +297,10 @@ function init(config) {
     // 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);
+    // uncaught errors and tagged clicks, on unless the config says false: the listeners check
+    // these as each error or click happens
+    state._ZAP._config.track_error = typeof config.track_error === 'boolean' ? config.track_error : constants.AP_CONFIG.track_error; // no i18n
+    state._ZAP._config.track_click = typeof config.track_click === 'boolean' ? config.track_click : constants.AP_CONFIG.track_click; // no i18n
     // 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;
@@ -302,39 +322,11 @@ function init(config) {
             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) {
+        return discardOtherAppData(state._ZAP._defaultoptions).then(function () {
             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);
+            return startUp(config, myGeneration);
         });
     }).catch(function (err) {
         logger.Console.error('Apptics.init: start-up failed', err); // no i18n
@@ -342,6 +334,42 @@ function init(config) {
     });
     return true;
 }
+/** Start-up from app/addversion on, once the store holds only this app's data. */
+function startUp(config, myGeneration) {
+    // 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);
+    });
+}
 /** How often a start-up waiting on the network tries app/addversion again, besides on `online`. */
 const OFFLINE_RETRY_MS = 60 * 1000;
 /**
@@ -448,6 +476,8 @@ function start(config, myGeneration) {
     state._ZAP._token = String(state._ZAP._defaultoptions.aaid);
     // last known server settings (getupdates) apply before anything is tracked
     index.restoreServerSettings();
+    // the user this browser was tracking as, before getsdkconfig is asked: it carries their ids
+    index$1.getUserInfo();
     // 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
@@ -466,9 +496,11 @@ function start(config, 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())
+    // getsdkconfig, once per page load and then at each answer's next_check_after. A first visit
+    // asked as soon as device/add succeeded (registerDeviceWithApptics) and this does nothing; a
+    // returning visit, whose device is registered, asks now, after app/addversion. Until it
+    // answers, the settings saved by the last visit apply (restoreServerSettings, in start())
+    index.startServerSettingChecks();
     if (appVersionChanged) {
         state._ZAP._device_info.appversionid = ''; // no i18n
         index.updateDeviceWithApptics(state._ZAP._device_info).then(function (result) {
@@ -483,7 +515,6 @@ function startTracking(appVersionChanged, myGeneration) {
     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;
@@ -518,6 +549,7 @@ function startTracking(appVersionChanged, myGeneration) {
 function reset() {
     generation++;
     scheduler.stopTimers();
+    session.resetInactivity();
     // 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);
@@ -548,6 +580,26 @@ function reset() {
 function isActive() {
     return state._ZAP._ready;
 }
+/**
+ * AppticsEvent.setClickTracking: click tracking from markup on or off, as the `track_click`
+ * config sets it. The listener stays; it checks the switch on every click.
+ */
+function setClickTracking(enabled) {
+    state._ZAP._config.track_click = typeof enabled === 'boolean' ? enabled : true; // no i18n
+    logger.Console.log('click tracking: ' + (state._ZAP._config.track_click ? 'on' : 'off')); // no i18n
+}
+/**
+ * AppticsScreen.setScreenTracking: automatic screen tracking on or off, as the `track_screen`
+ * config sets it. Applied now once the SDK is running; before that it is only noted, and start()
+ * switches tracking to it. Like the other switches, the next init() (a reset() too) goes back to
+ * what its config says.
+ */
+function setScreenTracking(enabled) {
+    state._ZAP._config.track_screen = typeof enabled === 'boolean' ? enabled : true; // no i18n
+    if (isActive()) {
+        autoScreen.enableScreenTracking(state._ZAP._config.track_screen);
+    }
+}
 /**
  * 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.
@@ -563,7 +615,7 @@ function trackingSelector(name) {
 // 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()) {
+    if (!window.appticsReadyStatus || !isActive() || !state._ZAP._config.track_click) {
         return;
     }
     var start = event.target;
@@ -579,7 +631,8 @@ function onDocumentClick(event) {
     }
     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
+    // no apgroupaction around it: trackEvent refuses it and says the group is missing
+    var groupName = (groupElem && trackingAttribute(groupElem, 'apgroupaction')) || undefined; // no i18n
     var eventProps = {};
     var rawProps = trackingAttribute(targetElem, 'apeventprops'); // no i18n
     if (!utils.isEmpty(rawProps)) {
@@ -603,10 +656,18 @@ function onDocumentClick(event) {
 function onPageHidden() {
     if (!isActive())
         return;
+    // the moment the user left: the session ends at it if they are not back within inactiveduration
+    session.markTabInactive(sendEndedSession);
     session.updateScreenWithEndtime();
     scheduler.flush(true);
     logger.Console.log('page hidden: closing the open screen and flushing'); // no i18n
 }
+/** A session that inactivity ended while the tab was away: sent now, not when the user returns. */
+function sendEndedSession() {
+    if (!isActive())
+        return;
+    scheduler.flush();
+}
 /**
  * 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
@@ -638,14 +699,18 @@ function attachListeners() {
     window.addEventListener('blur', function () {
         if (!isActive())
             return;
+        // focus moving into an iframe on the page blurs the window too, and the user is still here
+        if (document.activeElement && document.activeElement.tagName === 'IFRAME')
+            return; // no i18n
         logger.Console.log('Window lost focus, user switched to another window or application'); // no i18n
-        session.updateLastActiveTimeOfSession();
+        session.markTabInactive(sendEndedSession);
     });
     // 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.markTabActive();
         session.checkAndUpdateSession();
         scheduler.startTimers();
     });
@@ -656,6 +721,7 @@ function attachListeners() {
         if (!isActive() || !event.persisted)
             return;
         logger.Console.log('restored from the back/forward cache: starting a new session'); // no i18n
+        session.markTabActive();
         // the screen the page was left on starts a new view, in the new session
         session.checkAndUpdateSession().then(track.resumeScreen);
         scheduler.startTimers();
@@ -667,12 +733,12 @@ function attachListeners() {
             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
+        // back in view. getsdkconfig is not asked here: only at its next_check_after, on a tab's
+        // first page load, and when a user is registered or getupdates reports a change
+        session.markTabActive();
         // 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 () {
@@ -706,7 +772,7 @@ function attachListeners() {
         });
     }
     window.addEventListener('unhandledrejection', function (event) {
-        if (isActive() && state._ZAP._isGlobalErrorTracking) {
+        if (isActive() && state._ZAP._config.track_error) {
             track$1.trackError(event);
         }
     });
@@ -714,7 +780,7 @@ function attachListeners() {
     // 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) {
+        if (!isActive() || !state._ZAP._config.track_error) {
             return;
         }
         var target = event.target;
@@ -732,3 +798,5 @@ exports.init = init;
 exports.ready = ready;
 exports.reset = reset;
 exports.screenRouteRules = screenRouteRules;
+exports.setClickTracking = setClickTracking;
+exports.setScreenTracking = setScreenTracking;

package/dist/cjs/remoteconfig/country.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var state = require('../core/state.js');

package/dist/cjs/remoteconfig/custom.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var storage = require('../core/storage.js');

package/dist/cjs/remoteconfig/evaluate.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var logger = require('../core/logger.js');

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

@@ -1,24 +1,31 @@
 /**
- * Asks for the rule set, if anything has changed since the last one.
+ * Asks for the rule set: the whole of it with flagtime 0 on the first fetch of a page load, then
+ * only what changed since the last answered request, which is merged into what is stored.
  *
- * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
- * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
- * normal case and not a failure.
+ * Resolves with the answer, whether or not it carried a rule set — a later answer with no
+ * `remoteconfig` block means nothing has changed, which is the normal case and not a failure.
  *
- * A second caller joins the first rather than making another request.
+ * With `whole`, a cold fetch: flagtime 0 whatever this page has fetched already, and the answer
+ * replaces the stored set as the first fetch of a page load does.
+ *
+ * A second caller joins the first rather than making another request. A cold fetch joins one
+ * only when it asked with flagtime 0 too, and otherwise asks once it has answered.
  */
-export declare function fetchRemoteConfig(): Promise<Record<string, unknown>>;
+export declare function fetchRemoteConfig(whole?: boolean): Promise<Record<string, unknown>>;
 /**
  * reset(): forgets the rule set, its values and what the server last reported, and disowns a
  * request still in flight, whose answer would otherwise put the old rule set back.
  */
 export declare function resetRemoteConfig(): void;
 /**
- * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
- * CACHE_MS. Resolves true when they are, false when the fetch failed or could not be made — the
- * caller then decides whether stored values will do. Never rejects.
+ * Makes sure the values are this page's own: from a fetch on this page that succeeded, kept up to
+ * date by the polling after it. With `coldFetch`, a fetch with flagtime 0 now, whatever this page
+ * already has, whose answer replaces what is stored: at most COLD_LIMIT a minute, and one past
+ * that answers from what this page has. Resolves true when they are, false when the
+ * fetch failed or could not be made — the caller then decides whether stored values will do.
+ * Never rejects.
  *
  * Waits for start-up and for the device to be registered, which a first visit is still doing
  * when ready() resolves: getupdates is refused without the device ids.
  */
-export declare function obtain(): Promise<boolean>;
+export declare function obtain(coldFetch?: boolean): Promise<boolean>;