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

package/dist/cjs/user/index.js

@@ -0,0 +1,183 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var constants = require('../core/constants.js');
+var state = require('../core/state.js');
+var logger = require('../core/logger.js');
+var utils = require('../core/utils.js');
+var storage = require('../core/storage.js');
+var consent = require('../core/consent.js');
+var transport = require('../core/transport.js');
+var validate = require('../core/validate.js');
+var hooks = require('../core/hooks.js');
+
+function getUser() {
+    return state._ZAP._user_info || {}; // no i18n
+}
+/**
+ * user/register wants properties as the validated triple — the values, their types, and what
+ * was rejected — which is what UserBuilder.build() returns. A plain object passed to setUser
+ * is validated here, so both forms go up in the same shape.
+ */
+function asUserProperties(jsonObj) {
+    var maybeBuilt = jsonObj;
+    var built = maybeBuilt && typeof maybeBuilt === 'object' && maybeBuilt.data && maybeBuilt.datatype // no i18n
+        ? maybeBuilt
+        : validate.userValidateJSON(jsonObj);
+    built.message.forEach(function (problem) {
+        logger.logFailure(constants.AP_LOG_MODULE.PROPERTIES, 'AppticsUser.setUser: dropped ' + problem.keys.join(', ') + ' (error ' + problem.code + ')'); // no i18n
+    });
+    return built;
+}
+function setUser(userid, groupid, jsonObj) {
+    let _jsonObj = jsonObj || {};
+    userid = userid || ''; // no i18n
+    groupid = groupid || ''; // no i18n
+    if (!consent.canTrack('setUser')) { // no i18n
+        return;
+    }
+    if (utils.isEmpty(userid)) {
+        logger.logFailure(constants.AP_LOG_MODULE.PROPERTIES, 'AppticsUser.setUser: Invalid userid'); // no i18n
+        return;
+    }
+    var user_info = {
+        mam: userid,
+        customergroupid: groupid,
+        appversionid: state._ZAP._device_info.appversionid || '', // no i18n
+        status: 1,
+        happendat: utils.nowMs()
+    };
+    if (!utils.isEmptyObj(_jsonObj)) { // no i18n
+        user_info.userproperties = asUserProperties(_jsonObj);
+    }
+    registerUserWithApptics(user_info).then(function (user_info) {
+        logger.Console.log('setUser: ' + JSON.stringify(user_info)); // no i18n
+    }).catch(function (err) {
+        logger.Console.log(err);
+    });
+}
+function addOrUpdateUser(user_info) {
+    user_info.status = 1;
+    var users = storage.user_defaults.item('users') || []; // no i18n
+    users = users.map((item) => ({ ...item, status: 0 }));
+    var index = users.findIndex((userobj) => userobj.userid === user_info.userid);
+    if (index !== -1) {
+        users[index] = { ...users[index], ...user_info };
+    }
+    else {
+        users.push(user_info);
+    }
+    storage.user_defaults.add('users', users); // no i18n
+    // the user setUser registered, on its own as well: what this browser is tracking as now
+    storage.user_defaults.add('user_info', users[index !== -1 ? index : users.length - 1]); // no i18n
+}
+function getUserInfo() {
+    var stored = storage.user_defaults.item('user_info'); // no i18n
+    if (stored && typeof stored === 'object' && !utils.isEmpty(stored.userid)) { // no i18n
+        state._ZAP._user_info = stored;
+        return;
+    }
+    // registered before user_info was kept: the active one of the users list
+    var users = storage.user_defaults.item('users') || []; // no i18n
+    var activeuser = {};
+    if (users.length > 0) {
+        activeuser = users.filter((item) => item.status === 1)[0] || {};
+    }
+    state._ZAP._user_info = activeuser;
+}
+// Function to register the user
+function registerUserWithApptics(user_info) {
+    var label = 'registerUserWithApptics'; // no i18n
+    var blocked = transport.rejectIfDisabled(label) || transport.rejectIfOffline(label);
+    if (blocked) {
+        return blocked;
+    }
+    if (utils.isEmptyObj(user_info)) {
+        return Promise.reject(label + ': nothing to register'); // no i18n
+    }
+    var missing = transport.rejectIfNoDeviceIds(label);
+    if (missing) {
+        return missing;
+    }
+    var payload = JSON.stringify(utils.cloneMapExcludingKeys(user_info, ['userid', 'groupid', 'happendat'])); // no i18n
+    return transport.postToApptics('reguser', payload, transport.apiHeaders(), label).then(function (result) {
+        var data = result.data || {};
+        user_info.userid = data.userid;
+        user_info.groupid = data.customergroupid;
+        consent.setTrackingStatus(constants.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.hooks.remoteConfigUserChanged();
+        return data;
+    });
+}
+/** Builds validated user properties for setUser. */
+class UserBuilder {
+    setFirstName(first_name) { this.first_name = first_name; return this; }
+    setLastName(last_name) { this.last_name = last_name; return this; }
+    setCompanyName(company_name) { this.company_name = company_name; return this; }
+    setEmailAddress(email_address) { this.email_address = email_address; return this; }
+    setContactNumber(contact_number) { this.contact_number = contact_number; return this; }
+    setCountry(country) { this.country = country; return this; }
+    setRegion(region) { this.region = region; return this; }
+    setCity(city) { this.city = city; return this; }
+    setGeoLocation(geo_location) { this.geo_location = geo_location; return this; }
+    setGender(gender) { this.gender = gender; return this; }
+    setPlanType(plan_type) { this.plan_type = plan_type; return this; }
+    setTimezone(timezone) { this.timezone = timezone; return this; }
+    setLanguage(language) { this.language = language; return this; }
+    setEngagementScore(engagement_score) { this.engagement_score = engagement_score; return this; }
+    setDateOfBirth(date_of_birth) { this.date_of_birth = date_of_birth; return this; }
+    addStringProperty(key, value) {
+        if (typeof value === 'string') { // no i18n
+            this[key] = value;
+        }
+        return this;
+    }
+    addBooleanProperty(key, value) {
+        if (typeof value === 'boolean') { // no i18n
+            this[key] = value;
+        }
+        return this;
+    }
+    addNumberProperty(key, value) {
+        if (typeof value === 'number' && Number.isFinite(value)) { // no i18n
+            this[key] = value;
+        }
+        return this;
+    }
+    setCustomProperties(obj) {
+        if (typeof obj === 'object' && obj !== null) { // no i18n
+            for (const [key, value] of Object.entries(obj)) {
+                this[key] = value;
+            }
+        }
+        return this;
+    }
+    build() {
+        const user = {};
+        const knownFields = [
+            'first_name', 'last_name', 'company_name', 'email_address', 'contact_number',
+            'country', 'region', 'city', 'geo_location', 'gender', 'plan_type', 'timezone',
+            'language', 'engagement_score', 'date_of_birth'
+        ]; // no i18n
+        knownFields.forEach((field) => {
+            if (this[field] !== undefined)
+                user[field] = this[field];
+        });
+        Object.entries(this).forEach(([key, value]) => {
+            if (knownFields.indexOf(key) === -1 && typeof value !== 'function') { // no i18n
+                user[key] = value;
+            }
+        });
+        return validate.userValidateJSON(user);
+    }
+}
+
+exports.UserBuilder = UserBuilder;
+exports.addOrUpdateUser = addOrUpdateUser;
+exports.getUser = getUser;
+exports.getUserInfo = getUserInfo;
+exports.registerUserWithApptics = registerUserWithApptics;
+exports.setUser = setUser;

package/dist/esm/auto-init.d.ts

@@ -0,0 +1,8 @@
+import type { AppticsSdk } from './types.js';
+/** Calls Apptics.init() when the page has the console snippet (window.appticssettings) and it hasn't run. */
+export declare function autoInit(api: AppticsSdk['Apptics']): boolean;
+/**
+ * Queues autoInit so an app that sets window.appticssettings and calls init() in its
+ * top-level code runs first (autoInit then sees init() already ran).
+ */
+export declare function scheduleAutoInit(api: AppticsSdk['Apptics']): void;

package/dist/esm/auto-init.js

@@ -0,0 +1,29 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP } from './core/state.js';
+import { getSnippetOptions } from './core/env.js';
+
+/** Calls Apptics.init() when the page has the console snippet (window.appticssettings) and it hasn't run. */
+function autoInit(api) {
+    if (_ZAP._initialised) {
+        return false;
+    }
+    var opts = getSnippetOptions();
+    if (!opts || typeof opts !== 'object') { // no i18n
+        return false;
+    }
+    return api.init(opts);
+}
+/**
+ * Queues autoInit so an app that sets window.appticssettings and calls init() in its
+ * top-level code runs first (autoInit then sees init() already ran).
+ */
+function scheduleAutoInit(api) {
+    if (typeof window === 'undefined') { // no i18n
+        return;
+    }
+    queueMicrotask(function () {
+        autoInit(api);
+    });
+}
+
+export { autoInit, scheduleAutoInit };

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

