@zoho_apptics/apptics-js-sdk 1.0.1 → 2.0.0-beta

package/dist/cjs/core/debug.d.ts

@@ -0,0 +1,22 @@
+/** Whether debug mode is on right now, idle hour included. */
+export declare function debugEnabled(): boolean;
+/**
+ * Pushes the idle hour out. Called wherever something is actually tracked, which is the only
+ * evidence the SDK has that a person is still looking — there is no event for "watching".
+ */
+export declare function noteDebugActivity(): void;
+/**
+ * Turns debug mode off if its hour has run out. Called from the flush timer, which ticks whether
+ * or not anything is happening — a check that only ran on the way into a request would never
+ * fire, because an idle SDK makes no requests.
+ */
+export declare function expireDebugIfIdle(): void;
+/**
+ * Turns debug mode on, at any time: before init(), during start-up or while the SDK runs. The
+ * choice holds over `debug` in init() for the rest of the page's life.
+ */
+export declare function enableDebug(): void;
+/** Turns debug mode off, at any time, with the same hold over `debug` as enableDebug(). */
+export declare function disableDebug(): void;
+/** What init() applies for `debug`: the config's value, unless the app has already chosen. */
+export declare function applyDebugConfig(configured: boolean): void;

package/dist/cjs/core/debug.js

@@ -0,0 +1,88 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./constants.js');
+var state = require('./state.js');
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+
+/**
+ * The switch for debug mode, and the hour that closes it.
+ *
+ * Debug mode is not free on either side: every engagement, exception and log call goes to its
+ * `debug/` twin instead of the ordinary endpoint, which makes the server keep a traceable
+ * record of the request. That is worth it while someone is watching, and pure
+ * cost once they have walked away — and walking away is the normal way a debugging session ends,
+ * not a deliberate switch-off. So the SDK closes it: an hour with nothing tracked turns debug
+ * back off by itself, and anything tracked pushes that hour out again.
+ *
+ * It lives in core because every send asks it: `debug: true` in init(), or enableDebug(), is
+ * enough to turn the twins on, and that alone must expire.
+ */
+/** Whether debug mode is on right now, idle hour included. */
+function debugEnabled() {
+    return state._ZAP._config.debug_api === true && !debugIdle();
+}
+/** True once the idle hour has run out on a debug session nobody is watching. */
+function debugIdle() {
+    return state._ZAP._debugUntil > 0 && utils.nowMs() > state._ZAP._debugUntil;
+}
+/**
+ * Pushes the idle hour out. Called wherever something is actually tracked, which is the only
+ * evidence the SDK has that a person is still looking — there is no event for "watching".
+ */
+function noteDebugActivity() {
+    if (state._ZAP._config.debug_api !== true) {
+        return;
+    }
+    state._ZAP._debugUntil = utils.nowMs() + constants.DEBUG_IDLE_MS;
+}
+/**
+ * Turns debug mode off if its hour has run out. Called from the flush timer, which ticks whether
+ * or not anything is happening — a check that only ran on the way into a request would never
+ * fire, because an idle SDK makes no requests.
+ */
+function expireDebugIfIdle() {
+    if (!debugIdle()) {
+        return;
+    }
+    logger.Console.log('apptics: debug mode has been idle for an hour, switching it off'); // no i18n
+    setDebug(false);
+}
+/**
+ * The app's own choice, from enableDebug() or disableDebug(). It wins over `debug` in init(),
+ * so debug mode can be switched on or off with one call, before init() runs or while the SDK is
+ * running, and an init() or reset() that comes after doesn't switch it back. null until the app
+ * has chosen.
+ */
+var chosen = null;
+/** Turning it on starts the idle hour; turning it off clears it, so the next on gets a whole hour. */
+function setDebug(on) {
+    state._ZAP._config.debug_api = on;
+    state._ZAP._debugUntil = on ? utils.nowMs() + constants.DEBUG_IDLE_MS : 0;
+    logger.Console.log('apptics: debug mode ' + (on ? 'on' : 'off')); // no i18n
+}
+/**
+ * Turns debug mode on, at any time: before init(), during start-up or while the SDK runs. The
+ * choice holds over `debug` in init() for the rest of the page's life.
+ */
+function enableDebug() {
+    chosen = true;
+    setDebug(true);
+}
+/** Turns debug mode off, at any time, with the same hold over `debug` as enableDebug(). */
+function disableDebug() {
+    chosen = false;
+    setDebug(false);
+}
+/** What init() applies for `debug`: the config's value, unless the app has already chosen. */
+function applyDebugConfig(configured) {
+    setDebug(chosen !== null ? chosen : configured);
+}
+
+exports.applyDebugConfig = applyDebugConfig;
+exports.debugEnabled = debugEnabled;
+exports.disableDebug = disableDebug;
+exports.enableDebug = enableDebug;
+exports.expireDebugIfIdle = expireDebugIfIdle;
+exports.noteDebugActivity = noteDebugActivity;

