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

package/dist/cjs/index.js

@@ -0,0 +1,162 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('./core/constants.js');
+var guard = require('./core/guard.js');
+var lifecycle = require('./lifecycle.js');
+var autoApi = require('./engagement/auto-api.js');
+var track = require('./engagement/track.js');
+var definedEvents = require('./engagement/defined-events.js');
+var utils = require('./core/utils.js');
+var validate = require('./core/validate.js');
+var apiRules = require('./engagement/api-rules.js');
+var track$1 = require('./errors/track.js');
+var index = require('./user/index.js');
+var consent = require('./core/consent.js');
+var scheduler = require('./scheduler.js');
+var track$2 = require('./heatmap/track.js');
+require('./heatmap/send.js');
+var autoInit = require('./auto-init.js');
+var debug = require('./core/debug.js');
+
+/*
+ * Every public call below is a function of its own, with the parameter names the console shows
+ * on hover, forwarding to its guard()ed implementation (see forward).
+ */
+const initGuarded = guard.guard('Apptics.init', lifecycle.init); // no i18n
+const readyGuarded = guard.guard('Apptics.ready', lifecycle.ready); // no i18n
+const flushGuarded = guard.guard('Apptics.flush', scheduler.flush); // no i18n
+const resetGuarded = guard.guard('Apptics.reset', lifecycle.reset); // no i18n
+/**
+ * Debug mode, on or off; works before init(), and wins over `debug` in init(). On, engagement,
+ * exception and log go to their `debug/` twins and the answers carry a request id and a link into
+ * the server's own logs. It switches itself off after an hour with nothing tracked, so a forgotten
+ * tab stops tracing on its own.
+ */
+const enableDebugGuarded = guard.guard('Apptics.enableDebug', debug.enableDebug); // no i18n
+const disableDebugGuarded = guard.guard('Apptics.disableDebug', debug.disableDebug); // no i18n
+/** Android's Apptics: starting the SDK, and what applies to all of it. */
+const Apptics = {
+    /** Starts the SDK. The config object is required; the console snippet supplies it via auto-init. */
+    init: function init(config) { return guard.forward(initGuarded, arguments); },
+    /** Resolves true once the SDK is running, false if it can't start. */
+    ready: function ready() { return guard.forward(readyGuarded, arguments); },
+    /** Sends stored engagements, errors and heatmap records now. */
+    flush: function flush() { return guard.forward(flushGuarded, arguments); },
+    /** Clears stored identity, queued data and remote config values, then starts again. */
+    reset: function reset() { return guard.forward(resetGuarded, arguments); },
+    enableDebug: function enableDebug() { return guard.forward(enableDebugGuarded, arguments); },
+    disableDebug: function disableDebug() { return guard.forward(disableDebugGuarded, arguments); },
+};
+/**
+ * Android's AppticsEvents: `addEvent(name, group?, properties?)`, or
+ * `addEvent(AppticsEvent.DefinedEvents.X, properties?)`.
+ */
+const addEventGuarded = guard.guard('AppticsEvent.addEvent', track.trackEvent); // no i18n
+const AppticsEvent = {
+    /** Apptics' defined events, as Android's DefinedEvents, to log with addEvent. */
+    DefinedEvents: definedEvents.DefinedEvents,
+    addEvent: function addEvent(eventName, groupName, properties) {
+        return guard.forward(addEventGuarded, arguments);
+    },
+};
+const inScreenGuarded = guard.guard('AppticsScreen.inScreen', track.inScreenAt); // no i18n
+const outScreenGuarded = guard.guard('AppticsScreen.outScreen', track.outScreenAt); // no i18n
+/** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
+const AppticsScreen = {
+    /**
+     * Records a screen view and returns its id. The view ends at the next screen, when the page is
+     * hidden or its session ends, or when the id is handed to outScreen. '' for an invalid name.
+     */
+    inScreen: function inScreen(screenName, properties) {
+        if (!validate.validateScreenName(screenName)) {
+            // inScreenAt reports it; the caller still needs an answer now
+            inScreenGuarded(screenName, properties, '', utils.nowMs()); // no i18n
+            return ''; // no i18n
+        }
+        // the id and the start now, so both are right even when start-up is still running
+        var id = utils.getNewUUID();
+        inScreenGuarded(screenName, properties, id, utils.nowMs());
+        return id;
+    },
+    /** Ends the screen view inScreen began, before the next screen would. */
+    outScreen: function outScreen(id) {
+        outScreenGuarded(id, utils.nowMs());
+    },
+};
+const endTrackApiGuarded = guard.guard('AppticsApi.endTrackApi', track.endTrackApiAt); // no i18n
+const startTrackApiGuarded = guard.guard('AppticsApi.startTrackApi', track.startTrackApi); // no i18n
+const configureGuarded = guard.guard('AppticsApi.configure', apiRules.configureApiTracking); // no i18n
+const enableApiTrackingGuarded = guard.guard('AppticsApi.enableApiTracking', autoApi.enableApiTracking); // no i18n
+/** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
+const AppticsApi = {
+    /** Begins timing one call: returns the id endTrackApi takes. */
+    startTrackApi: function startTrackApi(url, method) { return guard.forward(startTrackApiGuarded, arguments); },
+    /** Finishes a call startTrackApi began and records it. */
+    endTrackApi: function endTrackApi(id, responseCode, responseMessage) {
+        // the end time now, not when a call made during start-up is replayed
+        endTrackApiGuarded(id, responseCode, responseMessage, utils.nowMs());
+    },
+    /** Builds the rules configure takes: `new AppticsApi.ApiTrackingBuilder()…build()`. */
+    ApiTrackingBuilder: apiRules.ApiTrackingBuilder,
+    /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
+    configure: function configure(config) { return guard.forward(configureGuarded, arguments); },
+    /** Turns automatic API tracking on or off; the `track_api` config flag is the usual way to set it. */
+    enableApiTracking: function enableApiTracking(enabled) { return guard.forward(enableApiTrackingGuarded, arguments); },
+};
+const trackErrorGuarded = guard.guard('AppticsError.trackError', track$1.trackError); // no i18n
+const trackGlobalErrorHandlerGuarded = guard.guard('AppticsError.trackGlobalErrorHandler', track$1.trackGlobalErrorHandler); // no i18n
+/** Errors: the ones the app caught, and the switch for the uncaught ones tracked on their own. */
+const AppticsError = {
+    /** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
+    trackError: function trackError(error, properties) { return guard.forward(trackErrorGuarded, arguments); },
+    /** Turns the automatic tracking of uncaught errors and unhandled rejections on or off. */
+    trackGlobalErrorHandler: function trackGlobalErrorHandler(enabled) { return guard.forward(trackGlobalErrorHandlerGuarded, arguments); },
+};
+const setUserGuarded = guard.guard('AppticsUser.setUser', index.setUser); // no i18n
+const getUserGuarded = guard.guard('AppticsUser.getUser', index.getUser); // no i18n
+/** Android's AppticsUser: the signed-in user, and the builder for their properties. */
+const AppticsUser = {
+    /** Registers the signed-in user; properties may be a plain object or UserBuilder.build(). */
+    setUser: function setUser(userid, groupid, properties) { return guard.forward(setUserGuarded, arguments); },
+    /** The registered user, or {} when there is none. */
+    getUser: function getUser() { return guard.forward(getUserGuarded, arguments); },
+    UserBuilder: index.UserBuilder,
+};
+const trackHeatmapGuarded = guard.guard('AppticsHeatmap.trackHeatmap', track$2.trackHeatmap); // no i18n
+/** Heatmap capture: AppticsHeatmap.trackHeatmap() starts or stops recording clicks and scrolls. */
+const AppticsHeatmap = {
+    trackHeatmap: function trackHeatmap(on) { return guard.forward(trackHeatmapGuarded, arguments); },
+};
+const setTrackingStatusGuarded = guard.guard('AppticsSettings.setTrackingStatus', consent.setTrackingStatus); // no i18n
+const getTrackingStatusGuarded = guard.guard('AppticsSettings.getTrackingStatus', consent.getTrackingStatus); // no i18n
+/** Android's AppticsSettings: what the SDK may track for this visitor. */
+const AppticsSettings = {
+    /** The states setTrackingStatus takes: USAGE_TRACKING_WITH_PII, USAGE_TRACKING_WITHOUT_PII, NO_TRACKING. */
+    AP_TRACKING_STATUS: constants.AP_TRACKING_STATUS,
+    setTrackingStatus: function setTrackingStatus(status) { return guard.forward(setTrackingStatusGuarded, arguments); },
+    getTrackingStatus: function getTrackingStatus() { return guard.forward(getTrackingStatusGuarded, arguments); },
+};
+const apptics = {
+    Apptics,
+    AppticsEvent,
+    AppticsScreen,
+    AppticsApi,
+    AppticsError,
+    AppticsUser,
+    AppticsSettings,
+    AppticsHeatmap,
+};
+autoInit.scheduleAutoInit(Apptics);
+
+exports.Apptics = Apptics;
+exports.AppticsApi = AppticsApi;
+exports.AppticsError = AppticsError;
+exports.AppticsEvent = AppticsEvent;
+exports.AppticsHeatmap = AppticsHeatmap;
+exports.AppticsScreen = AppticsScreen;
+exports.AppticsSettings = AppticsSettings;
+exports.AppticsUser = AppticsUser;
+exports.default = apptics;

