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

package/dist/esm/{core → remotelog}/callsite.js

@@ -1,11 +1,12 @@
-/*! @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 */
 /**
- * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ * Where in the app an AppticsLogger line was written, for logSDK's `filename`, `linenumber` and
+ * `function`: the Remote Logger page shows each line with them.
  *
  * There is no caller introspection in a browser, so the only way to answer "which line was this"
- * is to throw an Error nobody catches and read its stack. That is cheap enough for a channel that
- * only carries the SDK's own failures, but it is never on the app's path: everything here is
- * wrapped so a stack we cannot parse costs a line its call site and nothing more.
+ * is to make an Error and read its stack, skipping the SDK's own frames. That costs a little on
+ * every line the app logs, and nothing on any other call. Everything here is wrapped so a stack
+ * that cannot be parsed costs a line its call site and nothing more: the line is still logged.
  */
 const NO_CALL_SITE = { filename: '', linenumber: 0, fn: '' };
 /**

package/dist/esm/remotelog/gate.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 { is_apptics_disabled } from '../core/env.js';
 import { shouldTrackOrSendData } from '../core/consent.js';

package/dist/esm/remotelog/logger.js

@@ -1,6 +1,6 @@
-/*! @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 { LOG_FUNCTION_MAX } from '../core/constants.js';
-import { callSite } from '../core/callsite.js';
+import { callSite } from './callsite.js';
 import { remotelog_transactions } from '../core/storage.js';
 import { guard } from '../core/guard.js';
 import { nowMs } from '../core/utils.js';

package/dist/esm/remotelog/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 { LOG_FUNCTION_MAX, CONSOLE_LOG_MAX_BODY, REMOTE_LOG_LEVEL, LOG_FILENAME_MAX } from '../core/constants.js';
 import { _ZAP } from '../core/state.js';
 import { warnAlways, Console } from '../core/logger.js';
@@ -40,7 +40,7 @@ function entryFor(item) {
     var entry = {
         sessionstarttime: _ZAP._current_session.starttime || item.happenedat || nowMs(),
         logtime: item.happenedat || nowMs(),
-        // an app's line carries the level it was logged at; the SDK's own failures carry none
+        // an app's line carries the level it was logged at; only a line an older SDK stored has none
         level: Number(item.level) || REMOTE_LOG_LEVEL,
         logmessage: String(item.exceptionlog).slice(0, CONSOLE_LOG_MAX_BODY),
         function: String(item.module || 'SDK').slice(0, LOG_FUNCTION_MAX), // no i18n

package/dist/esm/remotelogger/index.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 { AppticsLogger } from '../remotelog/logger.js';
 
 /**

package/dist/esm/scheduler.d.ts

@@ -3,6 +3,8 @@
  * response (page hide), so they survive the page going away.
  */
 export declare function flush(forget?: boolean): Promise<void>;
-/** Starts the flush and getupdates intervals once; later calls do nothing until stopTimers(). */
+/** Apptics.flush(): flush(), at most once every CALLED_FLUSH_GAP_MS. A call sooner sends nothing. */
+export declare function calledFlush(): Promise<void>;
+/** Starts the flush interval once; later calls do nothing until stopTimers(). */
 export declare function startTimers(): void;
 export declare function stopTimers(): void;

package/dist/esm/scheduler.js

@@ -1,13 +1,13 @@
-/*! @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, getConfig } from './core/state.js';
-import { nowMs } from './core/utils.js';
 import { Console } from './core/logger.js';
+import { nowMs } from './core/utils.js';
 import { canTrack } from './core/consent.js';
 import { clearDefer } from './core/batch.js';
 import { sendEngagementData } from './engagement/send.js';
 import { sendErrorData } from './errors/send.js';
 import { hooks } from './core/hooks.js';
-import { getUpdatesFromServer } from './device/index.js';
+import { stopServerSettingChecks } from './device/index.js';
 import { expireDebugIfIdle } from './core/debug.js';
 
 /**
@@ -27,9 +27,26 @@ function flush(forget) {
         return hooks.sendHeatmaps(forget);
     });
 }
+/**
+ * How often Apptics.flush() sends when it is called by hand, from the console or the app's own
+ * code: once every 15 seconds, however often it is called. The SDK's own sends (the flush
+ * interval, page hide and close, back online) call flush() directly and are not held to it.
+ */
+const CALLED_FLUSH_GAP_MS = 15 * 1000;
+/** When Apptics.flush() last sent; 0 until it has. */
+var calledFlushAt = 0;
+/** Apptics.flush(): flush(), at most once every CALLED_FLUSH_GAP_MS. A call sooner sends nothing. */
+function calledFlush() {
+    var now = nowMs();
+    if (calledFlushAt > 0 && now - calledFlushAt < CALLED_FLUSH_GAP_MS) {
+        Console.log('Apptics.flush: sent ' + (now - calledFlushAt) + ' ms ago; it sends at most once every ' + CALLED_FLUSH_GAP_MS + ' ms, and the timer sends the rest'); // no i18n
+        return Promise.resolve();
+    }
+    calledFlushAt = now;
+    return flush();
+}
 var sendingInterval = null;