package/dist/cjs/core/env.d.ts

@@ -0,0 +1,28 @@
+import type { AppticsConfig } from '../types.js';
+export declare function isBlockedWS(ua: string): boolean;
+/** Device RAM as the API wants it ("4 GB"). Chromium only; empty elsewhere. */
+export declare function getRam(): string;
+export declare function getConnectionType(): string;
+export declare function getNetworkStatus(): number;
+/**
+ * The battery as a whole percentage, or null where the browser will not say.
+ *
+ * feedbackWebSDK types `battery` as an int and the console shows it next to a report, which is
+ * what makes "it died while I was filling this in" legible. The Battery Status API is behind a
+ * promise and is absent in Firefox and Safari entirely, so this answers null rather than 0 -
+ * a real 0% and "no answer" are different things, and only one of them belongs in a report.
+ */
+export declare function getBatteryPercent(): Promise<number | null>;
+export declare function getOrientation(): number;
+export declare function getDevice(): string;
+export declare function getOS(): string;
+export declare function getBrowser(): string;
+export declare function getBrowserVersion(): number | string;
+export declare function getReferringURL(): string;
+export declare function getTimeZone(): string;
+/** True for crawlers and non-browser environments; the SDK does nothing for them. */
+export declare function is_apptics_disabled(): boolean;
+/** Pure DNT check (no side effects). consent.hasDoNotTrackEnabled() applies NO_TRACKING. */
+export declare function isDntOn(): boolean;
+/** The console snippet's config (window.appticssettings._defaultoptions), if the page defines one. */
+export declare function getSnippetOptions(): AppticsConfig | undefined;

package/dist/cjs/core/env.js

