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

package/dist/cjs/core/utils.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var constants = require('./constants.js');

package/dist/cjs/core/validate.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var logger = require('./logger.js');
@@ -220,7 +220,7 @@ function validateScreenName(str) {
     }
     // Define the regular expression pattern
     //^[a-zA-Z][\\w\\s]{1,100}$
-    const pattern = /^[\w\s.\-_&/:]{0,99}$/;
+    const pattern = /^[\w\s.\-_&/:*]{0,99}$/;
     // Test if the string matches the pattern
     return pattern.test(str);
 }

package/dist/cjs/device/appversion.d.ts

@@ -1,11 +1,6 @@
 /** Whether we already hold usable ids for the app and version running now. */
 export declare function hasAppVersion(): boolean;
-/**
- * Registers this build, or reuses the stored answer.
- *
- * Resolves true when the ids are in place, false when they are not — the caller stops there
- * rather than carrying on to calls that would be refused for missing them.
- */
+export declare function appVersionFailedForNetwork(): boolean;
 export declare function registerAppVersion(): Promise<boolean>;
 /**
  * Puts the stored ids back on `_ZAP._device_info`.

package/dist/cjs/device/appversion.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.1 | (c) Zoho Corporation Private Limited | see LICENSE */
 'use strict';
 
 var state = require('../core/state.js');