@@ -0,0 +1,28 @@
+import type { Dict } from '../types.js';
+/** The largest value `attempt` may carry, from its own regex. */
+export declare const MAX_ATTEMPTS = 5;
+/**
+ * Whether this path has already used its five attempts, so the batch should be dropped rather
+ * than sent a sixth time with a param the proxy will refuse.
+ */
+export declare function attemptsExhausted(path: string): boolean;
+/**
+ * Records that a send is going out, and returns the params to put on it.
+ *
+ * Call it once per request, immediately before sending: it is what moves the attempt counter on,
+ * so calling it twice for one request would skip a number and reach five early.
+ */
+export declare function beginAttempt(path: string): Dict;
+/**
+ * Records that a send was accepted: the counter goes back to 1 and `lst` moves to now.
+ *
+ * For a page-close send the confirmation arrives after the caller has moved on, which is fine —
+ * nothing waits for this, it only decides what the *next* send says about itself.
+ */
+export declare function attemptSucceeded(path: string): void;
+/** Gives up on the current run of attempts, so the next send starts again at 1. */
+export declare function resetAttempts(path: string): void;
+/** When this path last had a send accepted, or 0. */
+export declare function lastSendTime(path: string): number;
+/** Forgets every path's bookkeeping. reset() calls it. */
+export declare function clearAttempts(): void;

