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

package/dist/cjs/types.d.ts

@@ -0,0 +1,312 @@
+import type { AP_FEEDBACK_TYPE, AP_TRACKING_STATUS } from './core/constants.js';
+import type { UserBuilder } from './user/index.js';
+import type { ApiTrackingBuilder, ApiTrackingConfig } from './engagement/api-rules.js';
+import type { DefinedEvent } from './engagement/defined-events.js';
+import type { AppticsLogger } from './remotelog/logger.js';
+/** Loose record for legacy payloads and server JSON that are built and sent as-is. */
+export type Dict = Record<string, any>;
+/** An item in the engagement or error queue. */
+export interface QueueItem {
+    id?: string;
+    type?: string;
+    starttime?: number;
+    endtime?: number;
+    [key: string]: any;
+}
+/** Device properties sent to and returned by `device/add`. */
+export type DeviceInfo = Dict;
+export interface UserInfo {
+    userid?: string;
+    groupid?: string;
+    status?: number;
+    [key: string]: any;
+}
+export interface ServerResult<T = Dict> {
+    result: string;
+    data?: T;
+    error_code?: unknown;
+    [key: string]: any;
+}
+export type TrackingStatus = (typeof AP_TRACKING_STATUS)[keyof typeof AP_TRACKING_STATUS];
+export type FeedbackType = (typeof AP_FEEDBACK_TYPE)[keyof typeof AP_FEEDBACK_TYPE];
+export type Properties = Record<string, unknown>;
+/** The config init() requires. The console snippet provides the same shape as window.appticssettings._defaultoptions. */
+export interface AppticsConfig {
+    /** Apptics host every request goes to, e.g. https://apptics.localzoho.com (a trailing slash is ignored). */
+    serviceUrl: string;
+    /** The app's token, sent as the `zak` header on app/addversion and device registration. */
+    zak: string;
+    /** App identifier, e.g. com.zoho.web.zylker. */
+    identifier: string;
+    /**
+     * Your app's version or build number, e.g. '2.4.0' or 512. Required: everything the SDK reports
+     * is only meaningful against the build it came from, so there is no default. Changing it
+     * registers the new version. Sent as text: a string is trimmed, and a number keeps only the
+     * digits JavaScript gives it (1.10 is '1.1'), so pass a dotted version as a string. A blank
+     * value, or a snippet placeholder such as 'YOUR_APP_VERSION', is refused.
+     */
+    appversion: string | number;
+    /** @deprecated ignored: app/addversion answers with the aaid */
+    aaid?: string;
+    /** @deprecated ignored: app/addversion answers with the aaid */
+    aaID?: string;
+    /** @deprecated ignored: app/addversion answers with the portal id */
+    zsoid?: string;
+    /** @deprecated ignored: app/addversion answers with the project id */
+    projectID?: string;
+    /** @deprecated console-snippet name for serviceUrl */
+    base_domain?: string;
+    /** @deprecated console-snippet name for zak */
+    token?: string;
+    /** Data centre key for Quartz screen recording: US, EU, IN, AU, CN, CA, JP, SA, AE, Local, or '-' to disable. */
+    DC?: string;
+    /**
+     * Debug mode: send engagement, exception and log payloads to their `debug/` twins, which answer
+     * with a request id and a link to the server's own logs, for following in the Apptics web
+     * console. Off by default; it does not change what is sent. Same as calling enableDebug().
+     */
+    debug?: boolean;
+    /** Log the SDK's own activity to the browser console. Off by default. */
+    console_log?: boolean;
+    ignore_do_not_track?: boolean;
+    /**
+     * Send the SDK's own failures to console/addlog, so they can be read from the Apptics console.
+     * This carries no app data: one line per failure, tagged with the SDK module it happened in.
+     */
+    remote_log?: boolean;
+    quartz_workspace_key?: string;
+    quartz_department_key?: string;
+    /**
+     * Record the app's API calls automatically, by wrapping XHR and fetch. Off by default. The SDK's
+     * own requests are never recorded. Which hosts and endpoints are recorded, and under what path,
+     * is set with configureApiTracking(new ApiTrackingBuilder()...build()).
+     */
+    track_api?: boolean;
+    /**
+     * Record screen views automatically: the page the SDK starts on, then every navigation —
+     * history.pushState / replaceState, back and forward, and `#/` hash routes. The screen is named
+     * by its path, without the query string. On by default. A inScreen() call within 300 ms of a
+     * navigation replaces its automatic view; set this false to track only the app's own calls.
+     */
+    track_screen?: boolean;
+    /**
+     * Print each `logger` line to the browser console too, at its level, as Android's showLogs
+     * prints to Logcat. Off by default. `console_log` is the SDK's own activity; this is the app's lines.
+     */
+    show_logs?: boolean;
+    /**
+     * Record sessions automatically. On by default; `false` records no sessions, while events,
+     * screens and the rest still are — Android's `automaticSessionsTrackingStatus = false`.
+     */
+    track_session?: boolean;
+    /** How often queued data is sent, in milliseconds. Default 30000, at least 1000. */
+    batch_flush_interval?: number;
+    /** How often the server's tracking flags are fetched, in milliseconds. Default 120000, at least 10000. */
+    getupdates_interval?: number;
+    /** Most items in one batch. Default 50, between 1 and 500. */
+    batch_size?: number;
+    /** Days an unsent item is kept before it is dropped. Default 7, between 1 and 30. */
+    batch_request_timeout?: number;
+    /** Idle minutes that end a session. Default 30, between 1 and 1440. */
+    inactiveduration?: number;
+    /**
+     * How long a visit must last before its session is recorded, in milliseconds. Default 5000, at
+     * most 60000. A shorter visit with nothing tracked in it is not reported at all; anything tracked
+     * inside the window records the session at once, with its real start time. 0 turns the wait off.
+     */
+    min_session_duration?: number;
+    /**
+     * Record where people click and how far they scroll. Off by default, and it does nothing unless
+     * the app also imports '@zoho_apptics/apptics-js-sdk/heatmap'.
+     */
+    track_heatmap?: boolean;
+    /** Most heatmap records one visit may produce. Default 500; capture pauses past it. */
+    heatmap_max_per_session?: number;
+    /** @deprecated the earlier name for `debug` (debug mode); `debug` wins when both are given */
+    debug_api?: boolean;
+    /**
+     * What to call this device in the debug stream, e.g. 'QA iPad 3'. Sent on engagement,
+     * exception and log, the three endpoints that declare it. Unset, nothing is sent unless
+     * debug mode is on, where a label is derived from the browser and OS instead.
+     */
+    device_name?: string;
+    [key: string]: unknown;
+}
+export interface UserValidationResult {
+    data: Record<string, string | number | boolean>;
+    datatype: Record<string, 'String' | 'Number' | 'Boolean'>;
+    message: Array<{
+        code: 101 | 102 | 103 | 104;
+        keys: string[];
+    }>;
+}
+export interface QuartzApi {
+    startRecording(details: {
+        workspaceLinkName: string;
+        departmentLinkName: string;
+        recordingDomain: string;
+    }): void;
+    previewVideo(): void;
+    editVideo(options: {
+        quartzBranding: boolean;
+    }): void;
+    clearFeedback(): void;
+    endRecording(): void;
+    setVideoContent(element: Element | null): void;
+    submitRecording(details: {
+        email: string;
+        subject: string;
+    }): Promise<{
+        feedbackLink?: string;
+    } | undefined>;
+}
+export interface QuartzConstantsApi {
+    ErrorType: Record<string, string>;
+    FeedbackState: Record<string, string>;
+}
+/**
+ * One heatmap record: a click or a finished scroll gesture, as `heatmap/add` takes it.
+ *
+ * Web-shaped. The endpoint's mobile fields have no meaning in a browser and are not sent:
+ * `battery_in`/`battery_out` (the Battery Status API is gone from Firefox and never existed in
+ * Safari), `pressure` and `finger_count` (0 and 1 for any mouse), `service_provider` (a carrier
+ * name, which the web has no access to). Sending constants for them would put dead columns in
+ * every record.
+ */
+export interface HeatmapRecord {
+    /** Queue key; removed before the record is sent. */
+    id?: string;
+    session_start_time: number;
+    /** When this record happened. The only thing that orders records inside a session. */
+    triggered_time: number;
+    screen: string;
+    url_path: string;
+    /**
+     * 'buttonclick' for a click on something clickable, 'default' otherwise. The server accepts
+     * only `event|default|buttonclick`; the kind of movement goes in `gesture_type`.
+     */
+    triggered_type: 'event' | 'default' | 'buttonclick';
+    /** 'click', or 'up-scroll' / 'down-scroll' / 'left-scroll' / 'right-scroll'. */
+    gesture_type: string;
+    /** Milliseconds the gesture took. 0 for a click. */
+    gesture_duration: number;
+    /** 'mouse', 'touch' or 'pen' from the pointer event. Absent for a scroll, which has none. */
+    input_type?: string;
+    /** A name for the element: an author's attribute where there is one, its text only with PII consent. */
+    element_label: string;
+    /** A stable number for the element's position in the tree, so clicks on one control group together. */
+    triggered_id: number;
+    coordinate_x: number;
+    coordinate_y: number;
+    /** 0-1 across the viewport width. */
+    normalized_x: number;
+    /** 0-1 down the full page height, which is what a scroll-depth map reads. */
+    normalized_y: number;
+    scroll_offset_x: number;
+    scroll_offset_y: number;
+    screen_width: number;
+    screen_height: number;
+    content_height: number;
+    orientation: number;
+    network_status: number;
+    edge_type: string;
+    /** Pixels per second, x1000. 0 for a click. */
+    velocity: number;
+    is_clickable: 0 | 1;
+    is_rage_click: 0 | 1;
+    is_dead_click: 0 | 1;
+}
+/** What `AppticsTrackError` accepts: a window `error` / `unhandledrejection` event or the same shape. */
+export type ErrorLike = Event | {
+    type?: string;
+    error?: unknown;
+    reason?: unknown;
+};
+/** The optional feedback modal, from '@zoho_apptics/apptics-js-sdk/feedback'. */
+export interface AppticsFeedbackApi {
+    /**
+     * Sends feedback without the form. Resolves once it is sent; rejects when it wasn't: the SDK
+     * has not started (no init()), the browser is offline, or the server refused it.
+     */
+    sendFeedback(type?: FeedbackType, message?: string, attachments?: FileList | File[] | null, logFiles?: FileList | File[] | null, 
+    /** dyninfo.txt (diagnostics entries + device info): unset sends it when diagnostics are waiting. */
+    includeDyninfo?: boolean, 
+    /** Stored addFeedbackLog() lines: unset sends them when there are any, false never does. */
+    includeLog?: boolean): Promise<void>;
+    /**
+     * Opens the form. Every argument is optional: `type` and `message` pre-fill it, the include
+     * flags start the log and diagnostics toggles on, and `isAnonymous` starts the user picker on
+     * Anonymous even when a user is registered.
+     */
+    feedbackOpen(type?: FeedbackType, message?: string, includeLog?: boolean, includeDyninfo?: boolean, attachments?: FileList | File[] | null, logFiles?: FileList | File[] | null, isAnonymous?: boolean): void;
+    feedbackClose(): void;
+}
+export interface AppticsApi {
+    /** Android's Apptics. */
+    Apptics: {
+        /** Starts the SDK. The config object is required; the console snippet supplies it via auto-init. */
+        init(config: AppticsConfig): boolean;
+    };
+    /** Android's AppticsEvents. */
+    AppticsEvents: {
+        /** An event. An invalid name or group is not logged; a group left out is `default`. */
+        addEvent(eventName: string, groupName?: string, properties?: Properties): void;
+        /** A defined event (DefinedEvents.AP_USER_LOGIN, …), which brings its own group. */
+        addEvent(definedEvent: DefinedEvent, properties?: Properties): void;
+    };
+    /** Apptics' defined events, as Android's DefinedEvents. */
+    DefinedEvents: Readonly<Record<string, DefinedEvent>>;
+    /** Android's AppticsScreenTracker. */
+    AppticsScreenTracker: {
+        /** Records a screen view and returns its id, for outScreen; '' for an invalid name. */
+        inScreen(screenName: string, properties?: Properties): string;
+        /** Ends the screen view inScreen began, before the next screen would. */
+        outScreen(id: string): void;
+    };
+    /** Android's AppticsApiTracker. */
+    AppticsApiTracker: {
+        /** Begins timing one call; returns the id endTrackApi takes. */
+        startTrackApi(url: string, method?: string): string;
+        /** Finishes the call startTrackApi began, and records it. */
+        endTrackApi(id: string, responseCode: number, responseMessage?: string): void;
+        /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
+        configure(config: ApiTrackingConfig | ApiTrackingBuilder): void;
+    };
+    ApiTrackingBuilder: typeof ApiTrackingBuilder;
+    /** Android's AppticsLogger: off until enable(), then v / d / i / w / e(tag, message). */
+    AppticsLogger: AppticsLogger;
+    /** Resolves true once start-up (storage load, device, session) has finished; false if it can't start. */
+    ready(): Promise<boolean>;
+    /**
+     * Turns debug mode on, before or after Apptics.init(). Engagement, exception and log then go to
+     * their `debug/` twins, whose answers carry a request id and a link into the server's own logs. It
+     * switches itself off after an hour with nothing tracked.
+     */
+    enableDebug(): void;
+    /** Turns debug mode off, before or after Apptics.init(); wins over `debug` in init(). */
+    disableDebug(): void;
+    /**
+     * Turns automatic API tracking on or off after Apptics.init(). Equivalent to the `track_api`
+     * config flag, which is the usual way to set it.
+     */
+    enableApiTracking(enabled?: boolean): void;
+    /** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
+    AppticsTrackError(error: ErrorLike, properties?: Properties): void;
+    enableGlobalErrorHandler(enabled?: boolean): void;
+    /** Properties may be a plain object, or the result of UserBuilder.build(). */
+    AppticsSetUser(userid: string, groupid?: string, properties?: Properties | UserValidationResult): void;
+    getUser(): UserInfo;
+    users: {
+        UserBuilder: typeof UserBuilder;
+    };
+    setTrackingStatus(status: TrackingStatus): void;
+    getTrackingStatus(): TrackingStatus;
+    flush(): void;
+    /** Records a timestamped line, sent as feedbacklog.txt with the next feedback submission. */
+    addFeedbackLog(message: string): void;
+    /** Records a diagnostics key/value under `heading`, sent inside dyninfo.txt with the next feedback. */
+    addDiagnosticsInfo(heading: string, key: string, value?: unknown): void;
+    reset(): void;
+    AP_TRACKING_STATUS: typeof AP_TRACKING_STATUS;
+    AP_FEEDBACK_TYPE: typeof AP_FEEDBACK_TYPE;
+}