package/dist/cjs/lifecycle.d.ts

@@ -0,0 +1,21 @@
+import { type ScreenRouteRule } from './core/constants.js';
+import type { AppticsConfig } from './types.js';
+/**
+ * Starts the SDK. The config object is required: pass it directly, or let the console snippet
+ * supply it (auto-init reads window.appticssettings._defaultoptions and calls init with it).
+ * Returns true when the config has base_url, auth_key, app_domain and appversion and start-up has
+ * begun (see ready()), false when it was already running, the config is missing or incomplete, or
+ * there is no browser. Start-up calls app/addversion with those four, which answers with aaid, the
+ * portal and project ids and the rest; then device/add registers the browser, as in 1.x.
+ */
+export declare function init(config: AppticsConfig): boolean;
+/**
+ * screen_routes as init() keeps it: each entry checked, an exact path cleaned up, a regex given as
+ * a string compiled. An entry that cannot be used is left out, and said, rather than matching
+ * something its author did not mean.
+ */
+export declare function screenRouteRules(routes: unknown): ScreenRouteRule[];
+/** Resolves true once start-up has finished, false if init() refused or storage is unusable. */
+export declare function ready(): Promise<boolean>;
+/** Clears stored identity and queues, then starts again from the snippet. */
+export declare function reset(): void;