package/dist/esm/core/attempts.js

@@ -0,0 +1,106 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { RETRY_CAPABLE_PATHS } from './constants.js';
+import { user_defaults } from './storage.js';
+import { nowMs } from './utils.js';
+
+/**
+ * Retry bookkeeping: `attempt`, `firstattempttime` and `lst`.
+ *
+ * Every url that carries data declares all three; app/addversion and getsdkconfig declare none,
+ * because they are start-up calls whose answers the SDK needs rather than payloads it is pushing.
+ *
+ * What they are for is the case this SDK cannot see on its own. A send goes out, the server
+ * stores it, and the answer is lost on the way back — a closed tab, a dropped connection, a
+ * proxy that times out. The SDK has no way to tell that from a send that never arrived, so it
+ * sends again. `attempt` and `firstattempttime` are what let the server recognise the second
+ * copy as the same payload rather than storing it twice. Without them, every retry is a
+ * duplicate session.
+ *
+ * `attempt` is declared `regex="[1-5]"`, so five is not a policy choice here — it is the largest
+ * number the proxy will accept. A batch that has not landed in five passes is dropped, because
+ * the sixth would be refused for the param rather than for the payload, which would look like a
+ * different fault entirely.
+ *
+ * State is per path and survives a reload, which is the point: the tab that was closed mid-send
+ * is exactly the one that needs to say "attempt 2" when it comes back.
+ */
+/** The largest value `attempt` may carry, from its own regex. */
+const MAX_ATTEMPTS = 5;
+const STORE_KEY = 'sendstate'; // no i18n
+function allState() {
+    var saved = user_defaults.item(STORE_KEY);
+    return saved && typeof saved === 'object' ? saved : {};
+}
+function stateOf(path) {
+    var state = allState()[path];
+    return state && typeof state === 'object'
+        ? { attempt: Number(state.attempt) || 1, firstattempttime: Number(state.firstattempttime) || 0, lst: Number(state.lst) || 0 }
+        : { attempt: 1, firstattempttime: 0, lst: 0 };
+}
+function save(path, state) {
+    var all = allState();
+    all[path] = state;
+    user_defaults.add(STORE_KEY, all);
+}
+/**
+ * Whether this path has already used its five attempts, so the batch should be dropped rather
+ * than sent a sixth time with a param the proxy will refuse.
+ */
+function attemptsExhausted(path) {
+    return stateOf(path).attempt > MAX_ATTEMPTS;
+}
+/**
+ * Records that a send is going out, and returns the params to put on it.
+ *
+ * Call it once per request, immediately before sending: it is what moves the attempt counter on,
+ * so calling it twice for one request would skip a number and reach five early.
+ */
+function beginAttempt(path) {
+    if (!RETRY_CAPABLE_PATHS[path]) {
+        return {};
+    }
+    var state = stateOf(path);
+    var at = nowMs();
+    if (state.attempt <= 1 || state.firstattempttime === 0) {
+        state.attempt = 1;
+        state.firstattempttime = at;
+    }
+    var params = {
+        attempt: String(Math.min(state.attempt, MAX_ATTEMPTS)),
+        firstattempttime: state.firstattempttime,
+    };
+    // lst is the last send this path had accepted. There is none before the first one lands, and
+    // an optional param is better absent than present and meaningless
+    if (state.lst > 0) {
+        params.lst = state.lst; // no i18n
+    }
+    // the next send for this path is the next attempt, unless this one is confirmed first
+    save(path, { attempt: state.attempt + 1, firstattempttime: state.firstattempttime, lst: state.lst });
+    return params;
+}
+/**
+ * Records that a send was accepted: the counter goes back to 1 and `lst` moves to now.
+ *
+ * For a page-close send the confirmation arrives after the caller has moved on, which is fine —
+ * nothing waits for this, it only decides what the *next* send says about itself.
+ */
+function attemptSucceeded(path) {
+    if (!RETRY_CAPABLE_PATHS[path]) {
+        return;
+    }
+    save(path, { attempt: 1, firstattempttime: 0, lst: nowMs() });
+}
+/** Gives up on the current run of attempts, so the next send starts again at 1. */
+function resetAttempts(path) {
+    if (!RETRY_CAPABLE_PATHS[path]) {
+        return;
+    }
+    var state = stateOf(path);
+    save(path, { attempt: 1, firstattempttime: 0, lst: state.lst });
+}
+/** Forgets every path's bookkeeping. reset() calls it. */
+function clearAttempts() {
+    user_defaults.add(STORE_KEY, undefined);
+}
+
+export { MAX_ATTEMPTS, attemptSucceeded, attemptsExhausted, beginAttempt, clearAttempts, resetAttempts };

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

