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

package/dist/cjs/engagement/track.js

@@ -0,0 +1,350 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (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 session = require('./session.js');
+var env = require('../core/env.js');
+var consent = require('../core/consent.js');
+var validate = require('../core/validate.js');
+var debug = require('../core/debug.js');
+var hooks = require('../core/hooks.js');
+var apiRules = require('./api-rules.js');
+var definedEvents = require('./defined-events.js');
+var autoScreen = require('./auto-screen.js');
+
+/**
+ * Records an event: `trackEvent(name, group?, properties?)`, or a defined event with
+ * `trackEvent(DefinedEvents.AP_USER_LOGIN, properties?)`, which brings its own group.
+ *
+ * As on Android, an invalid name or group is not logged. A group left out is `default`, so the
+ * one-argument form keeps working; a group given but invalid is a mistake worth being told about,
+ * not one to file quietly under `default`.
+ */
+function trackEvent(eventName, groupName, jsonObj) {
+    if (!consent.canTrackEngagement('trackEvent')) { // no i18n
+        return;
+    }
+    var defined = definedEvents.asDefinedEvent(eventName);
+    if (defined) {
+        // the defined event's own name and group, which alone may carry the reserved AP_ prefix
+        jsonObj = (groupName && typeof groupName === 'object' ? groupName : jsonObj); // no i18n
+        groupName = defined.group;
+        eventName = defined.event;
+    }
+    else {
+        if (typeof eventName !== 'string' || !validate.validateEventOrGroup(eventName)) { // no i18n
+            logger.logFailure(constants.AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid eventName: ' + String(eventName)); // no i18n
+            return;
+        }
+        if (groupName === undefined || groupName === null || groupName === '') { // no i18n
+            groupName = constants.AP_CONFIG.default_group_name;
+        }
+        else if (typeof groupName !== 'string' || !validate.validateEventOrGroup(groupName)) { // no i18n
+            logger.logFailure(constants.AP_LOG_MODULE.EVENT, 'AppticsEvents.addEvent: Invalid groupName for "' + eventName + '": ' + String(groupName)); // no i18n
+            return;
+        }
+    }
+    jsonObj = jsonObj || {};
+    var _jsonObj = validate.validateJSON(jsonObj);
+    // epoch time in seconds
+    var time = utils.nowMs();
+    var eventData = {
+        id: utils.getNewUUID(),
+        type: constants.AP_CONSTANTS.EVENT,
+        group: groupName,
+        event: eventName,
+        starttime: time,
+        endtime: time,
+        edge: state._ZAP._device_info.connectionType || env.getConnectionType(),
+        networkstatus: env.getNetworkStatus(),
+        screen: state._ZAP._current_screen.screen || '', // no i18n
+        sessionstarttime: state._ZAP._current_session.starttime || time,
+        customproperties: _jsonObj
+    };
+    // save the event
+    // the session may still be waiting out its minimum; this event is what earns it
+    session.commitPendingSession();
+    debug.noteDebugActivity();
+    storage.engagement_transactions.add(eventData);
+    logger.Console.log('AppticsEvents.addEvent(\'' + eventName + '\',\'' + groupName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    logger.Console.dir(eventData);
+}
+/**
+ * The app's own screen view with a known id and start. The public inScreen takes the id and the
+ * time when the app calls it, so the id it hands back is the view's even when start-up is still
+ * running and this runs a moment later.
+ */
+function inScreenAt(screenName, jsonObj, id, startedAt) {
+    if (!validate.validateScreenName(screenName)) {
+        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        return;
+    }
+    // the app named this screen itself: the automatic view of the same navigation gives way to it
+    hooks.hooks.screenTrackedByApp();
+    recordScreen(screenName, jsonObj, id, startedAt);
+}
+/** Ends the screen view inScreen() began, as Android's AppticsScreenTracker.outScreen(id). */
+function outScreenAt(id, endedAt) {
+    if (utils.isEmpty(id)) {
+        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.outScreen: no screen id given'); // no i18n
+        return;
+    }
+    session.closeScreen(id, endedAt);
+}
+/**
+ * Queues a screen view and makes it the current screen.
+ *
+ * The view is stored open (endtime 0) and closed when the next screen starts, when the page is
+ * hidden or closed, when its session ends, or by outScreen() — which is what gives it a duration.
+ * An open view is not sent until it is closed, as an open session is not.
+ */
+function recordScreen(screenName, jsonObj, id, startedAt, implicit) {
+    if (!consent.canTrackEngagement('inScreen')) { // no i18n
+        return;
+    }
+    if (!validate.validateScreenName(screenName)) {
+        logger.logFailure(constants.AP_LOG_MODULE.SCREEN, 'AppticsScreenTracker.inScreen: Invalid screenName: ' + String(screenName)); // no i18n
+        return;
+    }
+    jsonObj = jsonObj || {};
+    var _jsonObj = validate.validateJSON(jsonObj);
+    // epoch time in milliseconds
+    var time = typeof startedAt === 'number' ? startedAt : utils.nowMs(); // no i18n
+    var screenData = {
+        id: id || utils.getNewUUID(),
+        type: constants.AP_CONSTANTS.SCREEN,
+        screen: screenName,
+        starttime: time,
+        endtime: 0,
+        edge: state._ZAP._device_info.connectionType || env.getConnectionType(),
+        networkstatus: env.getNetworkStatus(),
+        orientation: env.getOrientation(),
+        sessionstarttime: state._ZAP._current_session.starttime || time,
+        customproperties: _jsonObj
+    };
+    // the screen being left ends where this one starts
+    var previous = state._ZAP._current_screen && state._ZAP._current_screen.id;
+    if (previous && previous !== screenData.id) {
+        session.closeScreen(previous, time);
+    }
+    session.commitPendingSession();
+    debug.noteDebugActivity();
+    storage.engagement_transactions.add(screenData);
+    // `implicit`: a view recorded only so a heatmap record has one to belong to. Kept on the
+    // in-memory copy alone, never on the stored item, which goes to the server as it is
+    state._ZAP._current_screen = implicit ? Object.assign({}, screenData, { implicit: true }) : screenData;
+    logger.Console.log('AppticsScreenTracker.inScreen(\'' + screenName + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    logger.Console.dir(screenData);
+}
+/**
+ * The screen a heatmap record belongs to, making sure engagement/add has a view of it: the console
+ * places a record by its screen, and a screen that was never sent as a view leaves it nowhere.
+ *
+ * A screen the app or automatic screen tracking named is used as it is — that one already has its
+ * view. Otherwise (automatic tracking off and no inScreen() call) the page is named the way
+ * automatic tracking would name it, and a view is recorded for it: once per screen, a new one when
+ * the path changes, and given way as soon as anything else names the screen.
+ */
+function screenForRecord() {
+    var current = state._ZAP._current_screen;
+    if (current && !utils.isEmpty(current.screen) && !current.implicit) {
+        return String(current.screen);
+    }
+    var name = autoScreen.automaticScreenName() || '/'; // no i18n
+    if (!current || !current.id || current.screen !== name || current.endtime) {
+        recordScreen(name, undefined, undefined, undefined, true);
+    }
+    return name;
+}
+/**
+ * Back in view after being hidden: the hide ended the screen view, so the screen the user is on
+ * starts a new one, as an Android activity coming back to the foreground does.
+ */
+function resumeScreen() {
+    var current = state._ZAP._current_screen;
+    if (!current || !current.id || !current.endtime || utils.isEmpty(current.screen)) {
+        return;
+    }
+    recordScreen(String(current.screen));
+}
+/**
+ * What the proxy accepts as an api item's hostname and path (security-regex.xml: api_hostname,
+ * api_urlpath). It validates these before the server sees them, and a rejected item is dropped
+ * there — nothing reaches the console and nothing says why. Checking here means trackApi can
+ * repair or refuse the value while there is still a caller to tell.
+ */
+const API_HOSTNAME = /^([a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+const API_PATH_DISALLOWED = /[^a-zA-Z0-9\-._*\/]+/g;
+/**
+ * Rewrites a path to the characters the proxy allows, one `*` per run of anything else, so an id
+ * that happens to hold an email or an encoded character costs that segment's detail rather than
+ * the whole call. Segment boundaries survive, which is what the console groups by.
+ */
+function sanitizeApiPath(path) {
+    if (utils.isEmpty(path)) {
+        return '/'; // no i18n
+    }
+    var cleaned = path.replace(API_PATH_DISALLOWED, '*'); // no i18n
+    return cleaned.charAt(0) === '/' ? cleaned : '/' + cleaned; // no i18n
+}
+/** A path for a log line, without the query, which can carry tokens. */
+function withoutQueryForLog(path) {
+    return String(path || '').split(/[?#]/)[0]; // no i18n
+}
+function trackApi(jsonObj) {
+    if (!consent.canTrackEngagement('trackApi')) { // no i18n
+        return;
+    }
+    jsonObj = jsonObj || {};
+    // Extract raw values from jsonObj (from XHR/fetch hook or manual calls)
+    var rawUrl = jsonObj.url || jsonObj.path || '';
+    var method = (jsonObj.method || 'GET').toString();
+    var responsecode = (typeof jsonObj.responsecode === 'number') ? jsonObj.responsecode :
+        (typeof jsonObj.status === 'number') ? jsonObj.status : 0;
+    // the template requires this key, and fetch leaves statusText empty on HTTP/2, so a
+    // placeholder stands in rather than risking the item being refused for an empty value
+    var responsemessage = jsonObj.responsemessage || jsonObj.statusText || jsonObj.error || '-';
+    // Time fields (ms since epoch, consistent with other trackers)
+    var now = utils.nowMs();
+    var starttime = (typeof jsonObj.starttime === 'number') ? jsonObj.starttime : now;
+    var endtime;
+    if (typeof jsonObj.endtime === 'number') {
+        endtime = jsonObj.endtime;
+    }
+    else if (typeof jsonObj.duration === 'number') {
+        endtime = starttime + jsonObj.duration;
+    }
+    else {
+        endtime = now;
+    }
+    // URL breakdown: scheme, hostname, port, path
+    var scheme = jsonObj.scheme || '';
+    var hostname = jsonObj.hostname || '';
+    var port = (typeof jsonObj.port === 'number') ? jsonObj.port : 0;
+    var path = jsonObj.path || '';
+    if (!utils.isEmpty(rawUrl)) {
+        try {
+            var urlObj = new URL(rawUrl, window.location.origin);
+            if (utils.isEmpty(scheme)) {
+                scheme = urlObj.protocol.replace(':', ''); // "https:"
+            }
+            if (utils.isEmpty(hostname)) {
+                hostname = urlObj.hostname;
+            }
+            if (!port) {
+                if (urlObj.port) {
+                    port = parseInt(urlObj.port, 10);
+                }
+                else {
+                    port = (urlObj.protocol === 'https:') ? 443 : 80;
+                }
+            }
+            if (utils.isEmpty(path)) {
+                path = urlObj.pathname;
+            }
+        }
+        catch (e) {
+            // Fallback: treat rawUrl as path if parsing fails
+            if (utils.isEmpty(path)) {
+                path = rawUrl;
+            }
+        }
+    }
+    // only http and https exist as far as the proxy's api_scheme is concerned
+    scheme = (scheme === 'https' || scheme === 'http') ? scheme : 'https'; // no i18n
+    // a hostname the proxy refuses cannot be repaired without inventing one, so the call is
+    // dropped here and said out loud. localhost and bare IPs land here: api_hostname wants at
+    // least one dot and an alphabetic suffix, which is worth knowing when nothing shows up locally
+    if (!API_HOSTNAME.test(hostname)) {
+        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApiTracker: hostname not accepted by the server: ' + String(hostname)); // no i18n
+        return;
+    }
+    // configureApiTracking: the app's rules decide whether this call is recorded at all
+    if (!apiRules.hostAllowed(hostname) || apiRules.endpointIgnored(path)) {
+        logger.Console.log('AppticsApiTracker: ' + hostname + withoutQueryForLog(path) + ' is left out by configureApiTracking'); // no i18n
+        return;
+    }
+    // and the name it is recorded under: ids become *, regional hosts one group, so the console
+    // groups calls by endpoint rather than by every id that went through it
+    path = sanitizeApiPath(apiRules.normalizeApiPath(path));
+    hostname = apiRules.groupedHost(hostname);
+    var sessionStart = state._ZAP._current_session.starttime || starttime;
+    // no customproperties: apiWebSDK does not declare the key, unlike the screen and event
+    // templates, so anything extra the caller passes is context for the log line only
+    var apiData = {
+        id: utils.getNewUUID(),
+        type: constants.AP_CONSTANTS.API,
+        // Required by backend schema
+        scheme: scheme,
+        port: port,
+        hostname: hostname,
+        path: path,
+        method: method,
+        responsecode: responsecode,
+        responsemessage: responsemessage,
+        starttime: starttime,
+        endtime: endtime,
+        sessionstarttime: sessionStart,
+        networkstatus: env.getNetworkStatus(),
+        edge: state._ZAP._device_info.connectionType || env.getConnectionType()
+    };
+    // save the api
+    session.commitPendingSession();
+    debug.noteDebugActivity();
+    storage.engagement_transactions.add(apiData);
+    logger.Console.log('AppticsApiTracker(\'' + method + ' ' + scheme + '://' + hostname + path + '\')'); // no i18n
+    logger.Console.dir(apiData);
+}
+/** Begun calls by id. Bounded, so an app that starts calls it never ends can't grow it forever. */
+var openCalls = {};
+var openOrder = [];
+const MAX_OPEN_CALLS = 500;
+/**
+ * Begins timing one API call, as Android's AppticsApiTracker.startTrackApi(url, method): returns
+ * the id to hand to endTrackApi once the response is in. Records nothing by itself.
+ */
+function startTrackApi(url, method) {
+    var id = utils.getNewUUID();
+    openCalls[id] = { url: String(url || ''), method: String(method || 'GET').toUpperCase(), starttime: utils.nowMs() }; // no i18n
+    openOrder.push(id);
+    if (openOrder.length > MAX_OPEN_CALLS) {
+        delete openCalls[openOrder.shift()];
+    }
+    return id;
+}
+/**
+ * Finishes a call startTrackApi began and records it, timed from start to `endedAt`. The public
+ * wrapper takes `endedAt` when the app calls it, so a call ended while start-up is still running
+ * keeps its real duration even though it is recorded a moment later.
+ */
+function endTrackApiAt(id, responseCode, responseMessage, endedAt) {
+    var open = openCalls[id];
+    if (!open) {
+        logger.logFailure(constants.AP_LOG_MODULE.API, 'AppticsApiTracker.endTrackApi: no call started with id ' + String(id)); // no i18n
+        return;
+    }
+    delete openCalls[id];
+    openOrder = openOrder.filter(function (one) { return one !== id; });
+    trackApi({
+        url: open.url,
+        method: open.method,
+        responsecode: typeof responseCode === 'number' ? responseCode : 0, // no i18n
+        responsemessage: responseMessage,
+        starttime: open.starttime,
+        endtime: endedAt,
+    });
+}
+
+exports.endTrackApiAt = endTrackApiAt;
+exports.inScreenAt = inScreenAt;
+exports.outScreenAt = outScreenAt;
+exports.recordScreen = recordScreen;
+exports.resumeScreen = resumeScreen;
+exports.screenForRecord = screenForRecord;
+exports.startTrackApi = startTrackApi;
+exports.trackApi = trackApi;
+exports.trackEvent = trackEvent;

package/dist/cjs/errors/send.d.ts

@@ -0,0 +1,6 @@
+import type { Dict, ServerResult } from '../types.js';
+/**
+ * Sends pending errors to the Apptics API.
+ */
+export declare function sendErrorData(forget?: boolean): Promise<void>;
+export declare function requestToSendErrors(_payload: Dict, forget?: boolean): Promise<ServerResult>;

package/dist/cjs/errors/send.js

@@ -0,0 +1,73 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+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 env = require('../core/env.js');
+var consent = require('../core/consent.js');
+var batch = require('../core/batch.js');
+var transport = require('../core/transport.js');
+
+/**
+ * Sends pending errors to the Apptics API.
+ */
+function sendErrorData(forget) {
+    // errortracking off (getupdates): queued errors stay until tracking is back on or they expire
+    if (env.is_apptics_disabled() || !consent.shouldTrackOrSendData() || !state._ZAP._errorTracking) {
+        return Promise.resolve();
+    }
+    if (navigator.onLine == false) {
+        logger.Console.warn('sendErrorData: No Network'); // no i18n
+        return Promise.resolve();
+    }
+    // if we're busy sending, retry in .5s
+    if (state._ZAP._sending) {
+        batch.defer(sendErrorData);
+        return Promise.resolve();
+    }
+    state._ZAP._sending = true;
+    batch.clearDefer();
+    return batch.withSendLock('errors', function () {
+        return batch.freshItems(storage.error_transactions, function (item) { return item.happenedat != 0; }, function (item) { return item.happenedat; }).then(function (error_items) {
+            if (error_items.length == 0) {
+                return;
+            }
+            let exceptiondetails = [];
+            var sent = [];
+            utils.cloneObject(error_items).forEach(function (item) {
+                sent.push({ ...item });
+                if (!item.hasOwnProperty('screenname')) { // no i18n
+                    item.screenname = ''; // no i18n
+                }
+                delete item.id;
+                delete item.type;
+                exceptiondetails.push(item);
+            });
+            return batch.awaitUnlessClosing(requestToSendErrors({ exceptiondetails: exceptiondetails }, forget).then(function () {
+                return storage.error_transactions.remove(sent);
+            }, function (err) {
+                // the server will never accept this batch. Keeping it would block every later
+                // batch behind it for good, so it is dropped and said out loud
+                if (transport.isPermanentRefusal(err)) {
+                    logger.warnAlways('apptics: the server refused these errors, so they were dropped: ' + String(err && err.message)); // no i18n
+                    return storage.error_transactions.remove(sent);
+                }
+                return Promise.reject(err);
+            }), forget, 'sendErrorData'); // no i18n
+        });
+    }).catch(function (err) {
+        logger.Console.log('sendErrorData:' + err); // no i18n
+    }).then(function () {
+        state._ZAP._sending = false;
+    });
+}
+// Function to send error data to server
+function requestToSendErrors(_payload, forget) {
+    var label = 'requestToSendErrors'; // no i18n
+    return batch.sendBatch('error', label, _payload, forget); // no i18n
+}
+
+exports.requestToSendErrors = requestToSendErrors;
+exports.sendErrorData = sendErrorData;

package/dist/cjs/errors/track.d.ts

@@ -0,0 +1,4 @@
+import type { Properties } from '../types.js';
+export declare function trackError(errorEvent: any, jsonObj?: Properties): void;
+export declare function enableGlobalErrorHandler(status?: boolean): void;
+export declare function extractMethodNameFromStackTrace(stackTrace: string): string;

package/dist/cjs/errors/track.js

@@ -0,0 +1,127 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (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 session = require('../engagement/session.js');
+var env = require('../core/env.js');
+var consent = require('../core/consent.js');
+var validate = require('../core/validate.js');
+var debug = require('../core/debug.js');
+
+/**
+ * The stack to report. Three sources, in order of how much they tell us:
+ *
+ * `reason.stack` and `error.stack` are where a promise rejection and a window error event keep it.
+ * `errorEvent.stack` covers an Error handed straight to trackError — `trackError(new Error('x'))`
+ * is the first thing anyone writes, and reading only the wrapped forms lost its trace silently.
+ *
+ * Failing all of those, a cross-origin script error or a non-Error throw carries no stack at all,
+ * and the event's own filename, line and column are the only detail there is, so they are written
+ * as a one-frame stack rather than discarded.
+ */
+function stackOf(errorEvent) {
+    var stack = errorEvent.reason?.stack || errorEvent.error?.stack || errorEvent.stack || ''; // no i18n
+    if (!utils.isEmpty(stack)) {
+        return stack;
+    }
+    var file = errorEvent.filename || errorEvent.fileName || ''; // no i18n
+    if (utils.isEmpty(file)) {
+        return ''; // no i18n
+    }
+    var line = errorEvent.lineno !== undefined ? errorEvent.lineno : errorEvent.lineNumber;
+    var column = errorEvent.colno !== undefined ? errorEvent.colno : errorEvent.columnNumber;
+    return 'at ' + file + (utils.isEmpty(line) ? '' : ':' + line) + (utils.isEmpty(column) ? '' : ':' + column); // no i18n
+}
+/** Said in place of a stack when there is none, so `message` is never sent empty. */
+const NO_STACK = 'no stack available'; // no i18n
+function trackError(errorEvent, jsonObj) {
+    if (!consent.canTrackErrors('trackError')) { // no i18n
+        return;
+    }
+    if (utils.isEmpty(errorEvent)) {
+        logger.Console.warn('AppticsTrackError: Invalid error'); // no i18n
+        return;
+    }
+    var _jsonObj = validate.validateJSON(jsonObj);
+    var stack = stackOf(errorEvent);
+    var methodName = extractMethodNameFromStackTrace(stack) || "";
+    var issuetype = errorEvent.type || "";
+    var thrown = errorEvent.reason || errorEvent.error || errorEvent.message || "";
+    // "Error: x at handler", or just "Error: x" when the stack names no method. issuename is
+    // required too, so something that carried no message at all is still named rather than blank
+    var described = !utils.isEmpty(String(thrown)) ? String(thrown) : (!utils.isEmpty(issuetype) ? String(issuetype) : 'Unknown error'); // no i18n
+    var message = described + (utils.isEmpty(methodName) ? "" : ' at ' + methodName);
+    // epoch time in seconds
+    var time = utils.nowMs();
+    var errorData = {
+        id: utils.getNewUUID(),
+        type: constants.AP_CONSTANTS.ERROR,
+        edge: state._ZAP._device_info.connectionType || env.getConnectionType(),
+        networkstatus: env.getNetworkStatus(),
+        happenedat: time,
+        issuename: message,
+        // the template requires this key, so a stackless error still says something: an empty value
+        // risks the proxy refusing the item, and errors travel in batches
+        message: !utils.isEmpty(stack) ? stack : (!utils.isEmpty(String(thrown)) ? String(thrown) : NO_STACK),
+        screenname: state._ZAP._current_screen.screen || window.location.pathname,
+        sessionstarttime: state._ZAP._current_session.starttime || time,
+        customproperties: _jsonObj
+    };
+    // save the error
+    // an error is worth a session even in the first seconds of a visit
+    session.commitPendingSession();
+    debug.noteDebugActivity();
+    storage.error_transactions.add(errorData);
+    logger.Console.log('AppticsTrackError(\'' + issuetype + '\',\'' + message + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    logger.Console.dir(errorData);
+}
+function enableGlobalErrorHandler(status) {
+    state._ZAP._isGlobalErrorTracking = typeof status === "boolean" ? status : true; // no i18n
+}
+function extractMethodNameFromStackTrace(stackTrace) {
+    let methodName = ''; // no i18n
+    if (utils.isEmpty(stackTrace)) {
+        return methodName;
+    }
+    const lines = stackTrace.split('\n'); // no i18n
+    if (lines.length < 2) {
+        return methodName; // Not enough information in the stack trace
+    }
+    // The method name is typically included in the second line
+    const methodNamePattern1 = /at (\S+) \(/;
+    const methodNamePattern2 = /^(\w+)@/;
+    for (let line of lines) {
+        const match1 = line.match(methodNamePattern1);
+        const match2 = line.match(methodNamePattern2);
+        // For browsers like Chrome, Ula
+        if (match1 && match1[1]) {
+            // Return the method name
+            const urlRegex = /\((.*)\)/;
+            // Extract the URL from the error string
+            const urlMatch = urlRegex.exec(line);
+            // Extracted URL
+            const url = urlMatch ? urlMatch[1] : 'Unknown URL'; // no i18n
+            methodName = match1[1];
+            url.split('/').pop(); // no i18n
+            methodName = methodName; // + '@'+ fileNameAndLine;
+            break;
+        }
+        // For browsers like Safari
+        if (match2 && match2[1]) {
+            // Return the method name
+            methodName = match2[1];
+            line.split('@')[1].split('/').pop(); // no i18n
+            methodName = methodName; // + '@'+ fileNameAndLine; // no i18n
+            break;
+        }
+    }
+    return methodName;
+}
+
+exports.enableGlobalErrorHandler = enableGlobalErrorHandler;
+exports.extractMethodNameFromStackTrace = extractMethodNameFromStackTrace;
+exports.trackError = trackError;

package/dist/cjs/feedback/controls.d.ts

@@ -0,0 +1,31 @@
+import type { Dict } from '../types.js';
+/** Who the next submission is attributed to: the picked user, or nobody. */
+export interface UserChoice {
+    anonymous: boolean;
+    userid: string;
+    groupid: string;
+}
+/** Read by core/transport when it builds the feedback request's parameters. */
+export declare const userChoice: UserChoice;
+/** Whether the next submission carries the stored logs and diagnostics. Unset means "decide from what is stored". */
+export declare const logChoice: {
+    includeLog?: boolean;
+    includeDyninfo?: boolean;
+};
+/**
+ * The "User" dropdown above the description. It lists Anonymous plus every registered user, and
+ * starts on the active one (status 1) unless the caller asked for anonymous.
+ */
+export declare function wireUserPicker(modal: HTMLElement, forceAnonymous: boolean): void;
+/**
+ * The two "Include …" switches and the viewer behind their View links. A row is shown only when
+ * there is something to include, and is then on by default, so a submission carries what the app
+ * recorded unless the user turns it off.
+ */
+export declare function wireLogControls(modal: HTMLElement, opts: Dict): void;
+/**
+ * Drags the dialog by its header. The right/bottom placement from the stylesheet is converted to
+ * an explicit left/top on the first drag, so the offsets have something to add to, and the box is
+ * kept inside the viewport.
+ */
+export declare function wireDrag(box: HTMLElement): void;