@@ -0,0 +1,267 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('./constants.js');
+var utils = require('./utils.js');
+
+function isBlockedWS(ua) {
+    var i;
+    ua = ua.toLowerCase();
+    for (i = 0; i < constants.BLOCKED_WS.length; i++) {
+        if (ua.indexOf(constants.BLOCKED_WS[i]) !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Device RAM as the API wants it ("4 GB"). Chromium only; empty elsewhere. */
+function getRam() {
+    var gb = navigator.deviceMemory;
+    return typeof gb === 'number' && gb > 0 ? gb + ' GB' : ''; // no i18n
+}
+function getConnectionType() {
+    var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection || {};
+    return connection.effectiveType || connection.type || ''; // no i18n
+}
+function getNetworkStatus() {
+    return window.navigator.onLine ? 0 : -1;
+}
+/**
+ * The battery as a whole percentage, or null where the browser will not say.
+ *
+ * feedbackWebSDK types `battery` as an int and the console shows it next to a report, which is
+ * what makes "it died while I was filling this in" legible. The Battery Status API is behind a
+ * promise and is absent in Firefox and Safari entirely, so this answers null rather than 0 -
+ * a real 0% and "no answer" are different things, and only one of them belongs in a report.
+ */
+function getBatteryPercent() {
+    try {
+        var getBattery = navigator.getBattery;
+        if (typeof getBattery !== 'function') { // no i18n
+            return Promise.resolve(null);
+        }
+        return getBattery.call(navigator).then(function (battery) {
+            var level = battery && typeof battery.level === 'number' ? battery.level : -1; // no i18n
+            return level >= 0 && level <= 1 ? Math.round(level * 100) : null;
+        }, function () {
+            return null;
+        });
+    }
+    catch (err) {
+        return Promise.resolve(null);
+    }
+}
+function getOrientation() {
+    var orientation = (window.screen && window.screen.orientation && window.screen.orientation.type) || ''; // no i18n
+    if (utils.includes(orientation, 'portrait-primary')) { // no i18n
+        return 0;
+    }
+    if (utils.includes(orientation, 'landscape-primary')) { // no i18n
+        return 1;
+    }
+    if (utils.includes(orientation, 'landscape-secondary')) { // no i18n
+        return 2;
+    }
+    if (utils.includes(orientation, 'portrait-secondary')) { // no i18n
+        return 3;
+    }
+    return -1;
+}
+function getDevice() {
+    var ua = navigator.userAgent;
+    if (/Windows/i.test(ua)) {
+        return (/Phone/.test(ua) || /WPDesktop/.test(ua)) ? 'Windows Phone' : 'Windows'; // no i18n
+    }
+    if (/iPad/.test(ua)) {
+        return 'iPad'; // no i18n
+    }
+    if (/iPod/.test(ua)) {
+        return 'iPod Touch'; // no i18n
+    }
+    if (/iPhone/.test(ua)) {
+        return 'iPhone'; // no i18n
+    }
+    if (/(BlackBerry|PlayBook|BB10)/i.test(ua)) {
+        return 'BlackBerry'; // no i18n
+    }
+    if (/Android/.test(ua)) {
+        return 'Android'; // no i18n
+    }
+    if (/Mac/i.test(ua)) {
+        return 'Mac'; // no i18n
+    }
+    if (/Linux/.test(ua)) {
+        return 'Linux'; // no i18n
+    }
+    if (/CrOS/.test(ua)) {
+        return 'Chrome'; // no i18n
+    }
+    return ''; // no i18n
+}
+function getOS() {
+    var ua = navigator.userAgent;
+    if (/Windows/i.test(ua)) {
+        return (/Phone/.test(ua) || /WPDesktop/.test(ua)) ? 'Windows Phone' : 'Windows'; // no i18n
+    }
+    if (/(iPhone|iPad|iPod)/.test(ua)) {
+        return 'iOS'; // no i18n
+    }
+    if (/Android/.test(ua)) {
+        return 'Android'; // no i18n
+    }
+    if (/(BlackBerry|PlayBook|BB10)/i.test(ua)) {
+        return 'BlackBerry'; // no i18n
+    }
+    if (/Mac/i.test(ua)) {
+        return 'Mac OS X'; // no i18n
+    }
+    if (/Linux/.test(ua)) {
+        return 'Linux'; // no i18n
+    }
+    if (/CrOS/.test(ua)) {
+        return 'Chrome OS'; // no i18n
+    }
+    return ''; // no i18n
+}
+function getBrowser() {
+    var ua = navigator.userAgent;
+    var vendor = navigator.vendor || ''; // no i18n // vendor is undefined for at least IE9
+    var opera = window.opera;
+    if (opera || utils.includes(ua, ' OPR/')) { // no i18n
+        return (utils.includes(ua, 'Mini')) ? 'Opera Mini' : 'Opera'; // no i18n
+    }
+    if (/(BlackBerry|PlayBook|BB10)/i.test(ua)) {
+        return 'BlackBerry'; // no i18n
+    }
+    if (utils.includes(ua, 'IEMobile') || utils.includes(ua, 'WPDesktop')) { // no i18n
+        return 'Internet Explorer Mobile'; // no i18n
+    }
+    if (utils.includes(ua, 'SamsungBrowser/')) { // no i18n    
+        return 'Samsung Internet'; // no i18n
+    }
+    if (utils.includes(ua, 'Edge') || utils.includes(ua, 'Edg/')) { // no i18n
+        return 'Microsoft Edge'; // no i18n
+    }
+    if (utils.includes(ua, 'FBIOS')) { // no i18n
+        return 'Facebook Mobile'; // no i18n
+    }
+    if (utils.includes(ua, 'Chrome')) { // no i18n
+        if (typeof ulaa == 'object') {
+            return 'Ulaa'; // no i18n
+        }
+        else if (window.navigator.brave != undefined && window.navigator.brave.isBrave.name == "isBrave") { // no i18n
+            return 'Brave'; // no i18n
+        }
+        else {
+            return 'Chrome'; // no i18n
+        }
+    }
+    if (utils.includes(ua, 'CriOS')) { // no i18n
+        return 'Chrome iOS'; // no i18n
+    }
+    if (utils.includes(ua, 'UCWEB') || utils.includes(ua, 'UCBrowser')) { // no i18n
+        return 'UC Browser'; // no i18n
+    }
+    if (utils.includes(ua, 'FxiOS')) { // no i18n
+        return 'Firefox iOS'; // no i18n
+    }
+    if (utils.includes(vendor, 'Apple')) { // no i18n
+        return (utils.includes(ua, 'Mobile')) ? 'Mobile Safari' : 'Safari'; // no i18n
+    }
+    if (utils.includes(ua, 'Android')) { // no i18n
+        return 'Android Mobile'; // no i18n
+    }
+    if (utils.includes(ua, 'Konqueror')) { // no i18n
+        return 'Konqueror'; // no i18n
+    }
+    if (utils.includes(ua, 'Firefox')) { // no i18n
+        return 'Firefox'; // no i18n
+    }
+    if (utils.includes(ua, 'MSIE') || utils.includes(ua, 'Trident/')) { // no i18n
+        return 'Internet Explorer'; // no i18n
+    }
+    if (utils.includes(ua, 'Gecko')) { // no i18n
+        return 'Mozilla'; // no i18n
+    }
+    return ''; // no i18n
+}
+function getBrowserVersion() {
+    var browser = getBrowser();
+    var ua = navigator.userAgent;
+    var versionRegexs = {
+        'Internet Explorer Mobile': /rv:(\d+(\.\d+)?)/, // no i18n
+        'Microsoft Edge': /Edg\/(\d+(\.\d+)?)/, // no i18n
+        'Chrome': /Chrome\/(\d+(\.\d+)?)/, // no i18n
+        'Brave': /Chrome\/(\d+(\.\d+)?)/, // no i18n
+        'Chrome iOS': /CriOS\/(\d+(\.\d+)?)/, // no i18n
+        'UC Browser': /(UCBrowser|UCWEB)\/(\d+(\.\d+)?)/, // no i18n
+        'Safari': /Version\/(\d+(\.\d+)?)/, // no i18n
+        'Mobile Safari': /Version\/(\d+(\.\d+)?)/, // no i18n
+        'Opera': /(Opera|OPR)\/(\d+(\.\d+)?)/, // no i18n
+        'Firefox': /Firefox\/(\d+(\.\d+)?)/, // no i18n
+        'Firefox iOS': /FxiOS\/(\d+(\.\d+)?)/, // no i18n
+        'Konqueror': /Konqueror:(\d+(\.\d+)?)/, // no i18n
+        'BlackBerry': /BlackBerry (\d+(\.\d+)?)/, // no i18n
+        'Android Mobile': /android\s(\d+(\.\d+)?)/, // no i18n
+        'Internet Explorer': /(rv:|MSIE )(\d+(\.\d+)?)/, // no i18n
+        'Mozilla': /rv:(\d+(\.\d+)?)/ // no i18n
+    };
+    // Check for Ulaa browser version
+    if (browser === 'Ulaa' && typeof ulaa === 'object') { // no i18n
+        return ulaa.getVersion();
+    }
+    var regex = versionRegexs[browser];
+    if (regex === undefined) {
+        return ''; // no i18n
+    }
+    var matches = ua.match(regex);
+    if (!matches) {
+        return ''; // no i18n
+    }
+    return parseFloat(matches[matches.length - 2]);
+}
+function getReferringURL() {
+    var split = String(window.location.href || '').split(window.location.pathname); // no i18n
+    if (split.length >= 2) {
+        return split[1].length > 500 ? split[1].substring(0, 500) : split[1];
+    }
+    return ''; // no i18n
+}
+function getTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+/** True for crawlers and non-browser environments; the SDK does nothing for them. */
+function is_apptics_disabled() {
+    return typeof navigator === 'undefined' || isBlockedWS(navigator.userAgent || ''); // no i18n
+}
+/** Pure DNT check (no side effects). consent.hasDoNotTrackEnabled() applies NO_TRACKING. */
+function isDntOn() {
+    var nav = window.navigator || {};
+    var dntValues = [true, 1, '1', 'yes']; // no i18n
+    return [nav.doNotTrack, nav.msDoNotTrack, window.doNotTrack].some(function (dntValue) {
+        return utils.includes(dntValues, dntValue);
+    });
+}
+/** The console snippet's config (window.appticssettings._defaultoptions), if the page defines one. */
+function getSnippetOptions() {
+    if (typeof window === 'undefined' || !window.appticssettings) { // no i18n
+        return undefined;
+    }
+    return window.appticssettings._defaultoptions;
+}
+
+exports.getBatteryPercent = getBatteryPercent;
+exports.getBrowser = getBrowser;
+exports.getBrowserVersion = getBrowserVersion;
+exports.getConnectionType = getConnectionType;
+exports.getDevice = getDevice;
+exports.getNetworkStatus = getNetworkStatus;
+exports.getOS = getOS;
+exports.getOrientation = getOrientation;
+exports.getRam = getRam;
+exports.getReferringURL = getReferringURL;
+exports.getSnippetOptions = getSnippetOptions;
+exports.getTimeZone = getTimeZone;
+exports.isBlockedWS = isBlockedWS;
+exports.isDntOn = isDntOn;
+exports.is_apptics_disabled = is_apptics_disabled;

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

@@ -0,0 +1 @@
+export declare const FRAMEWORK_ID = 5996;

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

@@ -0,0 +1,9 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+// 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;
+
+exports.FRAMEWORK_ID = FRAMEWORK_ID;

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

@@ -0,0 +1,2 @@
+/** 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;

package/dist/cjs/core/guard.js

@@ -0,0 +1,72 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var state = require('./state.js');
+var logger = require('./logger.js');
+
+/**
+ * Calls that run immediately while storage is loading. Everything else is buffered and replayed in order.
+ * getUser / getTrackingStatus answer from defaults until then; sendFeedback waits for ready() itself.
+ * 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,
+    // a switch, and a call that hands back the id endTrackApi needs: neither can wait in a queue
+    'AppticsApiTracker.configure': true, 'AppticsApiTracker.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,
+};
+/**
+ * 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, …)
+ * 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,
+    'AppticsRemoteConfig.fetchValues': true,
+};
+/** How a call is named in a message: `AppticsEvents.addEvent` as it is, `flush` as `apptics.flush`. */
+function publicName(name) {
+    return name.indexOf('Apptics') === 0 ? name : 'apptics.' + name; // no i18n
+}
+/** Warned once per page: one line is a clue, a line per call would bury the console. */
+var warnedNotStarted = false;
+/** Public calls never throw into the host app, and are buffered until start-up finishes. */
+function guard(name, fn) {
+    const guarded = function (...args) {
+        // not started: init() wasn't called, or it refused the config. Say so whether or not
+        // console_log is on, since console_log itself is only switched on by init()
+        if (!state._ZAP._initialised && NEEDS_INIT[name] && !warnedNotStarted) {
+            warnedNotStarted = true;
+            logger.warnAlways(publicName(name) + ': the SDK has not started, so this call is ignored. Call Apptics.init() first, and check its warnings if you did.'); // no i18n
+        }
+        if (state._ZAP._initialised && !state._ZAP._ready && !RUN_BEFORE_READY[name]) {
+            state._ZAP._pending.push(function () {
+                guarded(...args);
+            });
+            return undefined;
+        }
+        try {
+            return fn(...args);
+        }
+        catch (err) {
+            // a public call swallowing its own exception into a debug-gated console line is how
+            // "the modal does not open" looks from the outside: nothing happens, nothing is said.
+            // The app is still shielded - the call returns undefined rather than throwing - but
+            // the failure is now visible without debug, and reaches the remote logger
+            logger.warnAlways(publicName(name) + ' failed:', err); // no i18n
+            logger.logFailure(name, err);
+            return undefined;
+        }
+    };
+    return guarded;
+}
+
+exports.guard = guard;

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

@@ -0,0 +1,41 @@
+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
+ * remotelog/index.ts assign these when they are evaluated; the defaults only run if that module
+ * was never imported.
+ */
+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.
+     */
+    feedbackUser: () => {
+        userid: string;
+        groupid: string;
+    } | null;
+    /**
+     * Set by heatmap/send.ts. Here so the scheduler can flush heatmap records without importing
+     * the module — an app that never imports the heatmap entry keeps the default no-op.
+     */
+    sendHeatmaps: (forget?: boolean) => Promise<void>;
+    /** Set by heatmap/track.ts, so init() and reset() can switch capture without importing it. */
+    enableHeatmap: (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. */
+    resetRemoteConfig: () => void;
+    /**
+     * Set by engagement/auto-screen.ts: the app called inScreen() itself. Here because
+     * auto-screen records through track.ts, so track.ts cannot import it back.
+     */
+    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. */
+    remoteConfigUserChanged: () => void;
+};

package/dist/cjs/core/hooks.js

@@ -0,0 +1,23 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+/**
+ * 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
+ * was never imported.
+ */
+const hooks = {
+    updateDevice: () => Promise.reject('apptics: device module not loaded'), // no i18n
+    refreshDeviceInfo: () => { },
+    remoteLog: () => { },
+    feedbackUser: () => null,
+    sendHeatmaps: () => Promise.resolve(),
+    enableHeatmap: () => { },
+    resetHeatmap: () => { },
+    resetRemoteConfig: () => { },
+    screenTrackedByApp: () => { },
+    remoteConfigStarted: () => { },
+    remoteConfigUserChanged: () => { },
+};
+
+exports.hooks = hooks;

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

@@ -0,0 +1,16 @@
+export declare const Console: {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    dir(arg: unknown): void;
+};
+/** 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.
+ */
+export declare function logFailure(module: string, ...args: unknown[]): void;

package/dist/cjs/core/logger.js

@@ -0,0 +1,86 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var state = require('./state.js');
+var hooks = require('./hooks.js');
+var utils = require('./utils.js');
+var callsite = require('./callsite.js');
+
+const APConsole = typeof console !== 'undefined' ? console : null;
+function gated(method) {
+    return function (...args) {
+        if (state._ZAP._config.debug && APConsole) {
+            try {
+                APConsole[method].apply(APConsole, args);
+            }
+            catch (err) {
+                utils.each(args, function (arg) {
+                    APConsole[method](arg);
+                });
+            }
+        }
+    };
+}
+// Console override
+const Console = {
+    log: gated('log'),
+    warn: gated('warn'),
+    error: gated('error'),
+    info: gated('info'),
+    dir(arg) {
+        if (state._ZAP._config.debug && APConsole) {
+            APConsole.dir(arg);
+        }
+    },
+};
+/** Warnings the integrator must see even with debug off (e.g. missing required config). */
+function warnAlways(...args) {
+    if (APConsole)
+        APConsole.warn(...args);
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value) || String(value);
+    }
+    catch (err) {
+        return String(value);
+    }
+}
+/**
+ * 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.
+ */
+function logFailure(module, ...args) {
+    Console.error.apply(null, args);
+    hooks.hooks.remoteLog(module, args.map(function (arg) {
+        if (arg instanceof Error) {
+            return arg.stack || (arg.name + ': ' + arg.message); // no i18n
+        }
+        return typeof arg === 'string' ? arg : safeJson(arg); // no i18n
+    }).join(' '), siteOf(args)); // no i18n
+}
+/**
+ * Where to say the failure happened. An Error knows where it was thrown, which is the place
+ * worth reporting; the alternative is where it was caught, which is usually a catch block three
+ * modules away. Only a frame we could actually read counts, so an Error with no usable stack
+ * falls through to logFailure's own caller.
+ */
+function siteOf(args) {
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        if (arg instanceof Error) {
+            var thrownAt = callsite.callSiteFromStack(arg.stack, 0);
+            if (thrownAt.linenumber > 0) {
+                return thrownAt;
+            }
+        }
+    }
+    // past siteOf and logFailure, to whoever reported the failure
+    return callsite.callSite(2);
+}
+
+exports.Console = Console;
+exports.logFailure = logFailure;
+exports.warnAlways = warnAlways;