@@ -0,0 +1,32 @@
+import { type Queue } from './storage.js';
+import { type ApiPath } from './transport.js';
+import type { Dict, QueueItem, ServerResult } from '../types.js';
+/** Retries `send` in 500 ms, replacing any retry already scheduled. */
+export declare function defer(send: () => Promise<void>): void;
+export declare function clearDefer(): void;
+/** Only one tab sends a queue at a time. Without the Web Locks API, runs directly (1.x behaviour). */
+export declare function withSendLock(name: string, run: () => Promise<void>): Promise<void>;
+/**
+ * The batch to send: closed items within batch_request_timeout days.
+ * Expired items are removed from the queue without being sent.
+ */
+export declare function freshItems(queue: Queue, isClosed: (item: QueueItem) => boolean, timeOf: (item: QueueItem) => number): Promise<QueueItem[]>;
+/**
+ * Sends one batch of queued items. Resolves only when the server has accepted it, so the caller
+ * removes the items then and not before: a batch that fails stays queued and goes again on the
+ * next pass, as attempt 2, which `attempt` and `firstattempttime` let the server recognise as a
+ * copy rather than store twice.
+ *
+ * With `forget` (the page is closing) it goes by keepalive, and the promise settles if the answer
+ * arrives before the page is gone. See postKeepalive.
+ *
+ * Five attempts is the cap, because `attempt` is declared regex="[1-5]" and a sixth would be
+ * refused for the param rather than for the payload.
+ */
+export declare function sendBatch(path: ApiPath, label: string, _payload: Dict, forget?: boolean): Promise<ServerResult>;
+/**
+ * Hands a send's outcome back to a sender. Normally the sender waits for it. While the page
+ * closes it does not: the request is already out, and waiting would hold the next queue's send
+ * until after the page has gone. The outcome is still handled whenever it arrives.
+ */
+export declare function awaitUnlessClosing(landed: Promise<unknown>, forget: boolean | undefined, label: string): Promise<void> | undefined;