package/dist/cjs/user/index.d.ts

@@ -0,0 +1,33 @@
+import type { Dict, Properties, UserInfo, UserValidationResult } from '../types.js';
+export declare function getUser(): UserInfo;
+export declare function setUser(userid?: string, groupid?: string, jsonObj?: Properties | UserValidationResult): void;
+export declare function addOrUpdateUser(user_info: Dict): void;
+export declare function getUserInfo(): void;
+export declare function registerUserWithApptics(user_info: Dict): Promise<Dict>;
+/** Builds validated user properties for setUser. */
+export declare class UserBuilder {
+    [key: string]: unknown;
+    setFirstName(first_name: string): this;
+    setLastName(last_name: string): this;
+    setCompanyName(company_name: string): this;
+    setEmailAddress(email_address: string): this;
+    setContactNumber(contact_number: string): this;
+    setCountry(country: string): this;
+    setRegion(region: string): this;
+    setCity(city: string): this;
+    setGeoLocation(geo_location: string): this;
+    setGender(gender: string): this;
+    setPlanType(plan_type: string): this;
+    setTimezone(timezone: string): this;
+    setLanguage(language: string): this;
+    setEngagementScore(engagement_score: number): this;
+    setDateOfBirth(date_of_birth: number): this;
+    addStringProperty(key: string, value: string): this;
+    addBooleanProperty(key: string, value: boolean): this;
+    addNumberProperty(key: string, value: number): this;
+    setCustomProperties(obj: Record<string, unknown>): this;
+    build(): UserValidationResult;
+}
+export declare const users: {
+    UserBuilder: typeof UserBuilder;
+};

package/dist/cjs/user/index.js

@@ -0,0 +1,178 @@
+/*! @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 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, 'AppticsSetUser: 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, 'AppticsSetUser: 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
+}
+function getUserInfo() {
+    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);
+    }
+}
+// Users module for user management
+const users = { UserBuilder: UserBuilder };
+
+exports.UserBuilder = UserBuilder;
+exports.addOrUpdateUser = addOrUpdateUser;
+exports.getUser = getUser;
+exports.getUserInfo = getUserInfo;
+exports.registerUserWithApptics = registerUserWithApptics;
+exports.setUser = setUser;
+exports.users = users;

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

@@ -0,0 +1,8 @@
+import type { AppticsApi } 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: AppticsApi['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: AppticsApi['Apptics']): void;

package/dist/esm/auto-init.js

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