-var getUpdatesInterval = null;
-/** Starts the flush and getupdates intervals once; later calls do nothing until stopTimers(). */
+/** Starts the flush interval once; later calls do nothing until stopTimers(). */
 function startTimers() {
     if (sendingInterval === null) {
         sendingInterval = setInterval(function () {
@@ -46,29 +63,14 @@ function startTimers() {
             });
         }, getConfig('batch_flush_interval')); // no i18n
     }
-    if (getUpdatesInterval === null) {
-        // the interval is the floor, not the schedule: getsdkconfig answers with next_check_after,
-        // and asking again before then is a call the server has already told us it will not answer
-        // differently. The timer still ticks so a server that sends no hint behaves as before.
-        getUpdatesInterval = setInterval(function () {
-            if (_ZAP._nextConfigCheck > 0 && nowMs() < _ZAP._nextConfigCheck) {
-                return;
-            }
-            Console.log('scheduleToGetUpdatesFromServer: asking the server for its config'); // no i18n
-            getUpdatesFromServer().catch(function (err) {
-                Console.log(err);
-            });
-        }, getConfig('getupdates_interval')); // no i18n
-    }
 }
 function stopTimers() {
     if (sendingInterval !== null)
         clearInterval(sendingInterval);
-    if (getUpdatesInterval !== null)
-        clearInterval(getUpdatesInterval);
     sendingInterval = null;
-    getUpdatesInterval = null;
     clearDefer();
+    stopServerSettingChecks();
+    calledFlushAt = 0;
 }
 
-export { flush, startTimers, stopTimers };
+export { calledFlush, flush, startTimers, stopTimers };

package/dist/esm/types.d.ts

