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

package/dist/esm/heatmap/send.d.ts

@@ -8,6 +8,8 @@ import type { Dict, ServerResult } from '../types.js';
  *
  * Gated on the server's own heatmap flag (getsdkconfig module 18), not on engagement: an app may
  * want events while declining to have every click's coordinates recorded.
+ *
+ * The scheduler reaches it through hooks.sendHeatmaps, which src/index.ts sets.
  */
 export declare function sendHeatmapData(forget?: boolean): Promise<void>;
 export declare function requestToSendHeatmaps(_payload: Dict, forget?: boolean): Promise<ServerResult>;

package/dist/esm/heatmap/send.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 */
 import { _ZAP } from '../core/state.js';
 import { Console, warnAlways } from '../core/logger.js';
 import { cloneObject } from '../core/utils.js';
@@ -7,7 +7,6 @@ import { is_apptics_disabled } from '../core/env.js';
 import { shouldTrackOrSendData } from '../core/consent.js';
 import { defer, clearDefer, withSendLock, freshItems, awaitUnlessClosing, sendBatch } from '../core/batch.js';
 import { isPermanentRefusal } from '../core/transport.js';
-import { hooks } from '../core/hooks.js';
 
 /**
  * Sends queued heatmap records to heatmap/add.
@@ -18,6 +17,8 @@ import { hooks } from '../core/hooks.js';
  *
  * Gated on the server's own heatmap flag (getsdkconfig module 18), not on engagement: an app may
  * want events while declining to have every click's coordinates recorded.
+ *
+ * The scheduler reaches it through hooks.sendHeatmaps, which src/index.ts sets.
  */
 function sendHeatmapData(forget) {
     if (is_apptics_disabled() || !shouldTrackOrSendData() || !_ZAP._heatmapTracking) {
@@ -72,8 +73,5 @@ function requestToSendHeatmaps(_payload, forget) {
     var label = 'requestToSendHeatmaps'; // no i18n
     return sendBatch('heatmap', label, _payload, forget); // no i18n
 }
-// the scheduler flushes through this, so importing the heatmap entry is what puts heatmap
-// records on the flush timer at all
-hooks.sendHeatmaps = sendHeatmapData;
 
 export { requestToSendHeatmaps, sendHeatmapData };

package/dist/esm/heatmap/track.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 */
 import { AP_LOG_MODULE, AP_CONFIG, AP_TRACKING_STATUS } from '../core/constants.js';
 import { getConfig, _ZAP } from '../core/state.js';
 import { Console, logFailure } from '../core/logger.js';

package/dist/esm/index.d.ts

@@ -1,4 +1,3 @@
-import './heatmap/send.js';
 import type { AppticsSdk } from './types.js';
 export type { AppticsSdk, AppticsConfig, ErrorLike, FeedbackType, Properties, TrackingStatus, UserInfo, UserValidationResult, } from './types.js';
 /** Android's Apptics: starting the SDK, and what applies to all of it. */
@@ -14,7 +13,7 @@ export type { ApiTrackingConfig } from './engagement/api-rules.js';
 export declare const AppticsError: AppticsSdk['AppticsError'];
 /** Android's AppticsUser: the signed-in user, and the builder for their properties. */
 export declare const AppticsUser: AppticsSdk['AppticsUser'];
-/** Heatmap capture: AppticsHeatmap.trackHeatmap() starts or stops recording clicks and scrolls. */
+/** Heatmap capture: AppticsHeatmap.setHeatmapTracking() starts or stops recording clicks and scrolls. */
 export declare const AppticsHeatmap: AppticsSdk['AppticsHeatmap'];
 /** Android's AppticsSettings: what the SDK may track for this visitor. */
 export declare const AppticsSettings: AppticsSdk['AppticsSettings'];

package/dist/esm/index.js

@@ -1,29 +1,35 @@
-/*! @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 */
 import { AP_TRACKING_STATUS } from './core/constants.js';
 import { forward, guard } from './core/guard.js';
-import { reset, ready, init } from './lifecycle.js';
+import { warnAlways } from './core/logger.js';
+import { reset, ready, init, setClickTracking, setScreenTracking } from './lifecycle.js';
 import { enableApiTracking } from './engagement/auto-api.js';
 import { endTrackApiAt, outScreenAt, inScreenAt, startTrackApi, trackEvent } from './engagement/track.js';
 import { DefinedEvents } from './engagement/defined-events.js';
 import { nowMs, getNewUUID } from './core/utils.js';
 import { validateScreenName } from './core/validate.js';
 import { ApiTrackingBuilder, configureApiTracking } from './engagement/api-rules.js';
-import { trackGlobalErrorHandler, trackError } from './errors/track.js';
+import { setErrorTracking, trackError } from './errors/track.js';
 import { UserBuilder, getUser, setUser } from './user/index.js';
 import { getTrackingStatus, setTrackingStatus } from './core/consent.js';
-import { flush } from './scheduler.js';
+import { calledFlush } from './scheduler.js';
 import { trackHeatmap } from './heatmap/track.js';
-import './heatmap/send.js';
-import { scheduleAutoInit } from './auto-init.js';
+import { sendHeatmapData } from './heatmap/send.js';
+import { hooks } from './core/hooks.js';
 import { disableDebug, enableDebug } from './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.sendHeatmaps = 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('Apptics.init', init); // no i18n
 const readyGuarded = guard('Apptics.ready', ready); // no i18n
-const flushGuarded = guard('Apptics.flush', flush); // no i18n
+const flushGuarded = guard('Apptics.flush', calledFlush); // no i18n
 const resetGuarded = guard('Apptics.reset', reset); // no i18n
 /**
  * Debug mode, on or off; works before init(), and wins over `debug` in init(). On, engagement,
@@ -33,13 +39,23 @@ const resetGuarded = guard('Apptics.reset', reset); // no i18n
  */
 const enableDebugGuarded = guard('Apptics.enableDebug', enableDebug); // no i18n
 const disableDebugGuarded = guard('Apptics.disableDebug', 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;
+    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 forward(initGuarded, arguments); },
     /** Resolves true once the SDK is running, false if it can't start. */
     ready: function ready() { return 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 forward(flushGuarded, arguments); },
     /** Clears stored identity, queued data and remote config values, then starts again. */
     reset: function reset() { return forward(resetGuarded, arguments); },
@@ -47,19 +63,23 @@ const Apptics = {
     disableDebug: function disableDebug() { return 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('AppticsEvent.addEvent', trackEvent); // no i18n
+const setClickTrackingGuarded = guard('AppticsEvent.setClickTracking', setClickTracking); // no i18n
 const AppticsEvent = {
     /** Apptics' defined events, as Android's DefinedEvents, to log with addEvent. */
     DefinedEvents: DefinedEvents,
     addEvent: function addEvent(eventName, groupName, properties) {
         return 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 forward(setClickTrackingGuarded, arguments); },
 };
 const inScreenGuarded = guard('AppticsScreen.inScreen', inScreenAt); // no i18n
 const outScreenGuarded = guard('AppticsScreen.outScreen', outScreenAt); // no i18n
+const setScreenTrackingGuarded = guard('AppticsScreen.setScreenTracking', setScreenTracking); // no i18n
 /** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
 const AppticsScreen = {
     /**
@@ -81,11 +101,13 @@ const AppticsScreen = {
     outScreen: function outScreen(id) {
         outScreenGuarded(id, nowMs());
     },
+    /** Turns automatic screen tracking on or off; the `track_screen` config flag sets it at start-up. */
+    setScreenTracking: function setScreenTracking(enabled) { return forward(setScreenTrackingGuarded, arguments); },
 };
 const endTrackApiGuarded = guard('AppticsApi.endTrackApi', endTrackApiAt); // no i18n
 const startTrackApiGuarded = guard('AppticsApi.startTrackApi', startTrackApi); // no i18n
 const configureGuarded = guard('AppticsApi.configure', configureApiTracking); // no i18n
-const enableApiTrackingGuarded = guard('AppticsApi.enableApiTracking', enableApiTracking); // no i18n
+const setApiTrackingGuarded = guard('AppticsApi.setApiTracking', enableApiTracking); // no i18n
 /** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
 const AppticsApi = {
     /** Begins timing one call: returns the id endTrackApi takes. */
@@ -99,17 +121,27 @@ const AppticsApi = {
     ApiTrackingBuilder: ApiTrackingBuilder,
     /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
     configure: function configure(config) { return 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 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 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 forward(setApiTrackingGuarded, arguments);
+    },
 };
 const trackErrorGuarded = guard('AppticsError.trackError', trackError); // no i18n
-const trackGlobalErrorHandlerGuarded = guard('AppticsError.trackGlobalErrorHandler', trackGlobalErrorHandler); // no i18n
+const setErrorTrackingGuarded = guard('AppticsError.setErrorTracking', 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 forward(trackErrorGuarded, arguments); },
-    /** Turns the automatic tracking of uncaught errors and unhandled rejections on or off. */
-    trackGlobalErrorHandler: function trackGlobalErrorHandler(enabled) { return 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 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 forward(setErrorTrackingGuarded, arguments);
+    },
 };
 const setUserGuarded = guard('AppticsUser.setUser', setUser); // no i18n
 const getUserGuarded = guard('AppticsUser.getUser', getUser); // no i18n
@@ -121,10 +153,16 @@ const AppticsUser = {
     getUser: function getUser() { return forward(getUserGuarded, arguments); },
     UserBuilder: UserBuilder,
 };
-const trackHeatmapGuarded = guard('AppticsHeatmap.trackHeatmap', trackHeatmap); // no i18n
-/** Heatmap capture: AppticsHeatmap.trackHeatmap() starts or stops recording clicks and scrolls. */
+const setHeatmapTrackingGuarded = guard('AppticsHeatmap.setHeatmapTracking', trackHeatmap); // no i18n
+/** Heatmap capture: AppticsHeatmap.setHeatmapTracking() starts or stops recording clicks and scrolls. */
 const AppticsHeatmap = {
-    trackHeatmap: function trackHeatmap(on) { return 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 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 forward(setHeatmapTrackingGuarded, arguments);
+    },
 };
 const setTrackingStatusGuarded = guard('AppticsSettings.setTrackingStatus', setTrackingStatus); // no i18n
 const getTrackingStatusGuarded = guard('AppticsSettings.getTrackingStatus', getTrackingStatus); // no i18n
@@ -145,6 +183,5 @@ const apptics = {
     AppticsSettings,
     AppticsHeatmap,
 };
-scheduleAutoInit(Apptics);
 
 export { Apptics, AppticsApi, AppticsError, AppticsEvent, AppticsHeatmap, AppticsScreen, AppticsSettings, AppticsUser, apptics as default };

package/dist/esm/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/esm/lifecycle.js

@@ -1,17 +1,17 @@
-/*! @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 */
 import { REQUIRED_CONFIG, CONFIG_KEYS, AP_CONFIG, RETIRED_CONFIG_NAMES, DEFAULT_INACTIVE_MINUTES } from './core/constants.js';
 import { _ZAP } from './core/state.js';
 import { Console, warnAlways } from './core/logger.js';
 import { isEmpty, isSuccess } from './core/utils.js';
-import { storageReady, user_defaults, engagement_transactions, error_transactions, tracking_preference } from './core/storage.js';
+import { storageReady, user_defaults, engagement_transactions, error_transactions, heatmap_transactions, remotelog_transactions, feedbacklog_transactions, tracking_preference } from './core/storage.js';
 import { hooks } from './core/hooks.js';
 import { applyDebugConfig } from './core/debug.js';
 import { getConnectionType, getOrientation } from './core/env.js';
-import { restoreServerSettings, prepareDevice, updateDeviceWithApptics, refreshServerSettings, needsDevice, deviceReady } from './device/index.js';
-import { clearAppVersion, registerAppVersion, appVersionFailedForNetwork } from './device/appversion.js';
-import { holdTabLock, checkAndUpdateSession, updateLastActiveTimeOfSession, updateScreenWithEndtime, endCurrentSession } from './engagement/session.js';
+import { restoreServerSettings, prepareDevice, startServerSettingChecks, updateDeviceWithApptics, needsDevice, deviceReady } from './device/index.js';
+import { clearAppVersion, keyFingerprint, registerAppVersion, appVersionFailedForNetwork } from './device/appversion.js';
+import { holdTabLock, checkAndUpdateSession, markTabInactive, markTabActive, updateScreenWithEndtime, endCurrentSession, resetInactivity } from './engagement/session.js';
 import { enableApiTracking } from './engagement/auto-api.js';
-import { routePath, enableScreenTracking } from './engagement/auto-screen.js';
+import { enableScreenTracking, routePath } from './engagement/auto-screen.js';
 import { resumeScreen, trackEvent } from './engagement/track.js';
 import { trackError } from './errors/track.js';
 import { startTimers, flush, stopTimers } from './scheduler.js';
@@ -114,10 +114,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 = user_defaults.item('app_version_info') || {}; // no i18n
     var stored = !isEmpty(info.serviceUrl) && !isEmpty(info.identifier)
         ? appKey(info)
@@ -125,11 +130,17 @@ function discardOtherAppData(settings) {
     previousAppVersion = String((!isEmpty(info.appversion) ? info.appversion : user_defaults.item('appversion')) || ''); // no i18n
     user_defaults.add('appkey', undefined); // no i18n
     user_defaults.add('appversion', undefined); // no i18n
-    if (!isEmpty(stored) && stored !== appKey(settings)) {
-        Console.log('init: stored data belongs to another app, resetting'); // no i18n
-        clearStorage();
-        previousAppVersion = ''; // no i18n
-    }
+    var otherApp = !isEmpty(stored) && stored !== appKey(settings);
+    // a build that kept no fingerprint cannot tell: hasAppVersion() registers again, and records one
+    var otherKey = !isEmpty(info.zakhash) && info.zakhash !== keyFingerprint(settings.zak);
+    if (!otherApp && !otherKey) {
+        return Promise.resolve();
+    }
+    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.resetRemoteConfig();
+    return clearStorage();
 }
 /**
  * Timing an app may tune in init(). Each has a range: a value outside it is ignored with a
@@ -173,15 +184,20 @@ function applyIntervals(config) {
         }
     }
 }
+/** Everything the SDK stores: settings, ids and every queue. Resolves once it is all gone. */
 function clearStorage() {
     clearAttempts();
     user_defaults.clear();
-    engagement_transactions.clear();
-    error_transactions.clear();
+    return Promise.all([
+        engagement_transactions, error_transactions, heatmap_transactions, remotelog_transactions, 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
@@ -279,6 +295,10 @@ function init(config) {
     // screen view can be stored
     _ZAP._config.track_screen = typeof config.track_screen === 'boolean' ? config.track_screen : AP_CONFIG.track_screen; // no i18n
     _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
+    _ZAP._config.track_error = typeof config.track_error === 'boolean' ? config.track_error : AP_CONFIG.track_error; // no i18n
+    _ZAP._config.track_click = typeof config.track_click === 'boolean' ? config.track_click : 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
         _ZAP._config.feedback_theme = config.feedback_theme;
@@ -300,39 +320,11 @@ function init(config) {
             _ZAP._pending = [];
             return false;
         }
-        discardOtherAppData(_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 registerAppVersion().then(function (registered) {
+        return discardOtherAppData(_ZAP._defaultoptions).then(function () {
             if (myGeneration !== generation) {
                 return false;
             }
-            if (!registered && 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
-                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) {
-                        _ZAP._initialised = false;
-                        _ZAP._token = ''; // no i18n
-                        _ZAP._pending = [];
-                        return false;
-                    }
-                    return start(config, myGeneration);
-                });
-            }
-            if (!registered) {
-                warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
-                _ZAP._initialised = false;
-                _ZAP._token = ''; // no i18n
-                _ZAP._pending = [];
-                return false;
-            }
-            return start(config, myGeneration);
+            return startUp(config, myGeneration);
         });
     }).catch(function (err) {
         Console.error('Apptics.init: start-up failed', err); // no i18n
@@ -340,6 +332,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 registerAppVersion().then(function (registered) {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        if (!registered && 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
+            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) {
+                    _ZAP._initialised = false;
+                    _ZAP._token = ''; // no i18n
+                    _ZAP._pending = [];
+                    return false;
+                }
+                return start(config, myGeneration);
+            });
+        }
+        if (!registered) {
+            warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
+            _ZAP._initialised = false;
+            _ZAP._token = ''; // no i18n
+            _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;
 /**
@@ -446,6 +474,8 @@ function start(config, myGeneration) {
     _ZAP._token = String(_ZAP._defaultoptions.aaid);
     // last known server settings (getupdates) apply before anything is tracked
     restoreServerSettings();
+    // the user this browser was tracking as, before getsdkconfig is asked: it carries their ids
+    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 != _ZAP._defaultoptions.appversion; // no i18n
@@ -464,9 +494,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())
+    startServerSettingChecks();
     if (appVersionChanged) {
         _ZAP._device_info.appversionid = ''; // no i18n
         updateDeviceWithApptics(_ZAP._device_info).then(function (result) {
@@ -481,7 +513,6 @@ function startTracking(appVersionChanged, myGeneration) {
     _ZAP._device_info.connectionType = getConnectionType();
     attachListeners();
     _ZAP._properties.orientation = getOrientation();
-    getUserInfo();
     return checkAndUpdateSession().then(function () {
         if (myGeneration !== generation) {
             return false;
@@ -516,6 +547,7 @@ function startTracking(appVersionChanged, myGeneration) {
 function reset() {
     generation++;
     stopTimers();
+    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
     enableApiTracking(false);
@@ -546,6 +578,26 @@ function reset() {
 function isActive() {
     return _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) {
+    _ZAP._config.track_click = typeof enabled === 'boolean' ? enabled : true; // no i18n
+    Console.log('click tracking: ' + (_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) {
+    _ZAP._config.track_screen = typeof enabled === 'boolean' ? enabled : true; // no i18n
+    if (isActive()) {
+        enableScreenTracking(_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.
@@ -561,7 +613,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() || !_ZAP._config.track_click) {
         return;
     }
     var start = event.target;
@@ -577,7 +629,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')) || 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 (!isEmpty(rawProps)) {
@@ -601,10 +654,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
+    markTabInactive(sendEndedSession);
     updateScreenWithEndtime();
     flush(true);
     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;
+    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
@@ -636,14 +697,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
         Console.log('Window lost focus, user switched to another window or application'); // no i18n
-        updateLastActiveTimeOfSession();
+        markTabInactive(sendEndedSession);
     });
     // Track when the window gains focus (user switches back to the window)
     window.addEventListener('focus', function () {
         if (!isActive())
             return;
         Console.log('Window regained focus, user switched back to the window'); // no i18n
+        markTabActive();
         checkAndUpdateSession();
         startTimers();
     });
@@ -654,6 +719,7 @@ function attachListeners() {
         if (!isActive() || !event.persisted)
             return;
         Console.log('restored from the back/forward cache: starting a new session'); // no i18n
+        markTabActive();
         // the screen the page was left on starts a new view, in the new session
         checkAndUpdateSession().then(resumeScreen);
         startTimers();
@@ -665,12 +731,12 @@ function attachListeners() {
             onPageHidden();
             return;
         }
-        // back in view: the server's tracking flags may have changed while we were away
-        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
+        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
         checkAndUpdateSession().then(resumeScreen);
-        refreshServerSettings();
     });
     // if we are running in cordova use ondeviceready otherwise onload
     window.addEventListener(window.cordova ? 'deviceready' : 'load', function () {
@@ -704,7 +770,7 @@ function attachListeners() {
         });
     }
     window.addEventListener('unhandledrejection', function (event) {
-        if (isActive() && _ZAP._isGlobalErrorTracking) {
+        if (isActive() && _ZAP._config.track_error) {
             trackError(event);
         }
     });
@@ -712,7 +778,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() || !_ZAP._isGlobalErrorTracking) {
+        if (!isActive() || !_ZAP._config.track_error) {
             return;
         }
         var target = event.target;
@@ -726,4 +792,4 @@ function attachListeners() {
     window.addEventListener('click', onDocumentClick, true); // no i18n
 }
 
-export { init, ready, reset, screenRouteRules };
+export { init, ready, reset, screenRouteRules, setClickTracking, setScreenTracking };

package/dist/esm/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 */
 import { _ZAP } from '../core/state.js';
 import { getTimeZone } from '../core/env.js';
 import { TZ_COUNTRIES } from './tz-countries.js';

package/dist/esm/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 */
 import { storageReady } from '../core/storage.js';
 import { Console } from '../core/logger.js';
 import { reresolve } from './store.js';

package/dist/esm/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 */
 import { Console } from '../core/logger.js';
 import { _ZAP } from '../core/state.js';
 import { isEmpty } from '../core/utils.js';