package/dist/esm/core/batch.js

@@ -0,0 +1,109 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { _ZAP, isExpired } from './state.js';
+import { Console, warnAlways } from './logger.js';
+import { isEmptyObj, sizeof } from './utils.js';
+import './constants.js';
+import './db.js';
+import { shouldTrackOrSendData } from './consent.js';
+import { attemptsExhausted, MAX_ATTEMPTS, resetAttempts } from './attempts.js';
+import { rejectIfDisabled, rejectIfNoDeviceIds, getMetaObj, postKeepalive, apiHeaders, postToApptics } from './transport.js';
+
+/** Retries `send` in 500 ms, replacing any retry already scheduled. */
+function defer(send) {
+    if (_ZAP._deferSendTimer) {
+        clearTimeout(_ZAP._deferSendTimer);
+    }
+    _ZAP._deferSendTimer = setTimeout(send, 500);
+}
+function clearDefer() {
+    if (_ZAP._deferSendTimer) {
+        clearTimeout(_ZAP._deferSendTimer);
+        _ZAP._deferSendTimer = null;
+    }
+}
+/** Only one tab sends a queue at a time. Without the Web Locks API, runs directly (1.x behaviour). */
+function withSendLock(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-send-' + name, { ifAvailable: true }, function (lock) {
+        return lock ? run() : undefined;
+    }).then(function () { return undefined; });
+}
+/**
+ * The batch to send: closed items within batch_request_timeout days.
+ * Expired items are removed from the queue without being sent.
+ */
+function freshItems(queue, isClosed, timeOf) {
+    return queue.payload().then(function (items) {
+        var fresh = [];
+        var expired = [];
+        items.forEach(function (item) {
+            if (!isClosed(item)) {
+                return;
+            }
+            (isExpired(timeOf(item)) ? expired : fresh).push(item);
+        });
+        return expired.length ? queue.remove(expired).then(function () { return fresh; }) : fresh;
+    });
+}
+/**
+ * Sends one batch of queued items. Resolves only when the server has accepted it, so the caller
+ * removes the items then and not before: a batch that fails stays queued and goes again on the
+ * next pass, as attempt 2, which `attempt` and `firstattempttime` let the server recognise as a
+ * copy rather than store twice.
+ *
+ * With `forget` (the page is closing) it goes by keepalive, and the promise settles if the answer
+ * arrives before the page is gone. See postKeepalive.
+ *
+ * Five attempts is the cap, because `attempt` is declared regex="[1-5]" and a sixth would be
+ * refused for the param rather than for the payload.
+ */
+function sendBatch(path, label, _payload, forget) {
+    var blocked = rejectIfDisabled(label);
+    if (blocked) {
+        return blocked;
+    }
+    if (!shouldTrackOrSendData()) {
+        return Promise.reject(label + ': tracking is off'); // no i18n
+    }
+    if (isEmptyObj(_payload)) {
+        return Promise.reject(label + ': nothing to send'); // no i18n
+    }
+    var missing = rejectIfNoDeviceIds(label);
+    if (missing) {
+        return missing;
+    }
+    if (!_payload.hasOwnProperty('meta')) { // no i18n
+        _payload.meta = getMetaObj();
+    }
+    if (attemptsExhausted(path)) {
+        // five passes without a confirmed landing. Keeping it would block every later batch
+        // behind a payload the proxy will now refuse for its attempt number alone
+        warnAlways('apptics: dropping a ' + label + ' batch after ' + MAX_ATTEMPTS + ' attempts'); // no i18n
+        resetAttempts(path);
+        return Promise.resolve({ result: 'success' }); // no i18n
+    }
+    Console.log(label + ': Payload size : ' + (sizeof(_payload) / 1024)); // no i18n
+    var body = JSON.stringify(_payload);
+    return forget
+        ? postKeepalive(path, body, apiHeaders(), label)
+        : postToApptics(path, body, apiHeaders(), label);
+}
+/**
+ * Hands a send's outcome back to a sender. Normally the sender waits for it. While the page
+ * closes it does not: the request is already out, and waiting would hold the next queue's send
+ * until after the page has gone. The outcome is still handled whenever it arrives.
+ */
+function awaitUnlessClosing(landed, forget, label) {
+    if (!forget) {
+        return landed.then(function () { return undefined; });
+    }
+    landed.catch(function (err) {
+        Console.log(label + ': not confirmed before the page closed, kept for the next send: ' + String(err)); // no i18n
+    });
+    return undefined;
+}
+
+export { awaitUnlessClosing, clearDefer, defer, freshItems, sendBatch, withSendLock };

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