@@ -37,7 +37,7 @@ export interface ServerResult<T = Dict> {
 export type TrackingStatus = (typeof AP_TRACKING_STATUS)[keyof typeof AP_TRACKING_STATUS];
 export type FeedbackType = (typeof AP_FEEDBACK_TYPE)[keyof typeof AP_FEEDBACK_TYPE];
 export type Properties = Record<string, unknown>;
-/** The config init() requires. The console snippet provides the same shape as window.appticssettings._defaultoptions. */
+/** The config init() requires. */
 export interface AppticsConfig {
     /** Apptics host every request goes to, e.g. https://apptics.zoho.com (a trailing slash is ignored). Was `serviceUrl`. */
     base_url: string;
@@ -87,6 +87,18 @@ export interface AppticsConfig {
      * navigation replaces its automatic view; set this false to track only the app's own calls.
      */
     track_screen?: boolean;
+    /**
+     * Record uncaught errors and unhandled promise rejections automatically. On by default; set this
+     * false to record only the errors the app hands to AppticsError.trackError(). Switched later with
+     * AppticsError.setErrorTracking().
+     */
+    track_error?: boolean;
+    /**
+     * Record clicks on elements tagged `apeventaction` (or `data-apeventaction`) as events, in the
+     * group of the nearest `apgroupaction` around them. On by default; switched later with
+     * AppticsEvent.setClickTracking().
+     */
+    track_click?: boolean;
     /**
      * How automatic screen tracking names a path, tried in order; the first that matches wins, and a
      * path none matches keeps its own name. Each entry is one of:
@@ -105,13 +117,19 @@ export interface AppticsConfig {
     feedback_theme?: 'light' | 'dark' | 'auto';
     /** How often queued data is sent, in milliseconds. Default 30000, at least 1000. */
     batch_flush_interval?: number;
-    /** How often the server's tracking flags are fetched, in milliseconds. Default 120000, at least 10000. */
+    /**
+     * How long to wait before reading the server's tracking settings again, in milliseconds, when its
+     * answer gives no time for the next check (next_check_after). Default 120000, at least 10000.
+     */
     getupdates_interval?: number;
     /** Most items in one batch. Default 50, between 1 and 500. */
     batch_size?: number;
     /** Days an unsent item is kept before it is dropped. Default 7, between 1 and 30. */
     batch_request_timeout?: number;
-    /** Idle minutes that end a session. Default 30, between 1 and 1440. */
+    /**
+     * Minutes a tab can be inactive (hidden, minimised, in the background) before its session ends,
+     * at the moment the user left. Default 30, between 1 and 1440.
+     */
     inactiveduration?: number;
     /**
      * How long a visit must last before its session is recorded, in milliseconds. Default 5000, at
@@ -120,8 +138,8 @@ export interface AppticsConfig {
      */
     min_session_duration?: number;
     /**
-     * Record where people click and how far they scroll. Off by default; AppticsHeatmap.trackHeatmap()
-     * switches it later.
+     * Record where people click and how far they scroll. Off by default;
+     * AppticsHeatmap.setHeatmapTracking() switches it later.
      */
     track_heatmap?: boolean;
     /** Most heatmap records one visit may produce. Default 500; capture pauses past it. */
@@ -175,8 +193,9 @@ export interface QuartzApi {
         quartzBranding: boolean;
     }): void;
     clearFeedback(): void;
-    endRecording(): void;
-    setVideoContent(element: Element | null): void;
+    /** Resolves once the recording has ended and is stored; Quartz's own build returns a Promise. */
+    endRecording(): Promise<unknown> | void;
+    setVideoContent(element: Element | null): Promise<unknown> | void;
     submitRecording(details: {
         email: string;
         subject: string;
@@ -256,7 +275,7 @@ export interface SendFeedbackOptions {
     attachments?: FileList | File[] | null;
     /** Log files of the app's own to send along. */
     logFiles?: FileList | File[] | null;
-    /** The addDiagnosticsInfo() entries and the device's details: unset sends them when there are entries waiting. */
+    /** The addDiagnosticsInfo() entries: unset sends them when there are any, false never does. */
     includeDiagnostics?: boolean;
     /** The addFeedbackLog() lines: unset sends them when there are any, false never does. */
     includeLog?: boolean;
@@ -305,11 +324,15 @@ export interface AppticsFeedbackApi {
 export interface AppticsSdk {
     /** Android's Apptics: starting the SDK, and what applies to all of it. */
     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(config: AppticsConfig): boolean;
         /** Resolves true once start-up (storage load, device, session) has finished; false if it can't start. */
         ready(): Promise<boolean>;
-        /** Sends stored engagements, errors and heatmap records now; resolves once they have gone out. */
+        /**
+         * Sends stored engagements, errors and heatmap records now; resolves once they have gone out.
+         * At most once every 15 seconds: a call sooner than that sends nothing and resolves at once,
+         * and what is queued goes with the next timed send.
+         */
         flush(): Promise<void>;
         /** Clears stored identity, queued data and remote config values, then starts again. */
         reset(): void;
@@ -326,10 +349,15 @@ export interface AppticsSdk {
     AppticsEvent: {
         /** Apptics' defined events, as Android's DefinedEvents, to log with addEvent. */
         DefinedEvents: typeof DefinedEvents;
-        /** An event. An invalid name or group is not logged; a group left out is `default`. */
-        addEvent(eventName: string, groupName?: string, properties?: Properties): void;
+        /** An event. The group is required: an event without one, or with an invalid name or group, is not logged, and the console says why. */
+        addEvent(eventName: string, groupName: string, properties?: Properties): void;
         /** A defined event (AppticsEvent.DefinedEvents.AP_USER_LOGIN, …), which brings its own group. */
         addEvent(definedEvent: DefinedEvent, properties?: Properties): void;
+        /**
+         * Turns click tracking from markup (`apeventaction`) on or off after Apptics.init(); `enabled`
+         * defaults to true. The `track_click` config flag sets it at start-up.
+         */
+        setClickTracking(enabled?: boolean): void;
     };
     /** Android's AppticsScreenTracker. */
     AppticsScreen: {
@@ -337,6 +365,11 @@ export interface AppticsSdk {
         inScreen(screenName: string, properties?: Properties): string;
         /** Ends the screen view inScreen began, before the next screen would. */
         outScreen(id: string): void;
+        /**
+         * Turns automatic screen tracking on or off after Apptics.init(); `enabled` defaults to true.
+         * The `track_screen` config flag sets it at start-up. inScreen() records either way.
+         */
+        setScreenTracking(enabled?: boolean): void;
     };
     /** Android's AppticsApiTracker. */
     AppticsApi: {
@@ -349,16 +382,23 @@ export interface AppticsSdk {
         /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
         configure(config: ApiTrackingConfig | ApiTrackingBuilder): void;
         /**
-         * Turns automatic API tracking on or off after Apptics.init(). Equivalent to the `track_api`
-         * config flag, which is the usual way to set it.
+         * Turns automatic API tracking on or off after Apptics.init(); `enabled` defaults to true.
+         * The `track_api` config flag sets it at start-up.
          */
+        setApiTracking(enabled?: boolean): void;
+        /** @deprecated renamed setApiTracking; this name still works, with a console warning */
         enableApiTracking(enabled?: boolean): void;
     };
     /** Errors the app caught, and the switch for tracking uncaught ones. */
     AppticsError: {
         /** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
         trackError(error: ErrorLike, properties?: Properties): void;
-        /** Turns the automatic tracking of uncaught errors and unhandled rejections on or off. */
+        /**
+         * Turns the automatic tracking of uncaught errors and unhandled rejections on or off after
+         * Apptics.init(); `enabled` defaults to true. The `track_error` config flag sets it at start-up.
+         */
+        setErrorTracking(enabled?: boolean): void;
+        /** @deprecated renamed setErrorTracking; this name still works, with a console warning */
         trackGlobalErrorHandler(enabled?: boolean): void;
     };
     /** Android's AppticsUser. */
@@ -372,7 +412,12 @@ export interface AppticsSdk {
     };
     /** Click and scroll capture for the console's heatmaps. */
     AppticsHeatmap: {
-        /** Starts or stops recording clicks and scrolls; `on` defaults to true. */
+        /**
+         * Starts or stops recording clicks and scrolls; `enabled` defaults to true. The
+         * `track_heatmap` config flag sets it at start-up.
+         */
+        setHeatmapTracking(enabled?: boolean): void;
+        /** @deprecated renamed setHeatmapTracking; this name still works, with a console warning */
         trackHeatmap(on?: boolean): void;
     };
     /** Android's AppticsSettings: what the SDK may track for this visitor. */

package/dist/esm/user/index.js

@@ -1,10 +1,10 @@
-/*! @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_TRACKING_STATUS } from '../core/constants.js';
 import { _ZAP } from '../core/state.js';
 import { logFailure, Console } from '../core/logger.js';
 import { isEmpty, nowMs, isEmptyObj, cloneMapExcludingKeys } from '../core/utils.js';
 import { user_defaults } from '../core/storage.js';
-import { canTrack, setTrackingStatus } from '../core/consent.js';
+import { canTrack, recordTrackingStatus } from '../core/consent.js';
 import { rejectIfDisabled, rejectIfOffline, rejectIfNoDeviceIds, postToApptics, apiHeaders } from '../core/transport.js';
 import { userValidateJSON } from '../core/validate.js';
 import { hooks } from '../core/hooks.js';
@@ -102,11 +102,15 @@ function registerUserWithApptics(user_info) {
         var data = result.data || {};
         user_info.userid = data.userid;
         user_info.groupid = data.customergroupid;
-        setTrackingStatus(AP_TRACKING_STATUS.USAGE_TRACKING_WITH_PII);
+        // stored only: user/register has told the server, and the device is registered already
+        recordTrackingStatus(AP_TRACKING_STATUS.USAGE_TRACKING_WITH_PII);
         addOrUpdateUser(user_info);
         getUserInfo();
         // the user and their customer group are known now: remote config conditions on them re-apply
         hooks.remoteConfigUserChanged();
+        // getsdkconfig answers for the user (with every module off for one whose customer group
+        // is not tracked, customergrouptracking: false), so it is asked again for them now
+        hooks.askServerSettings();
         return data;
     });
 }