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

package/dist/esm/core/constants.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 const AP_TRACKING_STATUS = Object.freeze({
     USAGE_TRACKING_WITH_PII: 1,
     USAGE_TRACKING_WITHOUT_PII: 4,
@@ -138,8 +138,6 @@ const AP_CONFIG = Object.freeze({
     debug: false,
     track_by_default: true,
     ignore_do_not_track: false,
-    // the SDK's own failure reports to the Remote Logger page: off unless the app passes remote_log: true
-    remote_log: false,
     /**
      * Wrap XHR and fetch to record the app's API calls without it calling startTrackApi(). Off by
      * default: the hostnames and paths of every request an app makes is a wider grant than events
@@ -152,15 +150,16 @@ const AP_CONFIG = Object.freeze({
      */
     track_screen: true,
     /**
-     * Print each app logger line to the browser console as well, as Android's showLogs prints to
-     * Logcat. Off by default; console_log is the SDK's own activity, this is the app's lines.
+     * How automatic screen tracking names a path, as init() keeps the config's screen_routes: route
+     * patterns (`/users/{id}/orders`, each id recorded as a star), exact paths and regular
+     * expressions with a name. Tried in order; a path none matches keeps its own name.
      */
-    show_logs: false,
+    screen_routes: [],
     /**
-     * Record sessions automatically. On by default; false is Android's
-     * automaticSessionsTrackingStatus = false: no sessions, while events and screens still are.
+     * The feedback form's theme: 'light', 'dark', or 'auto' to follow the visitor's system setting.
+     * 'auto' by default.
      */
-    track_session: true,
+    feedback_theme: 'auto',
     /**
      * How long a visit must last before its session is stored, in milliseconds. A shorter visit with
      * nothing tracked in it is dropped: a bounce or a crawler is not a session. Anything tracked
@@ -206,7 +205,17 @@ const AP_CONFIG = Object.freeze({
  * What init() must be given. Everything else the SDK needs — aaid, the portal and project ids that
  * go in every url — comes back from app/addversion, which these four are enough to call.
  */
-const REQUIRED_CONFIG = Object.freeze(['serviceUrl', 'zak', 'identifier', 'appversion']); // no i18n
+const REQUIRED_CONFIG = Object.freeze(['base_url', 'auth_key', 'app_domain', 'appversion']); // no i18n
+/**
+ * The init() keys and the names the SDK keeps them under inside (and in app_version_info, which
+ * already-visited browsers have stored): base_url is the host, auth_key the `zak` header, and
+ * app_domain the app's identifier.
+ */
+const CONFIG_KEYS = Object.freeze({
+    base_url: 'serviceUrl', // no i18n
+    auth_key: 'zak', // no i18n
+    app_domain: 'identifier', // no i18n
+});
 /**
  * Paths with a `debug/` twin. The debug endpoints take the same body and answer with a request id
  * and a link to the server-side logs for that request, which is how a payload is traced end to
@@ -241,10 +250,16 @@ const RETRY_CAPABLE_PATHS = Object.freeze({
 const PATHS_WITHOUT_ORG = Object.freeze({
     addversion: true, // no i18n
 });
-/** Console-snippet names accepted for the canonical keys above. */
-const CONFIG_ALIASES = Object.freeze({
-    serviceUrl: 'base_domain', // no i18n
-    zak: 'token', // no i18n
+/**
+ * Earlier names of the init() keys: 2.0.0-beta's serviceUrl, zak and identifier, and the 1.x
+ * console snippet's base_domain and token. Still read, with a warning naming the key to use.
+ */
+const RETIRED_CONFIG_NAMES = Object.freeze({
+    serviceUrl: 'base_url', // no i18n
+    base_domain: 'base_url', // no i18n
+    zak: 'auth_key', // no i18n
+    token: 'auth_key', // no i18n
+    identifier: 'app_domain', // no i18n
 });
 // crawlers reference
 // https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers
@@ -274,4 +289,4 @@ const BLOCKED_WS = Object.freeze([
     'storebot-google', // no i18n
 ]);
 
-export { API_VERSIONS, AP_CONFIG, AP_CONSTANTS, AP_FEEDBACK_TYPE, AP_LOG_MODULE, AP_TRACKING_STATUS, BLOCKED_WS, CONFIG_ALIASES, CONSOLE_LOG_MAX_BODY, DEBUG_CAPABLE_PATHS, DEBUG_IDLE_MS, DEFAULT_API_PATHS, DEFAULT_INACTIVE_MINUTES, DEVICE_NAME_MAX, LOG_FILENAME_MAX, LOG_FUNCTION_MAX, PATHS_WITHOUT_ORG, REMOTE_LOG_LEVEL, REQUIRED_CONFIG, RETRY_CAPABLE_PATHS, SDK_MODULE };
+export { API_VERSIONS, AP_CONFIG, AP_CONSTANTS, AP_FEEDBACK_TYPE, AP_LOG_MODULE, AP_TRACKING_STATUS, BLOCKED_WS, CONFIG_KEYS, CONSOLE_LOG_MAX_BODY, DEBUG_CAPABLE_PATHS, DEBUG_IDLE_MS, DEFAULT_API_PATHS, DEFAULT_INACTIVE_MINUTES, DEVICE_NAME_MAX, LOG_FILENAME_MAX, LOG_FUNCTION_MAX, PATHS_WITHOUT_ORG, REMOTE_LOG_LEVEL, REQUIRED_CONFIG, RETIRED_CONFIG_NAMES, RETRY_CAPABLE_PATHS, SDK_MODULE };

package/dist/esm/core/db.d.ts

@@ -1,10 +1,12 @@
 import type { Dict, QueueItem } from '../types.js';
-export type QueueName = 'engagements' | 'errors' | 'logs' | 'consolelogs' | 'heatmaps';
+export type QueueName = 'engagements' | 'errors' | 'feedbacklogs' | 'remotelogs' | 'heatmaps';
 /** One storage implementation. storage.ts talks only to this interface. */
 export interface Backend {
     readonly kind: 'indexeddb' | 'localstorage';
     loadSettings(): Promise<Dict>;
     putSetting(key: string, value: unknown): Promise<void>;
+    /** Removes the key itself, so it is no longer in storage at all. */
+    deleteSetting(key: string): Promise<void>;
     clearSettings(): Promise<void>;
     /** Items in insertion order. */
     queueAll(store: QueueName): Promise<QueueItem[]>;
@@ -16,16 +18,22 @@ export interface Backend {
     importAll?(settings: Dict, queues: Record<QueueName, QueueItem[]>): Promise<void>;
 }
 export declare const DB_NAME = "apptics";
-export declare const DB_VERSION = 3;
-/** 1.x localStorage keys; also the layout of the localStorage backend. */
+export declare const DB_VERSION = 4;
+/** The types a feedback entry is stored under: an addFeedbackLog() line, an addDiagnosticsInfo() entry. */
+export declare const FEEDBACK_LOG = "feedbacklog";
+export declare const FEEDBACK_DIAGNOSTICS = "feedbackdiagnostics";
+/** A feedback entry from 1.x or 2.0.0-beta, with the type it is stored under now. */
+export declare function renameFeedbackType(item: QueueItem): QueueItem;
+/** 1.x localStorage keys, read once to bring 1.x data into IndexedDB (see migrateLegacy). */
 export declare const LEGACY_KEYS: Readonly<{
     readonly settings: "apptics-device-info";
     readonly engagements: "apptics-engagements-transactions";
     readonly errors: "apptics-errors-transactions";
     readonly logs: "apptics-log-transactions";
     readonly consolelogs: "apptics-consolelog-transactions";
-    readonly heatmaps: "apptics-heatmap-transactions";
 }>;
+/** The localStorage backend's layout, for a browser where IndexedDB will not open. */
+export declare const LOCAL_KEYS: Readonly<Record<'settings' | QueueName, string>>;
 /** Shape guards shared by both backends and the 1.x migration. */
 export declare function asList(value: unknown): QueueItem[];
 export declare function asDict(value: unknown): Dict;

package/dist/esm/core/db.js

@@ -1,24 +1,71 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { Console } from './logger.js';
 import { nowMs } from './utils.js';
 
 const DB_NAME = 'apptics'; // no i18n
-// 3 added the heatmaps store. The upgrade only creates stores that are missing, so an existing
-// database keeps everything already queued in it.
-const DB_VERSION = 3;
+// 3 added the heatmaps store. 4 renamed: each record's order key `seq` to `queue`, the logs store
+// to feedbacklogs and consolelogs to remotelogs. Every upgrade keeps what is already queued.
+const DB_VERSION = 4;
 const OPEN_TIMEOUT_MS = 3000;
-const QUEUES = ['engagements', 'errors', 'logs', 'consolelogs', 'heatmaps']; // no i18n
-/** 1.x localStorage keys; also the layout of the localStorage backend. */
+const QUEUES = ['engagements', 'errors', 'feedbacklogs', 'remotelogs', 'heatmaps']; // no i18n
+/** The field, and the index on it, that keeps a queue's records in the order they were added. */
+const QUEUE_KEY = 'queue'; // no i18n
+/** Version 3's names, which the version 4 upgrade moves to the ones above. */
+const OLD_QUEUE_KEY = 'seq'; // no i18n
+const RENAMED_STORES = [['logs', 'feedbacklogs'], ['consolelogs', 'remotelogs']]; // no i18n
+/** The types a feedback entry is stored under: an addFeedbackLog() line, an addDiagnosticsInfo() entry. */
+const FEEDBACK_LOG = 'feedbacklog'; // no i18n
+const FEEDBACK_DIAGNOSTICS = 'feedbackdiagnostics'; // no i18n
+const OLD_FEEDBACK_TYPES = Object.freeze({
+    log: FEEDBACK_LOG, // no i18n
+    diagnostics: FEEDBACK_DIAGNOSTICS, // no i18n
+});
+/** A feedback entry from 1.x or 2.0.0-beta, with the type it is stored under now. */
+function renameFeedbackType(item) {
+    var renamed = item && typeof item.type === 'string' ? OLD_FEEDBACK_TYPES[item.type] : undefined; // no i18n
+    return renamed ? { ...item, type: renamed } : item;
+}
+/** 1.x localStorage keys, read once to bring 1.x data into IndexedDB (see migrateLegacy). */
 const LEGACY_KEYS = Object.freeze({
     settings: 'apptics-device-info', // no i18n
     engagements: 'apptics-engagements-transactions', // no i18n
     errors: 'apptics-errors-transactions', // no i18n
     logs: 'apptics-log-transactions', // no i18n
     consolelogs: 'apptics-consolelog-transactions', // no i18n
-    // not a 1.x key: heatmaps did not exist then. It is here because this map is also the
-    // localStorage backend's layout, so the store needs a name there too
+});
+/** The localStorage backend's layout, for a browser where IndexedDB will not open. */
+const LOCAL_KEYS = Object.freeze({
+    settings: LEGACY_KEYS.settings,
+    engagements: LEGACY_KEYS.engagements,
+    errors: LEGACY_KEYS.errors,
+    feedbacklogs: 'apptics-feedbacklog-transactions', // no i18n
+    remotelogs: 'apptics-remotelog-transactions', // no i18n
     heatmaps: 'apptics-heatmap-transactions', // no i18n
 });
+/**
+ * The localStorage backend once kept these two under the 1.x keys. Moved to the new ones on first
+ * use, feedback types renamed on the way, unless something is already there.
+ */
+function moveRenamedLocalKeys() {
+    [[LEGACY_KEYS.logs, LOCAL_KEYS.feedbacklogs], [LEGACY_KEYS.consolelogs, LOCAL_KEYS.remotelogs]].forEach(function (pair) {
+        try {
+            var from = pair[0];
+            var to = pair[1];
+            var old = localStorage.getItem(from);
+            if (old === null) {
+                return;
+            }
+            if (localStorage.getItem(to) === null) {
+                var items = asList(JSON.parse(old));
+                localStorage.setItem(to, JSON.stringify(to === LOCAL_KEYS.feedbacklogs ? items.map(renameFeedbackType) : items));
+            }
+            localStorage.removeItem(from);
+        }
+        catch (err) {
+            // left where it is; the next load tries again
+        }
+    });
+}
 /** Shape guards shared by both backends and the 1.x migration. */
 function asList(value) {
     return Array.isArray(value) ? value : [];
@@ -46,26 +93,33 @@ function writeJSON(key, value) {
     }
 }
 function createLocalStorageBackend() {
+    moveRenamedLocalKeys();
     return {
         kind: 'localstorage', // no i18n
         loadSettings() {
-            return Promise.resolve(asDict(readJSON(LEGACY_KEYS.settings)));
+            return Promise.resolve(asDict(readJSON(LOCAL_KEYS.settings)));
         },
         putSetting(key, value) {
-            const all = asDict(readJSON(LEGACY_KEYS.settings));
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
             all[key] = value;
-            writeJSON(LEGACY_KEYS.settings, all);
+            writeJSON(LOCAL_KEYS.settings, all);
+            return Promise.resolve();
+        },
+        deleteSetting(key) {
+            const all = asDict(readJSON(LOCAL_KEYS.settings));
+            delete all[key];
+            writeJSON(LOCAL_KEYS.settings, all);
             return Promise.resolve();
         },
         clearSettings() {
-            writeJSON(LEGACY_KEYS.settings, {});
+            writeJSON(LOCAL_KEYS.settings, {});
             return Promise.resolve();
         },
         queueAll(store) {
-            return Promise.resolve(asList(readJSON(LEGACY_KEYS[store])));
+            return Promise.resolve(asList(readJSON(LOCAL_KEYS[store])));
         },
         queuePut(store, items) {
-            const list = asList(readJSON(LEGACY_KEYS[store]));
+            const list = asList(readJSON(LOCAL_KEYS[store]));
             items.forEach(function (item) {
                 const index = list.findIndex(function (existing) { return existing.id === item.id; });
                 if (index === -1) {
@@ -75,32 +129,32 @@ function createLocalStorageBackend() {
                     list[index] = item;
                 }
             });
-            writeJSON(LEGACY_KEYS[store], list);
+            writeJSON(LOCAL_KEYS[store], list);
             return Promise.resolve();
         },
         queueDelete(store, ids) {
-            const remaining = asList(readJSON(LEGACY_KEYS[store])).filter(function (item) {
+            const remaining = asList(readJSON(LOCAL_KEYS[store])).filter(function (item) {
                 return ids.indexOf(item.id) === -1;
             });
-            writeJSON(LEGACY_KEYS[store], remaining);
+            writeJSON(LOCAL_KEYS[store], remaining);
             return Promise.resolve();
         },
         queueClear(store) {
-            writeJSON(LEGACY_KEYS[store], []);
+            writeJSON(LOCAL_KEYS[store], []);
             return Promise.resolve();
         },
     };
 }
-let lastSeq = 0;
+let lastQueue = 0;
 /**
  * Strictly increasing, and time-based so tabs interleave in roughly the right order.
  * Counting up from the last value rather than a counter that wraps keeps insertion order
  * even when a chatty caller adds more than a thousand items inside one millisecond.
  */
-function nextSeq() {
+function nextQueue() {
     const base = nowMs() * 1000;
-    lastSeq = base > lastSeq ? base : lastSeq + 1;
-    return lastSeq;
+    lastQueue = base > lastQueue ? base : lastQueue + 1;
+    return lastQueue;
 }
 function request(req) {
     return new Promise(function (resolve, reject) {
@@ -115,7 +169,21 @@ function completed(tx) {
         tx.onabort = function () { reject(tx.error); };
     });
 }
-/** Puts `item` unless it exists (keepExisting) or replaces it keeping its seq. Runs inside `store`'s transaction. */
+/**
+ * The record's `type` for an item with none of its own: heatmap records carry no type, since
+ * their payload is the item itself and the server takes no extra field. Never undefined.
+ */
+const STORE_TYPES = Object.freeze({
+    engagements: 'engagement', // no i18n
+    errors: 'error', // no i18n
+    feedbacklogs: FEEDBACK_LOG,
+    remotelogs: 'remotelog', // no i18n
+    heatmaps: 'heatmap', // no i18n
+});
+function recordType(storeName, item) {
+    return item && typeof item.type === 'string' && item.type !== '' ? item.type : (STORE_TYPES[storeName] || storeName); // no i18n
+}
+/** Puts `item` unless it exists (keepExisting) or replaces it keeping its place. Runs inside `store`'s transaction. */
 function putRecord(store, item, keepExisting) {
     const id = String(item.id);
     const lookup = store.get(id);
@@ -124,7 +192,7 @@ function putRecord(store, item, keepExisting) {
         if (existing && keepExisting) {
             return;
         }
-        store.put({ id: id, seq: existing ? existing.seq : nextSeq(), type: item.type, item: item });
+        store.put({ id: id, queue: existing ? existing.queue : nextQueue(), type: recordType(store.name, item), item: item });
     };
 }
 /** Our stores, as created by onupgradeneeded. */
@@ -185,15 +253,7 @@ function openOnce(factory, timeoutMs) {
             return;
         }
         req.onupgradeneeded = function () {
-            const db = req.result;
-            if (!db.objectStoreNames.contains('settings')) { // no i18n
-                db.createObjectStore('settings'); // no i18n
-            }
-            QUEUES.forEach(function (name) {
-                if (!db.objectStoreNames.contains(name)) {
-                    db.createObjectStore(name, { keyPath: 'id' }).createIndex('seq', 'seq'); // no i18n
-                }
-            });
+            upgrade(req.result, req.transaction);
         };
         req.onsuccess = function () {
             if (settled) {
@@ -224,6 +284,70 @@ function openOnce(factory, timeoutMs) {
         };
     });
 }
+/**
+ * Creates what is missing and moves version 3's data to version 4's names, inside the upgrade's
+ * own transaction: either the whole upgrade lands, or the database stays at the old version with
+ * everything still in it.
+ */
+function upgrade(db, tx) {
+    if (!db.objectStoreNames.contains('settings')) { // no i18n
+        db.createObjectStore('settings'); // no i18n
+    }
+    QUEUES.forEach(function (name) {
+        if (!db.objectStoreNames.contains(name)) {
+            db.createObjectStore(name, { keyPath: 'id' }).createIndex(QUEUE_KEY, QUEUE_KEY); // no i18n
+        }
+    });
+    // kept stores: the order key is renamed on every record, and the index with it
+    QUEUES.forEach(function (name) {
+        const store = tx.objectStore(name);
+        if (!store.indexNames.contains(OLD_QUEUE_KEY)) {
+            return;
+        }
+        store.deleteIndex(OLD_QUEUE_KEY);
+        if (!store.indexNames.contains(QUEUE_KEY)) {
+            store.createIndex(QUEUE_KEY, QUEUE_KEY);
+        }
+        eachRecord(store, function (record, cursor) {
+            cursor.update(renamedRecord(record, false, name));
+        });
+    });
+    // renamed stores: every record moves to its new store, then the old store goes
+    RENAMED_STORES.forEach(function (pair) {
+        const from = pair[0];
+        const to = pair[1];
+        if (!db.objectStoreNames.contains(from)) {
+            return;
+        }
+        const source = tx.objectStore(from);
+        const target = tx.objectStore(to);
+        eachRecord(source, function (record) {
+            target.put(renamedRecord(record, to === 'feedbacklogs', to)); // no i18n
+        }, function () {
+            db.deleteObjectStore(from);
+        });
+    });
+}
+/** Calls `each` for every record of `store`, then `done`, inside the transaction `store` is in. */
+function eachRecord(store, each, done) {
+    const req = store.openCursor();
+    req.onsuccess = function () {
+        const cursor = req.result;
+        if (!cursor) {
+            if (done)
+                done();
+            return;
+        }
+        each(cursor.value, cursor);
+        cursor.continue();
+    };
+}
+/** A version 3 record under version 4's names: `queue` for `seq`, and the feedback types renamed. */
+function renamedRecord(record, feedback, storeName) {
+    const queue = typeof record[QUEUE_KEY] === 'number' ? record[QUEUE_KEY] : (typeof record[OLD_QUEUE_KEY] === 'number' ? record[OLD_QUEUE_KEY] : nextQueue()); // no i18n
+    const item = (feedback ? renameFeedbackType(record.item) : record.item);
+    return { id: String(record.id), queue: queue, type: recordType(storeName, item), item: item };
+}
 function createIndexedDBBackend(db) {
     return {
         kind: 'indexeddb', // no i18n
@@ -242,13 +366,18 @@ function createIndexedDBBackend(db) {
             tx.objectStore('settings').put(value, key); // no i18n
             return completed(tx);
         },
+        deleteSetting(key) {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').delete(key); // no i18n
+            return completed(tx);
+        },
         clearSettings() {
             const tx = db.transaction('settings', 'readwrite'); // no i18n
             tx.objectStore('settings').clear(); // no i18n
             return completed(tx);
         },
         queueAll(store) {
-            const index = db.transaction(store, 'readonly').objectStore(store).index('seq'); // no i18n
+            const index = db.transaction(store, 'readonly').objectStore(store).index(QUEUE_KEY);
             return request(index.getAll()).then(function (records) {
                 return records.map(function (record) { return record.item; });
             });
@@ -321,4 +450,4 @@ function openBackend() {
     return openIndexedDB(factory).then(createIndexedDBBackend, fallback);
 }
 
-export { DB_NAME, DB_VERSION, LEGACY_KEYS, asDict, asList, createIndexedDBBackend, createLocalStorageBackend, openBackend, openIndexedDB };
+export { DB_NAME, DB_VERSION, FEEDBACK_DIAGNOSTICS, FEEDBACK_LOG, LEGACY_KEYS, LOCAL_KEYS, asDict, asList, createIndexedDBBackend, createLocalStorageBackend, openBackend, openIndexedDB, renameFeedbackType };

package/dist/esm/core/debug.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { DEBUG_IDLE_MS } from './constants.js';
 import { _ZAP } from './state.js';
 import { Console } from './logger.js';

package/dist/esm/core/env.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { BLOCKED_WS } from './constants.js';
 import { includes } from './utils.js';
 

package/dist/esm/core/framework-id.d.ts

@@ -1 +1 @@
-export declare const FRAMEWORK_ID = 5996;
+export declare const FRAMEWORK_ID = 6002;

package/dist/esm/core/framework-id.js

@@ -1,7 +1,7 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 // Generated by scripts/register-version.mjs — do not edit by hand.
 // The framework id Apptics issued for this SDK, from POST /sdk/web/v1/framework/addversion
-// (version 2.0.0-beta, platform Browser). Regenerated on every npm pack.
-const FRAMEWORK_ID = 5996;
+// (version 2.0.0-beta.1, platform Browser). Regenerated on every npm pack.
+const FRAMEWORK_ID = 6002;
 
 export { FRAMEWORK_ID };

package/dist/esm/core/guard.d.ts

@@ -1,2 +1,11 @@
 /** Public calls never throw into the host app, and are buffered until start-up finishes. */
 export declare function guard<F extends (...args: any[]) => any>(name: string, fn: F): F;
+/**
+ * Hands a public call's own `arguments` to its guarded function, exactly as they were given.
+ *
+ * guard() returns a wrapper that takes `...args`, so a browser console shows every public call as
+ * `(...args)`. Each public call is therefore its own function with named parameters, which is what
+ * the console shows, and forwards through this: `arguments` rather than the named parameters, so
+ * a call keeps its argument count (addEvent tells its two forms apart by it).
+ */
+export declare function forward<F extends (...args: any[]) => any>(guarded: F, args: IArguments): ReturnType<F>;

package/dist/esm/core/guard.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { _ZAP } from './state.js';
 import { warnAlways, logFailure } from './logger.js';
 
@@ -8,29 +8,31 @@ import { warnAlways, logFailure } from './logger.js';
  * The two log collectors run now so an entry keeps the time it actually happened.
  */
 const RUN_BEFORE_READY = {
-    'Apptics.init': true, ready: true, reset: true, getUser: true, getTrackingStatus: true, sendFeedback: true,
-    addFeedbackLog: true, addDiagnosticsInfo: true,
-    // a switch, so it takes effect in order with the lines logged after it
-    'AppticsLogger.enable': true, 'AppticsLogger.disable': true, 'AppticsLogger.isEnabled': true,
+    'Apptics.init': true, 'Apptics.ready': true, 'Apptics.reset': true, 'AppticsUser.getUser': true,
+    'AppticsSettings.getTrackingStatus': true, 'AppticsFeedback.sendFeedback': true,
+    'AppticsFeedback.addFeedbackLog': true, 'AppticsFeedback.addDiagnosticsInfo': true,
+    // a switch, which init() must not undo: it keeps what was set when its config has no theme
+    'AppticsFeedback.setFeedbackTheme': true,
     // a switch, and a call that hands back the id endTrackApi needs: neither can wait in a queue
-    'AppticsApiTracker.configure': true, 'AppticsApiTracker.startTrackApi': true,
+    'AppticsApi.configure': true, 'AppticsApi.startTrackApi': true,
     // these wait for ready() themselves, and a queued call would hand back undefined, not a Promise
     'AppticsRemoteConfig.fetchValue': true, 'AppticsRemoteConfig.fetchValues': true,
-    'AppticsRemoteConfig.setFallbackWithOfflineValue': true, 'AppticsRemoteConfig.setCustomConditionValue': true,
-    enableDebug: true, disableDebug: true,
+    'AppticsRemoteConfig.setCustomConditionValue': true,
+    'Apptics.enableDebug': true, 'Apptics.disableDebug': true,
 };
 /**
  * Calls that record or send something, and so are lost when the SDK hasn't started. Calls that only
- * set a switch or read a value (enableDebug, AppticsLogger.enable, addFeedbackLog, getUser, …)
+ * set a switch or read a value (Apptics.enableDebug, AppticsLogger.enable, AppticsFeedback.addFeedbackLog,
+ * AppticsUser.getUser, …)
  * work without Apptics.init() and are not listed.
  */
 const NEEDS_INIT = {
-    'AppticsEvents.addEvent': true, 'AppticsScreenTracker.inScreen': true, 'AppticsScreenTracker.outScreen': true,
-    'AppticsApiTracker.endTrackApi': true, AppticsTrackError: true, AppticsSetUser: true, flush: true,
-    AppticsLogger: true, sendFeedback: true, 'AppticsRemoteConfig.fetchValue': true,
+    'AppticsEvent.addEvent': true, 'AppticsScreen.inScreen': true, 'AppticsScreen.outScreen': true,
+    'AppticsApi.endTrackApi': true, 'AppticsError.trackError': true, 'AppticsUser.setUser': true,
+    'Apptics.flush': true, AppticsLogger: true, 'AppticsFeedback.sendFeedback': true, 'AppticsRemoteConfig.fetchValue': true,
     'AppticsRemoteConfig.fetchValues': true,
 };
-/** How a call is named in a message: `AppticsEvents.addEvent` as it is, `flush` as `apptics.flush`. */
+/** How a call is named in a message: every public call is named after its object, as `AppticsEvent.addEvent`. */
 function publicName(name) {
     return name.indexOf('Apptics') === 0 ? name : 'apptics.' + name; // no i18n
 }
@@ -66,5 +68,16 @@ function guard(name, fn) {
     };
     return guarded;
 }
+/**
+ * Hands a public call's own `arguments` to its guarded function, exactly as they were given.
+ *
+ * guard() returns a wrapper that takes `...args`, so a browser console shows every public call as
+ * `(...args)`. Each public call is therefore its own function with named parameters, which is what
+ * the console shows, and forwards through this: `arguments` rather than the named parameters, so
+ * a call keeps its argument count (addEvent tells its two forms apart by it).
+ */
+function forward(guarded, args) {
+    return guarded.apply(null, Array.prototype.slice.call(args));
+}
 
-export { guard };
+export { forward, guard };

package/dist/esm/core/hooks.d.ts

@@ -1,4 +1,3 @@
-import type { CallSite } from './callsite.js';
 import type { DeviceInfo, ServerResult } from '../types.js';
 /**
  * Late-bound calls from lower modules up to the modules above them (see spec §5). device.ts and
@@ -9,7 +8,6 @@ export declare const hooks: {
     updateDevice: (deviceInfo: DeviceInfo) => Promise<ServerResult>;
     refreshDeviceInfo: () => void;
     /** Set by remotelog/index.ts. Here, not imported, so the logger doesn't depend on the sender. */
-    remoteLog: (module: string, message: unknown, site?: CallSite) => void;
     /**
      * Set by feedback/controls.ts: the user picked in the feedback form, or null for anonymous.
      * Here so transport can read the choice without importing the modal.
@@ -24,7 +22,7 @@ export declare const hooks: {
      */
     sendHeatmaps: (forget?: boolean) => Promise<void>;
     /** Set by heatmap/track.ts, so init() and reset() can switch capture without importing it. */
-    enableHeatmap: (status?: boolean) => void;
+    trackHeatmap: (status?: boolean) => void;
     /** Set by heatmap/track.ts: clears what this visit recorded, so the cap starts again. */
     resetHeatmap: () => void;
     /** Set by remoteconfig/fetch.ts, so reset() can forget the rule set without importing it. */
@@ -36,6 +34,6 @@ export declare const hooks: {
     screenTrackedByApp: () => void;
     /** Set by remoteconfig/fetch.ts: start-up has finished, so remote config fetches its values. */
     remoteConfigStarted: () => void;
-    /** Set by remoteconfig/fetch.ts: AppticsSetUser changed who this is, so conditions on the user re-apply. */
+    /** Set by remoteconfig/fetch.ts: AppticsUser.setUser changed who this is, so conditions on the user re-apply. */
     remoteConfigUserChanged: () => void;
 };

package/dist/esm/core/hooks.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 /**
  * Late-bound calls from lower modules up to the modules above them (see spec §5). device.ts and
  * remotelog/index.ts assign these when they are evaluated; the defaults only run if that module
@@ -7,10 +7,9 @@
 const hooks = {
     updateDevice: () => Promise.reject('apptics: device module not loaded'), // no i18n
     refreshDeviceInfo: () => { },
-    remoteLog: () => { },
     feedbackUser: () => null,
     sendHeatmaps: () => Promise.resolve(),
-    enableHeatmap: () => { },
+    trackHeatmap: () => { },
     resetHeatmap: () => { },
     resetRemoteConfig: () => { },
     screenTrackedByApp: () => { },

package/dist/esm/core/locks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runs `run` while holding the Web Lock `name`, waiting for it if another tab of this site holds
+ * it. Locks are shared by every tab of an origin, which is what keeps two tabs from registering
+ * the same browser twice or overwriting each other's session.
+ *
+ * Without the Web Locks API (older browsers), `run` simply runs, as it did before locks were used.
+ * Not reentrant: `run` must not ask for the same lock again, or it waits for itself.
+ */
+export declare function withLock<T>(name: string, run: () => Promise<T>): Promise<T>;

package/dist/esm/core/locks.js

@@ -0,0 +1,20 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/**
+ * Runs `run` while holding the Web Lock `name`, waiting for it if another tab of this site holds
+ * it. Locks are shared by every tab of an origin, which is what keeps two tabs from registering
+ * the same browser twice or overwriting each other's session.
+ *
+ * Without the Web Locks API (older browsers), `run` simply runs, as it did before locks were used.
+ * Not reentrant: `run` must not ask for the same lock again, or it waits for itself.
+ */
+function withLock(name, run) {
+    var locks = typeof navigator !== 'undefined' ? navigator.locks : undefined; // no i18n
+    if (!locks || typeof locks.request !== 'function') { // no i18n
+        return run();
+    }
+    return locks.request('apptics-' + name, function () {
+        return run();
+    });
+}
+
+export { withLock };

package/dist/esm/core/logger.d.ts

@@ -8,9 +8,8 @@ export declare const Console: {
 /** Warnings the integrator must see even with debug off (e.g. missing required config). */
 export declare function warnAlways(...args: unknown[]): void;
 /**
- * A failure inside one of the SDK's own modules: logged to the console as usual, and sent to
- * console/addlog so it can be read back from the Apptics console when the SDK misbehaves in the
- * wild. `module` is one of AP_LOG_MODULE's values. The remote half does nothing until
- * the remotelog module has been loaded and its own switch allows it.
+ * A failure inside one of the SDK's own modules, `module` one of AP_LOG_MODULE's values: said in
+ * the browser console in debug mode. Nothing is sent: the Remote Logger page carries only the
+ * lines an app logs with AppticsLogger.
  */
 export declare function logFailure(module: string, ...args: unknown[]): void;