@@ -0,0 +1,34 @@
+/**
+ * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ *
+ * 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.
+ */
+export interface CallSite {
+    /** The script's basename, not its url: logSDK caps filename at 100 characters. */
+    filename: string;
+    /** 0 when the stack gave us nothing — see entryFor() for why it is still sent. */
+    linenumber: number;
+    /** The calling function's name, when the frame has one. Anonymous callers have none. */
+    fn?: string;
+}
+export declare const NO_CALL_SITE: CallSite;
+/**
+ * A call typed in the browser's developer console: there is no file, line or function to report,
+ * only the console's own placeholder for its input, so the line says plainly that it came from
+ * nowhere in the app. file_name and the function field both accept `-`.
+ */
+export declare const CONSOLE_CALL_SITE: CallSite;
+/**
+ * The frame `skip` frames down a stack, counting only the ones that name a file — V8 heads its
+ * stacks with an `Error` line and Firefox does not, so counting raw lines would read a different
+ * frame in each browser.
+ */
+export declare function callSiteFromStack(stack: string | undefined, skip: number): CallSite;
+/**
+ * Where the caller `skip` levels above this call sits. `skip` is 0 for this function's own
+ * caller; each wrapper between that caller and the place worth reporting adds one.
+ */
+export declare function callSite(skip: number): CallSite;

package/dist/esm/core/callsite.js

