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

package/dist/esm/core/env.js

@@ -0,0 +1,251 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { BLOCKED_WS } from './constants.js';
+import { includes } from './utils.js';
+
+function isBlockedWS(ua) {
+    var i;
+    ua = ua.toLowerCase();
+    for (i = 0; i < BLOCKED_WS.length; i++) {
+        if (ua.indexOf(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 (includes(orientation, 'portrait-primary')) { // no i18n
+        return 0;
+    }
+    if (includes(orientation, 'landscape-primary')) { // no i18n
+        return 1;
+    }
+    if (includes(orientation, 'landscape-secondary')) { // no i18n
+        return 2;
+    }
+    if (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 || includes(ua, ' OPR/')) { // no i18n
+        return (includes(ua, 'Mini')) ? 'Opera Mini' : 'Opera'; // no i18n
+    }
+    if (/(BlackBerry|PlayBook|BB10)/i.test(ua)) {
+        return 'BlackBerry'; // no i18n
+    }
+    if (includes(ua, 'IEMobile') || includes(ua, 'WPDesktop')) { // no i18n
+        return 'Internet Explorer Mobile'; // no i18n
+    }
+    if (includes(ua, 'SamsungBrowser/')) { // no i18n    
+        return 'Samsung Internet'; // no i18n
+    }
+    if (includes(ua, 'Edge') || includes(ua, 'Edg/')) { // no i18n
+        return 'Microsoft Edge'; // no i18n
+    }
+    if (includes(ua, 'FBIOS')) { // no i18n
+        return 'Facebook Mobile'; // no i18n
+    }
+    if (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 (includes(ua, 'CriOS')) { // no i18n
+        return 'Chrome iOS'; // no i18n
+    }
+    if (includes(ua, 'UCWEB') || includes(ua, 'UCBrowser')) { // no i18n
+        return 'UC Browser'; // no i18n
+    }
+    if (includes(ua, 'FxiOS')) { // no i18n
+        return 'Firefox iOS'; // no i18n
+    }
+    if (includes(vendor, 'Apple')) { // no i18n
+        return (includes(ua, 'Mobile')) ? 'Mobile Safari' : 'Safari'; // no i18n
+    }
+    if (includes(ua, 'Android')) { // no i18n
+        return 'Android Mobile'; // no i18n
+    }
+    if (includes(ua, 'Konqueror')) { // no i18n
+        return 'Konqueror'; // no i18n
+    }
+    if (includes(ua, 'Firefox')) { // no i18n
+        return 'Firefox'; // no i18n
+    }
+    if (includes(ua, 'MSIE') || includes(ua, 'Trident/')) { // no i18n
+        return 'Internet Explorer'; // no i18n
+    }
+    if (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 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;
+}
+
+export { getBatteryPercent, getBrowser, getBrowserVersion, getConnectionType, getDevice, getNetworkStatus, getOS, getOrientation, getRam, getReferringURL, getSnippetOptions, getTimeZone, isBlockedWS, isDntOn, is_apptics_disabled };

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

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

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

@@ -0,0 +1,7 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (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;
+
+export { FRAMEWORK_ID };

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

@@ -0,0 +1,70 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP } from './state.js';
+import { warnAlways, logFailure } from './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 (!_ZAP._initialised && NEEDS_INIT[name] && !warnedNotStarted) {
+            warnedNotStarted = true;
+            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 (_ZAP._initialised && !_ZAP._ready && !RUN_BEFORE_READY[name]) {
+            _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
+            warnAlways(publicName(name) + ' failed:', err); // no i18n
+            logFailure(name, err);
+            return undefined;
+        }
+    };
+    return guarded;
+}
+
+export { guard };

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

@@ -0,0 +1,21 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (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
+ * 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: () => { },
+};
+
+export { hooks };

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

@@ -0,0 +1,82 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP } from './state.js';
+import { hooks } from './hooks.js';
+import { each } from './utils.js';
+import { callSiteFromStack, callSite } from './callsite.js';
+
+const APConsole = typeof console !== 'undefined' ? console : null;
+function gated(method) {
+    return function (...args) {
+        if (_ZAP._config.debug && APConsole) {
+            try {
+                APConsole[method].apply(APConsole, args);
+            }
+            catch (err) {
+                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 (_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.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 = callSiteFromStack(arg.stack, 0);
+            if (thrownAt.linenumber > 0) {
+                return thrownAt;
+            }
+        }
+    }
+    // past siteOf and logFailure, to whoever reported the failure
+    return callSite(2);
+}
+
+export { Console, logFailure, warnAlways };

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

@@ -0,0 +1,69 @@
+import { type ApConfig } from './constants.js';
+import type { DeviceInfo, Dict, TrackingStatus, UserInfo } from '../types.js';
+/** Runtime state shared by every module (the former `_ZAP` object). */
+export interface State {
+    _initialised: boolean;
+    /** Start-up finished (storage loaded, session open, timers running). */
+    _ready: boolean;
+    /** Public calls made after init() and before _ready, replayed in order. */
+    _pending: Array<() => void>;
+    _readyPromise: Promise<boolean> | null;
+    _regDeviceSending: boolean;
+    _regDeviceResolve: Array<(value: any) => void>;
+    _regDeviceReject: Array<(reason: any) => void>;
+    _sending: boolean;
+    _deferSendTimer: ReturnType<typeof setTimeout> | null;
+    _config: ApConfig;
+    _defaultoptions: Dict;
+    inactiveduration: number;
+    _token: string;
+    _frameworkID: number;
+    _platform: string;
+    _isanonrequired: boolean;
+    _devicestatus: TrackingStatus;
+    _uuid: string;
+    _apid: string;
+    _mapid: string;
+    _device_info: DeviceInfo;
+    _user_info: UserInfo;
+    _current_screen: Dict;
+    _current_session: Dict;
+    _properties: Dict;
+    _ignoreDnt: boolean;
+    _isGlobalErrorTracking: boolean;
+    _shouldTrack: boolean;
+    _engagementTracking: boolean;
+    _errorTracking: boolean;
+    /** getsdkconfig module 18. Heatmap has its own flag in v2; before that it rode engagement. */
+    _heatmapTracking: boolean;
+    /** getsdkconfig module 17. */
+    _remoteLoggerEnabled: boolean;
+    /** getsdkconfig's module flag for remote config, which is the authority on whether it runs. */
+    _remoteConfigEnabled: boolean;
+    /** What the last getupdates answer said, used only to stop asking about a module it reported off. */
+    _remoteConfigReported: boolean;
+    /** getsdkconfig module 12. */
+    _feedbackEnabled: boolean;
+    _quartzEnabled: boolean;
+    /** Epoch ms getsdkconfig asked us to wait until before asking again. 0 means no answer yet. */
+    _nextConfigCheck: number;
+    /**
+     * When debug mode switches itself off, as a timestamp; 0 while it is not running.
+     * Every tracked item pushes it back, so it only arrives after a genuinely idle hour.
+     */
+    _debugUntil: number;
+    _trackinfo: Dict;
+}
+export declare const _ZAP: State;
+/** Restores every field to its default. The object identity is kept, since modules hold a reference to it. */
+export declare function resetState(): void;
+export declare function getConfig<K extends keyof ApConfig>(key: K): ApConfig[K];
+/** The oldest timestamp still worth keeping: now minus batch_request_timeout days. */
+export declare function oldestKeptTime(): number;
+/**
+ * True for an item too old (or dated far enough in the future to be nonsense) to be worth
+ * sending. Queues use it to drop such items on the way in, and the sender uses it to drop the
+ * ones already stored. A minute of slack absorbs clock differences between tabs and machines,
+ * so an item a few milliseconds ahead of this clock is still kept.
+ */
+export declare function isExpired(time: unknown): boolean;

package/dist/esm/core/state.js

@@ -0,0 +1,73 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { AP_TRACKING_STATUS, AP_CONSTANTS, DEFAULT_INACTIVE_MINUTES, AP_CONFIG } from './constants.js';
+import { nowMs } from './utils.js';
+import { FRAMEWORK_ID } from './framework-id.js';
+
+function initialState() {
+    return {
+        _initialised: false,
+        _ready: false,
+        _pending: [],
+        _readyPromise: null,
+        _regDeviceSending: false,
+        _regDeviceResolve: [],
+        _regDeviceReject: [],
+        _sending: false,
+        _deferSendTimer: null,
+        _config: { ...AP_CONFIG },
+        _defaultoptions: {},
+        inactiveduration: DEFAULT_INACTIVE_MINUTES,
+        _token: '', // no i18n
+        // issued by Apptics at pack time; see scripts/register-version.mjs
+        _frameworkID: FRAMEWORK_ID,
+        _platform: AP_CONSTANTS.BROWSER,
+        _isanonrequired: true,
+        _devicestatus: AP_TRACKING_STATUS.USAGE_TRACKING_WITHOUT_PII,
+        _uuid: '', // no i18n
+        _apid: '', // no i18n
+        _mapid: '', // no i18n
+        _device_info: {},
+        _user_info: {},
+        _current_screen: {},
+        _current_session: {},
+        _properties: {},
+        _ignoreDnt: false,
+        _isGlobalErrorTracking: true,
+        _shouldTrack: true,
+        _engagementTracking: true,
+        _heatmapTracking: true,
+        _remoteLoggerEnabled: true,
+        _remoteConfigEnabled: true,
+        _remoteConfigReported: true,
+        _feedbackEnabled: true,
+        _nextConfigCheck: 0,
+        _debugUntil: 0,
+        _errorTracking: true,
+        _quartzEnabled: true,
+        _trackinfo: {},
+    };
+}
+const _ZAP = initialState();
+function getConfig(key) {
+    return _ZAP._config[key];
+}
+/** The oldest timestamp still worth keeping: now minus batch_request_timeout days. */
+function oldestKeptTime() {
+    return nowMs() - getConfig('batch_request_timeout') * 24 * 60 * 60 * 1000; // no i18n
+}
+/** How far ahead of this clock a timestamp may be before it counts as nonsense. */
+const CLOCK_SKEW_MS = 60 * 1000;
+/**
+ * True for an item too old (or dated far enough in the future to be nonsense) to be worth
+ * sending. Queues use it to drop such items on the way in, and the sender uses it to drop the
+ * ones already stored. A minute of slack absorbs clock differences between tabs and machines,
+ * so an item a few milliseconds ahead of this clock is still kept.
+ */
+function isExpired(time) {
+    if (typeof time !== 'number' || !isFinite(time)) {
+        return false; // no usable timestamp: leave it to the caller's own rules
+    }
+    return time < oldestKeptTime() || time > nowMs() + CLOCK_SKEW_MS;
+}
+
+export { _ZAP, getConfig, isExpired, oldestKeptTime };