@@ -80,7 +80,16 @@ function apply(data) {
  * Resolves true when the ids are in place, false when they are not — the caller stops there
  * rather than carrying on to calls that would be refused for missing them.
  */
+/**
+ * Whether the last registration failed for want of a network (offline, a dropped connection, a
+ * timeout) rather than because the server answered no. Only the first is worth trying again.
+ */
+var failedForNetwork = false;
+function appVersionFailedForNetwork() {
+    return failedForNetwork;
+}
 function registerAppVersion() {
+    failedForNetwork = false;
     if (hasAppVersion()) {
         apply(stored());
         logger.Console.log(LABEL + ': reusing the ids stored for ' + state._ZAP._defaultoptions.appversion); // no i18n
@@ -128,6 +137,8 @@ function registerAppVersion() {
         return true;
     })
         .catch(function (err) {
+        // a server answer carries serverResult; a request that never got one does not
+        failedForNetwork = !(err && err.serverResult) || navigator.onLine === false;
         logger.warnAlways(LABEL + ': could not register this app version: ' + String(err && err.message ? err.message : err)); // no i18n
         return false;
     })
@@ -152,6 +163,7 @@ function clearAppVersion() {
     storage.user_defaults.add(STORE_KEY, undefined);
 }
 
+exports.appVersionFailedForNetwork = appVersionFailedForNetwork;
 exports.applyStoredAppVersion = applyStoredAppVersion;
 exports.clearAppVersion = clearAppVersion;
 exports.hasAppVersion = hasAppVersion;

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

@@ -1,6 +1,17 @@
 import type { DeviceInfo, Dict, ServerResult } from '../types.js';
 export declare function checkAndUpdateDeviceInfo(): void;
 export declare function addOrUpdateDeviceID(device_info: DeviceInfo, previous?: DeviceInfo): void;
+/**
+ * Sets up this browser's device at start-up: the uuid, the device info, and a registration when
+ * the browser has none.
+ *
+ * Settings are this tab's own copy, loaded when it started. On a browser with no device yet, two
+ * tabs started together would each register it and store two devices, so the first visit runs
+ * under a lock shared by every tab of the site: the tab that gets it re-reads storage, registers
+ * only when no other tab has, and keeps the lock until the new ids are stored. The next tab then
+ * finds them. Start-up goes on as soon as the device info is set, without waiting for the server.
+ */
+export declare function prepareDevice(): Promise<void>;
 /** True while the device has no server ids, so nothing can be sent yet. */
 export declare function needsDevice(): boolean;
 /**

package/dist/cjs/device/index.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @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');
@@ -6,6 +6,7 @@ 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 locks = require('../core/locks.js');
 var env = require('../core/env.js');
 var consent = require('../core/consent.js');
 var transport = require('../core/transport.js');
@@ -95,7 +96,11 @@ function checkAndUpdateDeviceInfo() {
         // appreleaseversionid from app/addversion
         modelid: storage.getKeyFromDeviceInfo('modelid'), // no i18n
         appreleaseversionid: storage.getKeyFromDeviceInfo('appreleaseversionid'), // no i18n
-        timezone: env.getTimeZone()
+        timezone: env.getTimeZone(),
+        // kept here rather than as keys of their own: the id the browser is registered under, and
+        // whether it has had a session (a session's firstsession says so)
+        uuid: state._ZAP._uuid || storage.getKeyFromDeviceInfo('uuid'), // no i18n
+        hadsession: storage.getKeyFromDeviceInfo('hadsession') === true ? true : undefined, // no i18n
     };
     // the rebuild above starts from browser facts, so the ids app/addversion returned are put
     // back before anything is stored or compared
@@ -143,7 +148,7 @@ function addOrUpdateDeviceID(device_info, previous) {
  * out as an empty header.
  */
 const DEVICE_RESPONSE_KEYS = ['deviceid', 'anonymousid', 'aaid', 'apid', 'mapid', 'appversionid', 'osversionid', 'timezoneid', 'platformid', 'devicetypeid', 'modelid']; // no i18n
-/** Copies server-assigned ids into state and persists device info. */
+/** Copies server-assigned ids into state and persists device info; resolves once it is stored. */
 function applyDeviceResponse(data) {
     DEVICE_RESPONSE_KEYS.forEach(function (key) {
         // an id the answer does not mention is one we already hold, or one we never had:
@@ -159,12 +164,81 @@ function applyDeviceResponse(data) {
     if (!utils.isEmpty(data.mapid)) {
         state._ZAP._mapid = data.mapid;
     }
-    // Update the new device info into the localstorage
-    storage.user_defaults.add('device_info', state._ZAP._device_info); // no i18n
+    // stored before the registration counts as done, so another tab waiting to register reads it
+    return storage.user_defaults.save('device_info', state._ZAP._device_info); // no i18n
+}
+/**
+ * The browser's uuid: the one in storage, or a new one stored now. Every tab of the site uses the
+ * same one, because the device is registered under it.
+ */
+function useStoredUuid() {
+    // kept in device_info: it is the id this browser is registered under
+    var uuid = storage.getKeyFromDeviceInfo('uuid'); // no i18n
+    if (utils.isEmpty(uuid)) {
+        uuid = utils.getNewUUID();
+        storage.setDeviceInfoKey('uuid', uuid); // no i18n
+    }
+    state._ZAP._uuid = uuid;
+}
+/**
+ * The ids another tab of this site registered after this one loaded its settings: those are in
+ * storage but not in this tab's copy. Resolves with them, applied to this tab, or null when the
+ * browser is still unregistered and this tab has to register it.
+ */
+function adoptRegisteredDevice() {
+    return storage.reloadSettings(['device_info']).then(function () {
+        var stored = storage.user_defaults.item('device_info') || {}; // no i18n
+        if (utils.isEmpty(stored.deviceid) || utils.isEmpty(stored.anonymousid)) {
+            return null;
+        }
+        // the device is registered under the uuid the other tab sent
+        if (!utils.isEmpty(stored.uuid)) {
+            state._ZAP._uuid = stored.uuid;
+        }
+        logger.Console.log('registerDeviceWithApptics: another tab registered this browser, using its device ' + stored.deviceid); // no i18n
+        return applyDeviceResponse(stored).then(function () {
+            return { result: 'success', data: stored }; // no i18n
+        });
+    });
+}
+/**
+ * Sets up this browser's device at start-up: the uuid, the device info, and a registration when
+ * the browser has none.
+ *
+ * Settings are this tab's own copy, loaded when it started. On a browser with no device yet, two
+ * tabs started together would each register it and store two devices, so the first visit runs
+ * under a lock shared by every tab of the site: the tab that gets it re-reads storage, registers
+ * only when no other tab has, and keeps the lock until the new ids are stored. The next tab then
+ * finds them. Start-up goes on as soon as the device info is set, without waiting for the server.
+ */
+function prepareDevice() {
+    var cached = storage.user_defaults.item('device_info') || {}; // no i18n
+    if (!utils.isEmpty(cached.deviceid) && !utils.isEmpty(cached.anonymousid)) {
+        useStoredUuid();
+        checkAndUpdateDeviceInfo();
+        return Promise.resolve();
+    }
+    return new Promise(function (resolve) {
+        locks.withLock('device', function () {
+            return storage.reloadSettings(['device_info']).then(function () {
+                useStoredUuid();
+                checkAndUpdateDeviceInfo();
+                resolve();
+                // held until a registration this started is stored, or has failed
+                return deviceReady();
+            });
+        }).catch(function (err) {
+            logger.Console.log('prepareDevice: ' + err); // no i18n
+        }).then(function () {
+            resolve();
+        });
+    });
 }
 /** True while the device has no server ids, so nothing can be sent yet. */
 function needsDevice() {
-    return utils.isEmpty(transport.getHeaderParams('apid')) && utils.isEmpty(transport.getHeaderParams('mapid')); // no i18n
+    // the app ids from app/addversion, and the deviceid from device/add: either missing, and the
+    // device is registered before anything stored is sent
+    return (utils.isEmpty(transport.getHeaderParams('apid')) && utils.isEmpty(transport.getHeaderParams('mapid'))) || !transport.hasDeviceId(); // no i18n
 }
 /**
  * Resolves once a registration that is in flight has settled, succeeded or not, and right away
@@ -197,8 +271,8 @@ function registerDeviceWithApptics() {
         return blocked;
     }
     if (!state._ZAP._token) {
-        logger.Console.warn(label + ': You must call apptics.init() first'); // no i18n
-        return Promise.reject(label + ': You must call apptics.init() first'); // no i18n
+        logger.Console.warn(label + ': You must call Apptics.init() first'); // no i18n
+        return Promise.reject(label + ': You must call Apptics.init() first'); // no i18n
     }
     var offline = transport.rejectIfOffline(label);
     if (offline) {
@@ -215,13 +289,21 @@ function registerDeviceWithApptics() {
             return;
         }
         state._ZAP._regDeviceSending = true;
-        var payload = deviceBody(state._ZAP._device_info);
-        // device/add is the one url that allows all four: zak and uuid identify the caller,
-        // apid and mapid the app. app/addversion has already answered with apid and mapid by
-        // the time registration runs, so the first call can carry them like every later one.
-        var headers = { zak: transport.getHeaderParams('zak'), uuid: transport.getHeaderParams('uuid'), ...transport.apiHeaders() }; // no i18n
-        transport.postToApptics('regdevice', payload, headers, label).then(function (result) {
-            applyDeviceResponse(result.data || {});
+        adoptRegisteredDevice().then(function (adopted) {
+            if (adopted) {
+                return adopted;
+            }
+            var payload = deviceBody(state._ZAP._device_info);
+            // device/add is the one url that allows all four: zak and uuid identify the caller,
+            // apid and mapid the app. app/addversion has already answered with apid and mapid by
+            // the time registration runs, so the first call can carry them like every later one.
+            var headers = { zak: transport.getHeaderParams('zak'), uuid: transport.getHeaderParams('uuid'), ...transport.apiHeaders() }; // no i18n
+            return transport.postToApptics('regdevice', payload, headers, label).then(function (result) {
+                return applyDeviceResponse(result.data || {}).then(function () {
+                    return result;
+                });
+            });
+        }).then(function (result) {
             settleRegistration(true, result);
             resolve(result);
             // first visit: the ids exist now, so fetch the server settings right away
@@ -257,7 +339,9 @@ function getUpdatesFromServer() {
     return transport.postToApptics('sdkconfig', '', transport.apiHeaders(), label).then(function (result) {
         var data = result.data || {};
         applyServerFlags(data);
-        storage.user_defaults.add('trackinfo', state._ZAP._trackinfo); // no i18n
+        // the visitor's tracking status lives in trackinfo too, and is not the server's to replace
+        var saved = storage.storedTrackingStatus();
+        storage.user_defaults.add('trackinfo', saved === undefined ? state._ZAP._trackinfo : Object.assign({}, state._ZAP._trackinfo, { tracking_status: saved })); // no i18n
         logger.Console.log('getUpdatesFromServer: ' + JSON.stringify(state._ZAP._trackinfo)); // no i18n
         return data;
     });
@@ -316,10 +400,18 @@ function applyServerFlags(data) {
         state._ZAP._remoteLoggerEnabled = data.remoteloggerenabled !== false;
         state._ZAP._feedbackEnabled = data.feedbackenabled !== false;
     }
+    // screen recording, set up in the console: everything the form needs comes from here
     var quartz = (data.quartz && typeof data.quartz === 'object' ? data.quartz : {});
-    state._ZAP._quartzEnabled = quartz.hasOwnProperty('quartz_enabled') // no i18n
-        ? quartz.quartz_enabled !== false
-        : data.quartzenabled !== false;
+    var text = function (value) {
+        return typeof value === 'string' ? value.trim() : ''; // no i18n
+    };
+    state._ZAP._quartz = {
+        enabled: quartz.hasOwnProperty('quartz_enabled') ? quartz.quartz_enabled === true : data.quartzenabled === true, // no i18n
+        workspace: text(quartz.quartz_workspace),
+        department: text(quartz.quartz_department),
+        domain: text(quartz.quartz_domain),
+        cdnUrl: text(quartz.quartz_cdn_url),
+    };
     // when to ask again, which replaces polling on a fixed interval
     if (typeof data.next_check_after === 'number' && data.next_check_after > 0) {
         state._ZAP._nextConfigCheck = data.next_check_after;
@@ -330,7 +422,14 @@ function applyServerFlags(data) {
         heatmaptracking: state._ZAP._heatmapTracking,
         remoteloggerenabled: state._ZAP._remoteLoggerEnabled,
         feedbackenabled: state._ZAP._feedbackEnabled,
-        quartzenabled: state._ZAP._quartzEnabled,
+        // in the server's own shape, so restoring it on the next visit reads it the same way
+        quartz: {
+            quartz_enabled: state._ZAP._quartz.enabled,
+            quartz_workspace: state._ZAP._quartz.workspace,
+            quartz_department: state._ZAP._quartz.department,
+            quartz_domain: state._ZAP._quartz.domain,
+            quartz_cdn_url: state._ZAP._quartz.cdnUrl,
+        },
         shouldtrack: state._ZAP._shouldTrack,
         next_check_after: state._ZAP._nextConfigCheck
     };
@@ -366,6 +465,7 @@ exports.checkAndUpdateDeviceInfo = checkAndUpdateDeviceInfo;
 exports.deviceReady = deviceReady;
 exports.getUpdatesFromServer = getUpdatesFromServer;
 exports.needsDevice = needsDevice;
+exports.prepareDevice = prepareDevice;
 exports.refreshServerSettings = refreshServerSettings;
 exports.registerDeviceWithApptics = registerDeviceWithApptics;
 exports.restoreServerSettings = restoreServerSettings;

package/dist/cjs/engagement/api-rules.d.ts

@@ -1,62 +1,34 @@
-/**
- * What API tracking records, and under what name — Android's AppticsApiTracker.configure, built
- * with ApiTrackingBuilder the way user properties are built with UserBuilder:
- *
- *   configureApiTracking(new ApiTrackingBuilder()
- *       .allowOnlyDomains('api.zylker.com', 'api.zylker.in')
- *       .groupDomains('api.zylker.*')
- *       .ignoreEndpoint('/health', '/internal/**')
- *       .addPattern('/v2/catalog/{categoryId}/items/{itemId}')
- *       .build());
- *
- * Two jobs. Filtering decides whether a call is recorded at all: ignore rules first, and they
- * always win, then the allow lists. Normalization decides the path it is recorded under, so that
- * `/users/42/orders` and `/users/43/orders` are one endpoint on the console rather than two: the
- * query string goes, an explicit pattern is used when one matches, and otherwise numeric ids,
- * UUIDs and JWTs become `*`.
- *
- * Both apply to every call, the ones the fetch/XHR wrappers catch and the ones the app reports
- * with trackApi() or startTrackApi(), so one set of rules decides what the API page shows.
- */
 /** The rules, as ApiTrackingBuilder.build() returns them. Every list may be empty. */
 export interface ApiTrackingConfig {
-    ignoreDomains: string[];
-    allowOnlyDomains: string[];
-    allowOnlyTLDs: string[];
-    ignoreTLDs: string[];
-    ignoreDomainPrefixes: string[];
-    ignoreDomainSuffixes: string[];
-    groupDomains: string[];
-    ignoreEndpoints: string[];
-    patterns: string[];
-    preserveSegments: string[];
-    autoDetection: boolean;
+    /** URLs recorded, exactly; with any allow rule, only calls matching one are recorded. */
+    allowEquals: string[];
+    /** URLs never recorded, exactly. */
+    ignoreEquals: string[];
+    /** Regular expressions a recorded URL may match; with any allow rule, it must match one. */
+    allowRegex: RegExp[];
+    /** Regular expressions whose URLs are never recorded. */
+    ignoreRegex: RegExp[];
 }
-/** Builds the rules for configureApiTracking, with AppticsApiTracker.configure's names. */
+/**
+ * A URL as the rules compare it: `scheme://host[:port]/path`, the scheme and host lower-cased,
+ * the default port dropped, the query, fragment and a trailing slash removed. '' when it is not
+ * an absolute http(s) URL.
+ */
+export declare function ruleUrl(raw: string): string;
+/**
+ * Builds the rules configure takes. Each method may be called more than once, and takes any number
+ * of values: `new ApiTrackingBuilder().allowEquals(a, b).ignoreRegex(/x/).build()`.
+ */
 export declare class ApiTrackingBuilder {
     private rules;
-    /** Never records these hosts. */
-    ignoreDomains(...domains: string[]): this;
-    /** Records only these hosts; every other is skipped. */
-    allowOnlyDomains(...domains: string[]): this;
-    /** Records only hosts ending in these TLDs, e.g. `.com`. */
-    allowOnlyTLDs(...tlds: string[]): this;
-    /** Never records hosts ending in these TLDs, e.g. `.local`. */
-    ignoreTLDs(...tlds: string[]): this;
-    /** Never records hosts starting with these, e.g. `dev.`. */
-    ignoreDomainPrefixes(...prefixes: string[]): this;
-    /** Never records hosts ending with these, e.g. `.cdn.net`. */
-    ignoreDomainSuffixes(...suffixes: string[]): this;
-    /** Records the hosts a pattern such as `api.myapp.*` matches under that one name. */
-    groupDomains(...patterns: string[]): this;
-    /** Never records these paths: exact, `*` or `{name}` for one segment, `**` at the end for a prefix. */
-    ignoreEndpoint(...paths: string[]): this;
-    /** Records a path this pattern matches as the pattern, with each `{name}` as `*`. Tried before auto-detection. */
-    addPattern(...patterns: string[]): this;
-    /** Segments never turned into `*`, e.g. `v1` or `404`. */
-    preserveSegments(...segments: string[]): this;
-    /** `false`: only addPattern paths are normalized; every other path is recorded as it is. */
-    autoDetection(enabled: boolean): this;
+    /** Records only these URLs (and those any allowRegex matches): `https://api.example.com/orders`. */
+    allowEquals(...urls: string[]): this;
+    /** Never records these URLs: `https://api.example.com/health`. */
+    ignoreEquals(...urls: string[]): this;
+    /** Records only URLs these match (and those any allowEquals names): `/^https:\/\/api\.example\.com\//`. */
+    allowRegex(...patterns: Array<RegExp | string>): this;
+    /** Never records URLs these match: `/\/internal\//`. */
+    ignoreRegex(...patterns: Array<RegExp | string>): this;
     build(): ApiTrackingConfig;
 }
 /**
@@ -66,19 +38,12 @@ export declare class ApiTrackingBuilder {
 export declare function configureApiTracking(config: ApiTrackingConfig | ApiTrackingBuilder): void;
 /** The rules in force, for tests and the playground. */
 export declare function apiTrackingConfig(): ApiTrackingConfig;
-/** Whether calls to this host are recorded. Ignore rules are checked first and always win. */
-export declare function hostAllowed(hostname: string): boolean;
-/** The name a host is recorded under: the first groupDomains pattern it matches, or itself. */
-export declare function groupedHost(hostname: string): string;
-/** Whether a host is one of the groupDomains names, which carry a `*` no real host has. */
-export declare function isGroupedHost(hostname: string): boolean;
-/** The path without its query string or fragment, which is where ids and tokens travel. */
-export declare function withoutQuery(path: string): string;
-/** Whether ignoreEndpoint leaves this path out. Matched on the path as called, query removed. */
-export declare function endpointIgnored(path: string): boolean;
 /**
- * The path a call is recorded under. The query goes; then the first addPattern that matches is
- * used, with each `{name}` as `*` (the server's path rule has no room for braces); otherwise, with
- * autoDetection on, numeric ids, UUIDs and JWTs become `*`, except preserveSegments.
+ * Whether a call to `url` is recorded. Ignore rules are tried first and always win; then, when
+ * there are allow rules, the URL must match one. A URL that cannot be read is not recorded.
  */
+export declare function urlTracked(url: string): boolean;
+/** The path without its query string or fragment, which is where ids and tokens travel. */
+export declare function withoutQuery(path: string): string;
+/** The path a call is recorded under: the query goes, and numeric ids, UUIDs and JWTs become `*`. */
 export declare function normalizeApiPath(path: string): string;