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

package/dist/cjs/index.js

@@ -0,0 +1,150 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (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 logs = require('./feedback/logs.js');
+var autoInit = require('./auto-init.js');
+var debug = require('./core/debug.js');
+var logger = require('./remotelog/logger.js');
+
+/** Android's Apptics: `Apptics.init(config)` starts the SDK. */
+const Apptics = {
+    /** Starts the SDK. The config object is required; the console snippet supplies it via auto-init. */
+    init: guard.guard('Apptics.init', lifecycle.init), // no i18n
+};
+const ready = guard.guard('ready', lifecycle.ready); // no i18n
+/** Android's AppticsEvents: `addEvent(name, group?, properties?)`, or `addEvent(DefinedEvents.X, properties?)`. */
+const AppticsEvents = {
+    addEvent: guard.guard('AppticsEvents.addEvent', track.trackEvent), // no i18n
+};
+const inScreenGuarded = guard.guard('AppticsScreenTracker.inScreen', track.inScreenAt); // no i18n
+const outScreenGuarded = guard.guard('AppticsScreenTracker.outScreen', track.outScreenAt); // no i18n
+/** Android's AppticsScreenTracker: inScreen(name) returns the view's id, outScreen(id) ends it. */
+const AppticsScreenTracker = {
+    /**
+     * 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 (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 (id) {
+        outScreenGuarded(id, utils.nowMs());
+    },
+};
+const endTrackApiGuarded = guard.guard('AppticsApiTracker.endTrackApi', track.endTrackApiAt); // no i18n
+/** Android's AppticsApiTracker: startTrackApi / endTrackApi, and configure for the rules. */
+const AppticsApiTracker = {
+    /** Begins timing one call: returns the id endTrackApi takes. */
+    startTrackApi: guard.guard('AppticsApiTracker.startTrackApi', track.startTrackApi), // no i18n
+    /** Finishes a call startTrackApi began and records it. */
+    endTrackApi: function (id, responseCode, responseMessage) {
+        // the end time now, not when a call made during start-up is replayed
+        endTrackApiGuarded(id, responseCode, responseMessage, utils.nowMs());
+    },
+    /** The rules API tracking records by, from ApiTrackingBuilder. Works before Apptics.init(). */
+    configure: guard.guard('AppticsApiTracker.configure', apiRules.configureApiTracking), // no i18n
+};
+/** Turns automatic API tracking on or off; the `track_api` config flag is the usual way to set it. */
+const enableApiTracking = guard.guard('enableApiTracking', autoApi.enableApiTracking); // no i18n
+/** Reports an error the app caught, or an `error` / `unhandledrejection` event. */
+const AppticsTrackError = guard.guard('AppticsTrackError', track$1.trackError); // no i18n
+const enableGlobalErrorHandler = guard.guard('enableGlobalErrorHandler', track$1.enableGlobalErrorHandler); // no i18n
+/** Registers the signed-in user; properties may be a plain object or UserBuilder.build(). */
+const AppticsSetUser = guard.guard('AppticsSetUser', index.setUser); // no i18n
+const getUser = guard.guard('getUser', index.getUser); // no i18n
+const setTrackingStatus = guard.guard('setTrackingStatus', consent.setTrackingStatus); // no i18n
+const getTrackingStatus = guard.guard('getTrackingStatus', consent.getTrackingStatus); // no i18n
+const flush = guard.guard('flush', scheduler.flush); // no i18n
+/** Records a line for the next feedback submission. Costs nothing until feedback is sent. */
+const addFeedbackLog = guard.guard('addFeedbackLog', logs.addFeedbackLog); // no i18n
+/** Records a diagnostics key/value, grouped under `heading`, for the next feedback submission. */
+const addDiagnosticsInfo = guard.guard('addDiagnosticsInfo', logs.addDiagnosticsInfo); // no i18n
+/**
+ * Turns debug mode on; 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 enableDebug = guard.guard('enableDebug', debug.enableDebug); // no i18n
+/** Turns debug mode off; works before init(), and wins over `debug` in init(). */
+const disableDebug = guard.guard('disableDebug', debug.disableDebug); // no i18n
+const reset = guard.guard('reset', lifecycle.reset); // no i18n
+const apptics = {
+    Apptics,
+    AppticsEvents,
+    AppticsScreenTracker,
+    AppticsApiTracker,
+    AppticsLogger: logger.AppticsLogger,
+    DefinedEvents: definedEvents.DefinedEvents,
+    ApiTrackingBuilder: apiRules.ApiTrackingBuilder,
+    ready,
+    enableDebug,
+    disableDebug,
+    enableApiTracking,
+    AppticsTrackError,
+    enableGlobalErrorHandler,
+    AppticsSetUser,
+    getUser,
+    users: index.users,
+    setTrackingStatus,
+    getTrackingStatus,
+    flush,
+    addFeedbackLog,
+    addDiagnosticsInfo,
+    reset,
+    AP_TRACKING_STATUS: constants.AP_TRACKING_STATUS,
+    AP_FEEDBACK_TYPE: constants.AP_FEEDBACK_TYPE,
+};
+autoInit.scheduleAutoInit(Apptics);
+
+exports.AP_FEEDBACK_TYPE = constants.AP_FEEDBACK_TYPE;
+exports.AP_TRACKING_STATUS = constants.AP_TRACKING_STATUS;
+exports.DefinedEvents = definedEvents.DefinedEvents;
+exports.ApiTrackingBuilder = apiRules.ApiTrackingBuilder;
+exports.UserBuilder = index.UserBuilder;
+exports.users = index.users;
+exports.AppticsLogger = logger.AppticsLogger;
+exports.Apptics = Apptics;
+exports.AppticsApiTracker = AppticsApiTracker;
+exports.AppticsEvents = AppticsEvents;
+exports.AppticsScreenTracker = AppticsScreenTracker;
+exports.AppticsSetUser = AppticsSetUser;
+exports.AppticsTrackError = AppticsTrackError;
+exports.addDiagnosticsInfo = addDiagnosticsInfo;
+exports.addFeedbackLog = addFeedbackLog;
+exports.default = apptics;
+exports.disableDebug = disableDebug;
+exports.enableApiTracking = enableApiTracking;
+exports.enableDebug = enableDebug;
+exports.enableGlobalErrorHandler = enableGlobalErrorHandler;
+exports.flush = flush;
+exports.getTrackingStatus = getTrackingStatus;
+exports.getUser = getUser;
+exports.ready = ready;
+exports.reset = reset;
+exports.setTrackingStatus = setTrackingStatus;

package/dist/cjs/lifecycle.d.ts

@@ -0,0 +1,14 @@
+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 serviceUrl, zak, identifier 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;
+/** 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;