@@ -0,0 +1,110 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+/**
+ * Where a log line was raised, for logSDK's `filename` and `linenumber`.
+ *
+ * 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.
+ */
+const NO_CALL_SITE = { filename: '', linenumber: 0, fn: '' };
+/**
+ * A call typed in the browser's developer console: there is no file, line or function to report,
+ * only the console's own placeholder for its input, so the line says plainly that it came from
+ * nowhere in the app. file_name and the function field both accept `-`.
+ */
+const CONSOLE_CALL_SITE = { filename: '-', linenumber: 0, fn: '-' };
+/**
+ * The frame of code run from the developer console, in each browser:
+ *   V8 (Chrome, Edge):  `    at <anonymous>:1:15`        (the file is <anonymous>)
+ *   Firefox:            `@debugger eval code:1:15`
+ *   Safari:             `global code` or `eval code`, with no location at all
+ * V8 names a string run through eval or new Function <anonymous> too; it is no file either.
+ */
+const CONSOLE_FILE_V8 = '<anonymous>'; // no i18n
+const CONSOLE_FIREFOX = /debugger eval code/; // no i18n
+const CONSOLE_SAFARI = /^(global|eval) code(@|$)/; // no i18n
+/** logSDK declares max-len="100" on filename. */
+const FILENAME_MAX = 100;
+/**
+ * The file and line out of one stack frame, in either shape a browser produces:
+ *   V8:              `    at doThing (https://host/app.js:12:34)`
+ *   Firefox/Safari:  `doThing@https://host/app.js:12:34`
+ * Both end in `:line:column`, which is the only part that is the same everywhere, so the match is
+ * anchored there and the column is read only so that it can be thrown away — without it the
+ * pattern would take the column for the line.
+ */
+const FRAME = /([^\s(@]+):(\d+):(\d+)\)?$/;
+/** `https://host/path/app.js?v=2` -> `app.js`. The url would not fit in 100 characters. */
+function basename(url) {
+    var path = url.split(/[?#]/)[0] || url;
+    var parts = path.split('/');
+    return (parts[parts.length - 1] || path).slice(0, FILENAME_MAX);
+}
+/**
+ * The function a frame names, in either shape:
+ *   V8:              `at doThing (` — or `at async doThing (`
+ *   Firefox/Safari:  `doThing@`
+ * A frame without one (`at https://…` or `@https://…`) is an anonymous caller, and gets ''.
+ */
+const FRAME_FN_V8 = /^at\s+(?:async\s+)?(.+?)\s+\(/;
+const FRAME_FN_OTHER = /^([^@\s]+)@/;
+function frameFunction(frame) {
+    var match = FRAME_FN_V8.exec(frame) || FRAME_FN_OTHER.exec(frame);
+    return match ? (match[1] || '') : ''; // no i18n
+}
+function parseFrame(line) {
+    var trimmed = line.trim();
+    var match = FRAME.exec(trimmed);
+    if (match === null) {
+        return null;
+    }
+    var line_no = Number(match[2]);
+    if (!isFinite(line_no)) {
+        return null;
+    }
+    return { filename: basename(match[1] || ''), linenumber: line_no, fn: frameFunction(trimmed) };
+}
+/**
+ * The frame `skip` frames down a stack, counting only the ones that name a file — V8 heads its
+ * stacks with an `Error` line and Firefox does not, so counting raw lines would read a different
+ * frame in each browser.
+ */
+function callSiteFromStack(stack, skip) {
+    if (!stack) {
+        return NO_CALL_SITE;
+    }
+    var lines = stack.split('\n');
+    var seen = 0;
+    for (var i = 0; i < lines.length; i++) {
+        var raw = (lines[i] || '').trim(); // no i18n
+        var frame = parseFrame(raw);
+        if (frame === null) {
+            // Safari's console frame has no location, so it is never a frame parseFrame reads
+            if (seen === skip && CONSOLE_SAFARI.test(raw)) {
+                return CONSOLE_CALL_SITE;
+            }
+            continue;
+        }
+        if (seen++ < skip) {
+            continue;
+        }
+        return frame.filename === CONSOLE_FILE_V8 || CONSOLE_FIREFOX.test(raw) ? CONSOLE_CALL_SITE : frame;
+    }
+    return NO_CALL_SITE;
+}
+/**
+ * Where the caller `skip` levels above this call sits. `skip` is 0 for this function's own
+ * caller; each wrapper between that caller and the place worth reporting adds one.
+ */
+function callSite(skip) {
+    try {
+        // +1 for this function's own frame, which is never the answer
+        return callSiteFromStack(new Error().stack, skip + 1);
+    }
+    catch (err) {
+        return NO_CALL_SITE;
+    }
+}
+
+export { CONSOLE_CALL_SITE, NO_CALL_SITE, callSite, callSiteFromStack };

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

@@ -0,0 +1,27 @@
+import type { TrackingStatus } from '../types.js';
+/**
+ * DNT counts only when not ignored; while it counts, tracking is NO_TRACKING (opt_in_status).
+ * Decided on every visit and never stored: storing it made one visit with DNT on look like the
+ * visitor's own choice, so tracking stayed off after DNT was turned off or ignore_do_not_track set.
+ */
+export declare function hasDoNotTrackEnabled(): boolean;
+export declare function opt_in_status(): TrackingStatus;
+export declare function shouldTrackOrSendData(): boolean;
+/**
+ * The guard every tracking call starts with: init() has run, the client isn't a crawler,
+ * and consent / server flags allow tracking.
+ */
+export declare function canTrack(caller: string): boolean;
+/** canTrack plus the server's `engagementtracking` flag from getupdates (events, screens, sessions, api calls). */
+export declare function canTrackEngagement(caller: string): boolean;
+/**
+ * canTrack plus the server's heatmap flag (getsdkconfig module 18).
+ *
+ * Heatmap rode the engagement flag until v2 gave it one of its own, which matters: an app may
+ * well want events while declining to have every click's coordinates recorded.
+ */
+export declare function canTrackHeatmap(caller: string): boolean;
+/** canTrack plus the server's `errortracking` flag from getupdates. */
+export declare function canTrackErrors(caller: string): boolean;
+export declare function setTrackingStatus(trackingState: TrackingStatus): void;
+export declare function getTrackingStatus(): TrackingStatus;