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

package/dist/cjs/heatmap/track.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.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var constants = require('../core/constants.js');
@@ -24,6 +24,12 @@ var debug = require('../core/debug.js');
  */
 /** How long the page must be still before a scroll burst counts as one finished gesture. */
 const SCROLL_IDLE_MS = 150;
+/**
+ * How much of the viewport, each way, an element must cover for its scrolling to be the page's.
+ * An app whose layout scrolls a content pane instead of the window (most dashboards do) still
+ * gets a scroll map; a dropdown list or a small table scrolling on its own is not the page moving.
+ */
+const PAGE_SCROLLER_SHARE = 0.5;
 /** Clicks closer than this in time and space count as one angry repetition. */
 const RAGE_WINDOW_MS = 1000;
 const RAGE_RADIUS_PX = 30;
@@ -42,6 +48,10 @@ var scrollStart = 0;
 var scrollStartX = 0;
 var scrollStartY = 0;
 var scrollTimer = null;
+/** What the gesture in progress scrolls: null for the window, else the page's content pane. */
+var scrolling = null;
+/** Where each content pane was after its last gesture, as lastX / lastY are for the window. */
+var paneAt = new WeakMap();
 /**
  * Where the page was before the current gesture began.
  *
@@ -124,7 +134,7 @@ function labelFor(node) {
     if (!node) {
         return ''; // no i18n
     }
-    var attributes = ['data-ap-label', 'apeventaction', 'aria-label', 'name', 'id', 'title']; // no i18n
+    var attributes = ['data-ap-label', 'apeventaction', 'data-apeventaction', 'aria-label', 'name', 'id', 'title']; // no i18n
     for (var i = 0; i < attributes.length; i++) {
         var value = node.getAttribute ? node.getAttribute(attributes[i]) : null;
         if (!utils.isEmpty(value)) {
@@ -280,14 +290,57 @@ function watchForDeadClick(record, target) {
         }
     }, DEAD_CLICK_MS);
 }
-function onScroll() {
+/**
+ * What a scroll event moved, as a gesture counts it: null for the window (the event's target is
+ * the document), the element when it is big enough to be the page's own scrolling, and undefined
+ * for anything smaller, which is not recorded.
+ */
+function scrollerOf(target) {
+    var doc = document;
+    // the window and the document are not elements: either is the page itself scrolling
+    if (!target || target.nodeType !== 1 || target === doc.documentElement || target === doc.body) {
+        return null;
+    }
+    var el = target;
+    var big = el.clientHeight >= (window.innerHeight || 0) * PAGE_SCROLLER_SHARE
+        && el.clientWidth >= viewportWidth() * PAGE_SCROLLER_SHARE;
+    return big ? el : undefined;
+}
+/** Where a scroller is now. */
+function positionOf(scroller) {
+    return scroller === null
+        ? { x: Math.round(window.scrollX || window.pageXOffset || 0), y: Math.round(window.scrollY || window.pageYOffset || 0) }
+        : { x: Math.round(scroller.scrollLeft || 0), y: Math.round(scroller.scrollTop || 0) };
+}
+/**
+ * Where a scroller was before this gesture: what the last one left. A content pane seen for the
+ * first time is taken to have been at its top, which is where a pane starts.
+ */
+function startOf(scroller) {
+    if (scroller === null) {
+        return { x: lastX, y: lastY };
+    }
+    return paneAt.get(scroller) || { x: 0, y: 0 };
+}
+function onScroll(event) {
     if (!consent.canTrackHeatmap('heatmap') || !underCap()) { // no i18n
         return;
     }
+    var scroller = scrollerOf(event ? event.target : null);
+    if (scroller === undefined) {
+        return;
+    }
+    if (scrollTimer !== null && scroller !== scrolling) {
+        // another scroller started moving: the gesture on the first one is over
+        clearTimeout(scrollTimer);
+        endScrollGesture();
+    }
     if (scrollTimer === null) {
+        scrolling = scroller;
+        var start = startOf(scroller);
         scrollStart = utils.nowMs();
-        scrollStartX = lastX;
-        scrollStartY = lastY;
+        scrollStartX = start.x;
+        scrollStartY = start.y;
     }
     else {
         clearTimeout(scrollTimer);
@@ -297,13 +350,21 @@ function onScroll() {
 /** One record for the whole burst, once the page has been still for SCROLL_IDLE_MS. */
 function endScrollGesture() {
     scrollTimer = null;
+    var scroller = scrolling;
+    scrolling = null;
     try {
-        var endX = Math.round(window.scrollX || 0);
-        var endY = Math.round(window.scrollY || 0);
+        var end = positionOf(scroller);
+        var endX = end.x;
+        var endY = end.y;
         var dx = endX - scrollStartX;
         var dy = endY - scrollStartY;
-        lastX = endX;
-        lastY = endY;
+        if (scroller === null) {
+            lastX = endX;
+            lastY = endY;
+        }
+        else {
+            paneAt.set(scroller, end);
+        }
         if (dx === 0 && dy === 0) {
             return;
         }
@@ -312,8 +373,14 @@ function endScrollGesture() {
         var direction = Math.abs(dy) >= Math.abs(dx)
             ? (dy > 0 ? 'down-scroll' : 'up-scroll') // no i18n
             : (dx > 0 ? 'right-scroll' : 'left-scroll'); // no i18n
-        var height = contentHeight() || 1;
-        store(Object.assign(common(), {
+        // the depth is of what scrolled: the document, or the content pane and its own content
+        var height = (scroller === null ? contentHeight() : scroller.scrollHeight) || 1;
+        var visible = scroller === null ? (window.innerHeight || 0) : scroller.clientHeight;
+        store(Object.assign(common(), scroller === null ? {} : {
+            content_height: scroller.scrollHeight,
+            scroll_offset_x: endX,
+            scroll_offset_y: endY,
+        }, {
             // the server accepts only event|default|buttonclick here; what kind of movement it
             // was belongs in gesture_type. input_type is left off rather than invented: a wheel
             // carries no pointer type, and the intended vocabulary has no value for "unknown"
@@ -326,7 +393,7 @@ function endScrollGesture() {
             coordinate_y: endY,
             normalized_x: 0,
             // how far down the page the gesture left them, which is what a scroll map reads
-            normalized_y: fraction(endY + (window.innerHeight || 0), height),
+            normalized_y: fraction(endY + visible, height),
             velocity: Math.round((distance / duration) * 1000),
             is_clickable: 0,
             is_rage_click: 0,
@@ -338,7 +405,7 @@ function endScrollGesture() {
     }
 }
 /** Turns capture on or off. Listeners are passive, so they never delay a click or a scroll. */
-function enableHeatmap(status) {
+function trackHeatmap(status) {
     var wanted = typeof status === 'boolean' ? status : true; // no i18n
     if (wanted === installed) {
         return;
@@ -355,10 +422,13 @@ function enableHeatmap(status) {
     }
     window.removeEventListener('pointerdown', onPointerDown, true); // no i18n
     window.removeEventListener('scroll', onScroll, true); // no i18n
+    // a gesture still settling when capture stops (a single-page app leaving a heatmap page) is
+    // recorded as it stands, not dropped: it was the visitor's last scroll on that page
     if (scrollTimer !== null) {
         clearTimeout(scrollTimer);
-        scrollTimer = null;
+        endScrollGesture();
     }
+    scrolling = null;
     installed = false;
     logger.Console.log('apptics.heatmap: capture stopped'); // no i18n
 }
@@ -368,10 +438,11 @@ function resetHeatmapSession() {
     recentClicks = [];
     lastX = 0;
     lastY = 0;
+    paneAt = new WeakMap();
 }
 // init() and reset() drive capture through these, so neither has to import this module
-hooks.hooks.enableHeatmap = enableHeatmap;
+hooks.hooks.trackHeatmap = trackHeatmap;
 hooks.hooks.resetHeatmap = resetHeatmapSession;
 
-exports.enableHeatmap = enableHeatmap;
 exports.resetHeatmapSession = resetHeatmapSession;
+exports.trackHeatmap = trackHeatmap;

package/dist/cjs/index.d.ts

@@ -1,68 +1,21 @@
-import { AP_FEEDBACK_TYPE, AP_TRACKING_STATUS } from './core/constants.js';
-import { init as initImpl, ready as readyImpl, reset as resetImpl } from './lifecycle.js';
-import { enableApiTracking as enableApiTrackingImpl } from './engagement/auto-api.js';
-import { DefinedEvents } from './engagement/defined-events.js';
-import { ApiTrackingBuilder } from './engagement/api-rules.js';
-import { enableGlobalErrorHandler as enableGlobalErrorHandlerImpl } from './errors/track.js';
-import { getUser as getUserImpl, UserBuilder, users } from './user/index.js';
-import { getTrackingStatus as getTrackingStatusImpl, setTrackingStatus as setTrackingStatusImpl } from './core/consent.js';
-import { flush as flushImpl } from './scheduler.js';
-import { addDiagnosticsInfo as addDiagnosticsInfoImpl, addFeedbackLog as addFeedbackLogImpl } from './feedback/logs.js';
-import type { AppticsApi } from './types.js';
-import { disableDebug as disableDebugImpl, enableDebug as enableDebugImpl } from './core/debug.js';
-import { AppticsLogger } from './remotelog/logger.js';
-export type { AppticsLogger as AppticsLoggerApi } from './remotelog/logger.js';
-export type { AppticsApi, AppticsConfig, ErrorLike, FeedbackType, Properties, TrackingStatus, UserInfo, UserValidationResult, } from './types.js';
-/** Android's Apptics: `Apptics.init(config)` starts the SDK. */
-export declare const Apptics: {
-    /** Starts the SDK. The config object is required; the console snippet supplies it via auto-init. */
-    init: typeof initImpl;
-};
-export declare const ready: typeof readyImpl;
-/** Android's AppticsEvents: `addEvent(name, group?, properties?)`, or `addEvent(DefinedEvents.X, properties?)`. */
-export declare const AppticsEvents: {
-    addEvent: AppticsApi["AppticsEvents"]["addEvent"];
-};
-/** Apptics' defined events, as Android's DefinedEvents, to log with AppticsEvents.addEvent. */
-export { DefinedEvents };
+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. */
+export declare const Apptics: AppticsSdk['Apptics'];
+export declare const AppticsEvent: AppticsSdk['AppticsEvent'];
 export type { DefinedEvent } from './engagement/defined-events.js';
 /** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
-export declare const AppticsScreenTracker: AppticsApi['AppticsScreenTracker'];
+export declare const AppticsScreen: AppticsSdk['AppticsScreen'];
 /** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
-export declare const AppticsApiTracker: AppticsApi['AppticsApiTracker'];
-export { ApiTrackingBuilder };
+export declare const AppticsApi: AppticsSdk['AppticsApi'];
 export type { ApiTrackingConfig } from './engagement/api-rules.js';
-/** Turns automatic API tracking on or off; the `track_api` config flag is the usual way to set it. */
-export declare const enableApiTracking: typeof enableApiTrackingImpl;
-/** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
-export declare const AppticsTrackError: AppticsApi["AppticsTrackError"];
-export declare const enableGlobalErrorHandler: typeof enableGlobalErrorHandlerImpl;
-/** Registers the signed-in user; properties may be a plain object or UserBuilder.build(). */
-export declare const AppticsSetUser: AppticsApi["AppticsSetUser"];
-export declare const getUser: typeof getUserImpl;
-export declare const setTrackingStatus: typeof setTrackingStatusImpl;
-export declare const getTrackingStatus: typeof getTrackingStatusImpl;
-export declare const flush: typeof flushImpl;
-/** Records a line for the next feedback submission. Costs nothing until feedback is sent. */
-export declare const addFeedbackLog: typeof addFeedbackLogImpl;
-/** Records a diagnostics key/value, grouped under `heading`, for the next feedback submission. */
-export declare const addDiagnosticsInfo: typeof addDiagnosticsInfoImpl;
-/**
- * Turns debug mode on; works before init(), and wins over `debug` in init().
- *
- * On, engagement, exception and log go to their `debug/` twins and the answers carry a request id
- * and a link into the server's own logs. It switches itself off after an hour with nothing
- * tracked, so a forgotten tab stops tracing on its own.
- */
-export declare const enableDebug: typeof enableDebugImpl;
-/** Turns debug mode off; works before init(), and wins over `debug` in init(). */
-export declare const disableDebug: typeof disableDebugImpl;
-export declare const reset: typeof resetImpl;
-/**
- * Android's AppticsLogger, shown on the console's Remote Logger page. Off until
- * `AppticsLogger.enable()`; then `AppticsLogger.v / d / i / w / e(tag, message, ...details)`.
- */
-export { AppticsLogger };
-export { AP_FEEDBACK_TYPE, AP_TRACKING_STATUS, UserBuilder, users };
-declare const apptics: AppticsApi;
+/** Errors: the ones the app caught, and the switch for the uncaught ones tracked on their own. */
+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.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'];
+declare const apptics: AppticsSdk;
 export default apptics;

package/dist/cjs/index.js

@@ -1,10 +1,11 @@
-/*! @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.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');
@@ -16,30 +17,80 @@ var track$1 = require('./errors/track.js');
 var index = require('./user/index.js');
 var consent = require('./core/consent.js');
 var scheduler = require('./scheduler.js');
-var logs = require('./feedback/logs.js');
-var autoInit = require('./auto-init.js');
+var track$2 = require('./heatmap/track.js');
+var send = require('./heatmap/send.js');
+var hooks = require('./core/hooks.js');
 var debug = require('./core/debug.js');
-var logger = require('./remotelog/logger.js');
 
-/** Android's Apptics: `Apptics.init(config)` starts the SDK. */
+// 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.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,
+ * exception and log go to their `debug/` twins and the answers carry a request id and a link into
+ * the server's own logs. It switches itself off after an hour with nothing tracked, so a forgotten
+ * tab stops tracing on its own.
+ */
+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. */
-    init: guard.guard('Apptics.init', lifecycle.init), // no i18n
+    /** 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; 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); },
+    enableDebug: function enableDebug() { return guard.forward(enableDebugGuarded, arguments); },
+    disableDebug: function disableDebug() { return guard.forward(disableDebugGuarded, arguments); },
 };
-const ready = guard.guard('ready', lifecycle.ready); // no i18n
-/** Android's AppticsEvents: `addEvent(name, group?, properties?)`, or `addEvent(DefinedEvents.X, properties?)`. */
-const AppticsEvents = {
-    addEvent: guard.guard('AppticsEvents.addEvent', track.trackEvent), // no i18n
+/**
+ * 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('AppticsScreenTracker.inScreen', track.inScreenAt); // no i18n
-const outScreenGuarded = guard.guard('AppticsScreenTracker.outScreen', track.outScreenAt); // no i18n
+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 AppticsScreenTracker = {
+const AppticsScreen = {
     /**
      * Records a screen view and returns its id. The view ends at the next screen, when the page is
      * hidden or its session ends, or when the id is handed to outScreen. '' for an invalid name.
      */
-    inScreen: function (screenName, properties) {
+    inScreen: function inScreen(screenName, properties) {
         if (!validate.validateScreenName(screenName)) {
             // inScreenAt reports it; the caller still needs an answer now
             inScreenGuarded(screenName, properties, '', utils.nowMs()); // no i18n
@@ -51,100 +102,98 @@ const AppticsScreenTracker = {
         return id;
     },
     /** Ends the screen view inScreen began, before the next screen would. */
-    outScreen: function (id) {
+    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('AppticsApiTracker.endTrackApi', track.endTrackApiAt); // no i18n
+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 setApiTrackingGuarded = guard.guard('AppticsApi.setApiTracking', autoApi.enableApiTracking); // no i18n
 /** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
-const AppticsApiTracker = {
+const AppticsApi = {
     /** Begins timing one call: returns the id endTrackApi takes. */
-    startTrackApi: guard.guard('AppticsApiTracker.startTrackApi', track.startTrackApi), // no i18n
+    startTrackApi: function startTrackApi(url, method) { return guard.forward(startTrackApiGuarded, arguments); },
     /** Finishes a call startTrackApi began and records it. */
-    endTrackApi: function (id, responseCode, responseMessage) {
+    endTrackApi: function endTrackApi(id, responseCode, responseMessage) {
         // the end time now, not when a call made during start-up is replayed
         endTrackApiGuarded(id, responseCode, responseMessage, utils.nowMs());
     },
+    /** Builds the rules configure takes: `new AppticsApi.ApiTrackingBuilder()…build()`. */
+    ApiTrackingBuilder: apiRules.ApiTrackingBuilder,
     /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
-    configure: guard.guard('AppticsApiTracker.configure', apiRules.configureApiTracking), // no i18n
+    configure: function configure(config) { return guard.forward(configureGuarded, 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 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; 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
+/** Android's AppticsUser: the signed-in user, and the builder for their properties. */
+const AppticsUser = {
+    /** Registers the signed-in user; properties may be a plain object or UserBuilder.build(). */
+    setUser: function setUser(userid, groupid, properties) { return guard.forward(setUserGuarded, arguments); },
+    /** The registered user, or {} when there is none. */
+    getUser: function getUser() { return guard.forward(getUserGuarded, arguments); },
+    UserBuilder: index.UserBuilder,
+};
+const setHeatmapTrackingGuarded = guard.guard('AppticsHeatmap.setHeatmapTracking', track$2.trackHeatmap); // no i18n
+/** Heatmap capture: AppticsHeatmap.setHeatmapTracking() starts or stops recording clicks and scrolls. */
+const AppticsHeatmap = {
+    /** 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
+/** Android's AppticsSettings: what the SDK may track for this visitor. */
+const AppticsSettings = {
+    /** The states setTrackingStatus takes: USAGE_TRACKING_WITH_PII, USAGE_TRACKING_WITHOUT_PII, NO_TRACKING. */
+    AP_TRACKING_STATUS: constants.AP_TRACKING_STATUS,
+    setTrackingStatus: function setTrackingStatus(status) { return guard.forward(setTrackingStatusGuarded, arguments); },
+    getTrackingStatus: function getTrackingStatus() { return guard.forward(getTrackingStatusGuarded, arguments); },
 };
-/** Turns automatic API tracking on or off; the `track_api` config flag is the usual way to set it. */
-const enableApiTracking = guard.guard('enableApiTracking', autoApi.enableApiTracking); // no i18n
-/** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
-const AppticsTrackError = guard.guard('AppticsTrackError', track$1.trackError); // no i18n
-const enableGlobalErrorHandler = guard.guard('enableGlobalErrorHandler', track$1.enableGlobalErrorHandler); // no i18n
-/** Registers the signed-in user; properties may be a plain object or UserBuilder.build(). */
-const AppticsSetUser = guard.guard('AppticsSetUser', index.setUser); // no i18n
-const getUser = guard.guard('getUser', index.getUser); // no i18n
-const setTrackingStatus = guard.guard('setTrackingStatus', consent.setTrackingStatus); // no i18n
-const getTrackingStatus = guard.guard('getTrackingStatus', consent.getTrackingStatus); // no i18n
-const flush = guard.guard('flush', scheduler.flush); // no i18n
-/** Records a line for the next feedback submission. Costs nothing until feedback is sent. */
-const addFeedbackLog = guard.guard('addFeedbackLog', logs.addFeedbackLog); // no i18n
-/** Records a diagnostics key/value, grouped under `heading`, for the next feedback submission. */
-const addDiagnosticsInfo = guard.guard('addDiagnosticsInfo', logs.addDiagnosticsInfo); // no i18n
-/**
- * Turns debug mode on; works before init(), and wins over `debug` in init().
- *
- * On, engagement, exception and log go to their `debug/` twins and the answers carry a request id
- * and a link into the server's own logs. It switches itself off after an hour with nothing
- * tracked, so a forgotten tab stops tracing on its own.
- */
-const enableDebug = guard.guard('enableDebug', debug.enableDebug); // no i18n
-/** Turns debug mode off; works before init(), and wins over `debug` in init(). */
-const disableDebug = guard.guard('disableDebug', debug.disableDebug); // no i18n
-const reset = guard.guard('reset', lifecycle.reset); // no i18n
 const apptics = {
     Apptics,
-    AppticsEvents,
-    AppticsScreenTracker,
-    AppticsApiTracker,
-    AppticsLogger: logger.AppticsLogger,
-    DefinedEvents: definedEvents.DefinedEvents,
-    ApiTrackingBuilder: apiRules.ApiTrackingBuilder,
-    ready,
-    enableDebug,
-    disableDebug,
-    enableApiTracking,
-    AppticsTrackError,
-    enableGlobalErrorHandler,
-    AppticsSetUser,
-    getUser,
-    users: index.users,
-    setTrackingStatus,
-    getTrackingStatus,
-    flush,
-    addFeedbackLog,
-    addDiagnosticsInfo,
-    reset,
-    AP_TRACKING_STATUS: constants.AP_TRACKING_STATUS,
-    AP_FEEDBACK_TYPE: constants.AP_FEEDBACK_TYPE,
+    AppticsEvent,
+    AppticsScreen,
+    AppticsApi,
+    AppticsError,
+    AppticsUser,
+    AppticsSettings,
+    AppticsHeatmap,
 };
-autoInit.scheduleAutoInit(Apptics);
 
-exports.AP_FEEDBACK_TYPE = constants.AP_FEEDBACK_TYPE;
-exports.AP_TRACKING_STATUS = constants.AP_TRACKING_STATUS;
-exports.DefinedEvents = definedEvents.DefinedEvents;
-exports.ApiTrackingBuilder = apiRules.ApiTrackingBuilder;
-exports.UserBuilder = index.UserBuilder;
-exports.users = index.users;
-exports.AppticsLogger = logger.AppticsLogger;
 exports.Apptics = Apptics;
-exports.AppticsApiTracker = AppticsApiTracker;
-exports.AppticsEvents = AppticsEvents;
-exports.AppticsScreenTracker = AppticsScreenTracker;
-exports.AppticsSetUser = AppticsSetUser;
-exports.AppticsTrackError = AppticsTrackError;
-exports.addDiagnosticsInfo = addDiagnosticsInfo;
-exports.addFeedbackLog = addFeedbackLog;
+exports.AppticsApi = AppticsApi;
+exports.AppticsError = AppticsError;
+exports.AppticsEvent = AppticsEvent;
+exports.AppticsHeatmap = AppticsHeatmap;
+exports.AppticsScreen = AppticsScreen;
+exports.AppticsSettings = AppticsSettings;
+exports.AppticsUser = AppticsUser;
 exports.default = apptics;
-exports.disableDebug = disableDebug;
-exports.enableApiTracking = enableApiTracking;
-exports.enableDebug = enableDebug;
-exports.enableGlobalErrorHandler = enableGlobalErrorHandler;
-exports.flush = flush;
-exports.getTrackingStatus = getTrackingStatus;
-exports.getUser = getUser;
-exports.ready = ready;
-exports.reset = reset;
-exports.setTrackingStatus = setTrackingStatus;

package/dist/cjs/lifecycle.d.ts

@@ -1,14 +1,32 @@
+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).
- * Returns true when the config has serviceUrl, zak, identifier and appversion and start-up has
+ * 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
  * portal and project ids and the rest; then device/add registers the browser, as in 1.x.
  */
 export declare function init(config: AppticsConfig): boolean;
+/**
+ * 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.
+ */
+export declare function screenRouteRules(routes: unknown): ScreenRouteRule[];
 /** Resolves true once start-up has finished, false if init() refused or storage is unusable. */
 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;