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

package/dist/esm/lifecycle.js

@@ -0,0 +1,534 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { REQUIRED_CONFIG, AP_CONFIG, CONFIG_ALIASES, DEFAULT_INACTIVE_MINUTES } from './core/constants.js';
+import { _ZAP } from './core/state.js';
+import { warnAlways, Console } from './core/logger.js';
+import { isEmpty, getNewUUID, isSuccess } from './core/utils.js';
+import { storageReady, user_defaults, tracking_preference, engagement_transactions, error_transactions } from './core/storage.js';
+import { hooks } from './core/hooks.js';
+import { applyDebugConfig } from './core/debug.js';
+import { getConnectionType, getOrientation } from './core/env.js';
+import { getTrackingStatus } from './core/consent.js';
+import { restoreServerSettings, checkAndUpdateDeviceInfo, refreshServerSettings, updateDeviceWithApptics, needsDevice, deviceReady } from './device/index.js';
+import { registerAppVersion, clearAppVersion } from './device/appversion.js';
+import { checkAndUpdateSession, updateLastActiveTimeOfSession, updateScreenWithEndtime, endCurrentSession } from './engagement/session.js';
+import { enableApiTracking } from './engagement/auto-api.js';
+import { enableScreenTracking } from './engagement/auto-screen.js';
+import { resumeScreen, trackEvent } from './engagement/track.js';
+import { trackError } from './errors/track.js';
+import { startTimers, flush, stopTimers } from './scheduler.js';
+import './remotelog/index.js';
+import { getUserInfo } from './user/index.js';
+import { clearAttempts } from './core/attempts.js';
+import { sendStoredLogs, forgetStoredLogs } from './remotelog/send.js';
+
+let listenersAttached = false;
+/** The config init() was last called with; reset() starts again from it. */
+let lastConfig = null;
+/** Bumped by every init(); a start() from an earlier init() that was reset in between does nothing. */
+let generation = 0;
+function isBrowser() {
+    if (typeof window === 'undefined' || typeof document === 'undefined' || typeof Promise === 'undefined') { // no i18n
+        return false;
+    }
+    try {
+        return typeof indexedDB !== 'undefined' || !!window.localStorage; // no i18n
+    }
+    catch (err) {
+        return false; // storage access can throw in sandboxed frames
+    }
+}
+/**
+ * Canonical config: serviceUrl, zak, identifier, appversion.
+ * The console snippet uses older names (base_domain, token), which are accepted here.
+ * serviceUrl loses any trailing slash, because request paths add their own.
+ */
+function normaliseConfig(config) {
+    var settings = Object.assign({}, config);
+    Object.keys(CONFIG_ALIASES).forEach(function (key) {
+        if (isEmpty(settings[key]) && !isEmpty(settings[CONFIG_ALIASES[key]])) {
+            settings[key] = settings[CONFIG_ALIASES[key]];
+        }
+    });
+    if (!isEmpty(settings.serviceUrl)) {
+        settings.serviceUrl = String(settings.serviceUrl).replace(/\/+$/, ''); // no i18n
+    }
+    settings.appversion = appVersionText(settings.appversion);
+    return settings;
+}
+/**
+ * The version as the text it is stored and sent as: a string trimmed, a finite number as its digits.
+ * Anything else — blank, NaN, an object — is '', which init() reports as missing.
+ */
+function appVersionText(value) {
+    if (typeof value === 'number') { // no i18n
+        return isFinite(value) ? String(value) : ''; // no i18n
+    }
+    return typeof value === 'string' ? value.trim() : ''; // no i18n
+}
+/**
+ * The placeholders the console's snippets and the docs show for appversion. Starting with one
+ * would register a version that was never shipped, and every visit after it would report under it.
+ */
+const APPVERSION_PLACEHOLDERS = ['YOUR_APP_VERSION', 'YOUR_BUILD_OR_APP_VERSION', 'YOUR_APPVERSION']; // no i18n
+function isAppVersionPlaceholder(version) {
+    return APPVERSION_PLACEHOLDERS.indexOf(version.toUpperCase()) !== -1;
+}
+/** Which app this browser's stored data belongs to, before app/addversion has named it. */
+function appKey(settings) {
+    return settings.serviceUrl + '|' + settings.identifier; // no i18n
+}
+/**
+ * Data stored for another app on this origin is discarded before anything else reads it,
+ * including the stored app/addversion answer that would otherwise hand out that app's ids.
+ */
+function discardOtherAppData(settings) {
+    var stored = user_defaults.item('appkey'); // no i18n
+    if (!isEmpty(stored) && stored !== appKey(settings)) {
+        Console.log('init: stored data belongs to another app, resetting'); // no i18n
+        clearStorage();
+    }
+    user_defaults.add('appkey', appKey(settings)); // no i18n
+}
+/**
+ * Timing an app may tune in init(). Each has a range: a value outside it is ignored with a
+ * warning rather than applied, since a 10 ms flush interval would hammer the server.
+ */
+const TUNABLE = Object.freeze([
+    { key: 'batch_flush_interval', min: 1000, max: 3600000 }, // no i18n
+    { key: 'getupdates_interval', min: 10000, max: 86400000 }, // no i18n
+    { key: 'batch_size', min: 1, max: 500 }, // no i18n
+    { key: 'batch_request_timeout', min: 1, max: 30 }, // no i18n
+    { key: 'min_session_duration', min: 0, max: 60000 }, // no i18n
+    { key: 'heatmap_max_per_session', min: 0, max: 10000 }, // no i18n
+]);
+/** Reads the tunable timings out of the config. Anything missing goes back to its default. */
+function applyIntervals(config) {
+    TUNABLE.forEach(function (rule) {
+        var value = config[rule.key];
+        // every init() decides these on its own, so a value from an earlier one never lingers
+        _ZAP._config[rule.key] = AP_CONFIG[rule.key];
+        if (isEmpty(value)) {
+            return;
+        }
+        var num = Number(value);
+        if (!isFinite(num) || num < rule.min || num > rule.max) {
+            warnAlways('Apptics.init: ' + rule.key + ' must be between ' + rule.min + ' and ' + rule.max + ', keeping ' + _ZAP._config[rule.key]); // no i18n
+            return;
+        }
+        _ZAP._config[rule.key] = num;
+        Console.log('Apptics.init: ' + rule.key + ' set to ' + num); // no i18n
+    });
+    // inactiveduration lives on state, not in _config
+    _ZAP.inactiveduration = DEFAULT_INACTIVE_MINUTES;
+    if (!isEmpty(config.inactiveduration)) {
+        var minutes = Number(config.inactiveduration);
+        if (!isFinite(minutes) || minutes < 1 || minutes > 1440) {
+            warnAlways('Apptics.init: inactiveduration must be between 1 and 1440 minutes, keeping ' + _ZAP.inactiveduration); // no i18n
+        }
+        else {
+            _ZAP.inactiveduration = minutes;
+            Console.log('Apptics.init: inactiveduration set to ' + minutes); // no i18n
+        }
+    }
+}
+function clearStorage() {
+    clearAttempts();
+    user_defaults.clear();
+    engagement_transactions.clear();
+    error_transactions.clear();
+}
+/**
+ * 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.
+ */
+function init(config) {
+    if (!config || typeof config !== 'object') { // no i18n
+        warnAlways('Apptics.init: a config object is required, e.g. apptics.init({ serviceUrl, zak, identifier, appversion })'); // no i18n
+        return false;
+    }
+    if (_ZAP._initialised) {
+        Console.warn('Apptics.init: already initialised; call apptics.reset() to start again'); // no i18n
+        return false;
+    }
+    if (!isBrowser()) {
+        warnAlways('Apptics.init: skipped, no browser with storage and Promise support'); // no i18n
+        return false;
+    }
+    var settings = normaliseConfig(config);
+    var missing = REQUIRED_CONFIG.filter(function (key) {
+        return isEmpty(settings[key]);
+    });
+    if (missing.length > 0) {
+        warnAlways('Apptics.init: missing required config: ' + missing.join(', ')); // no i18n
+        return false;
+    }
+    if (isAppVersionPlaceholder(settings.appversion)) {
+        warnAlways('Apptics.init: appversion is still the placeholder "' + settings.appversion // no i18n
+            + '"; replace it with your app\'s version or build number, e.g. \'2.4.0\''); // no i18n
+        return false;
+    }
+    _ZAP._defaultoptions = settings;
+    // every request goes to serviceUrl; there is no other host to learn about
+    _ZAP._defaultoptions.base_domain = settings.serviceUrl;
+    // marks the SDK as started for the checks that need it; app/addversion replaces it with aaid
+    _ZAP._token = settings.identifier;
+    // console_log: the SDK's own activity in the browser console
+    if (!isEmpty(config.console_log)) {
+        _ZAP._config.debug = !!config.console_log;
+    }
+    // track_session: false records no sessions, as Android's automaticSessionsTrackingStatus
+    _ZAP._config.track_session = typeof config.track_session === 'boolean' ? config.track_session : AP_CONFIG.track_session; // no i18n
+    // show_logs: the app's own logger lines in the browser console, as Android's showLogs
+    _ZAP._config.show_logs = typeof config.show_logs === 'boolean' ? config.show_logs : AP_CONFIG.show_logs; // no i18n
+    if (typeof config.ignore_do_not_track === 'boolean') { // no i18n
+        _ZAP._config.ignore_do_not_track = config.ignore_do_not_track;
+    }
+    // debug: debug mode, the debug endpoints. Same payloads, but the answer says where to trace the
+    // request. debug_api is its earlier name and still works; debug wins when both are given
+    _ZAP._config.debug_api = typeof config.debug === 'boolean' ? config.debug // no i18n
+        : typeof config.debug_api === 'boolean' ? config.debug_api : AP_CONFIG.debug_api; // no i18n
+    // starts (or clears) the idle hour that closes debug mode on its own
+    // an enableDebug() or disableDebug() call the app already made wins over the config
+    applyDebugConfig(_ZAP._config.debug_api);
+    // what to call this device in the debug stream; see devicename in core/transport.ts
+    _ZAP._config.device_name = typeof config.device_name === 'string' ? config.device_name : AP_CONFIG.device_name; // no i18n
+    // remote logging: the SDK's own diagnostics, sent to console/addlog
+    _ZAP._config.remote_log = AP_CONFIG.remote_log;
+    if (typeof config.remote_log === 'boolean') { // no i18n
+        _ZAP._config.remote_log = config.remote_log;
+    }
+    // automatic api tracking: the app's own requests, wrapped. Which hosts it records is
+    // configureApiTracking's to say; the two keys that once did it are refused out loud rather
+    // than quietly ignored, since an app relying on them would otherwise record hosts it meant not to
+    _ZAP._config.track_api = AP_CONFIG.track_api;
+    ['track_api_hosts', 'track_api_exclude_hosts'].forEach(function (key) {
+        if (config[key] !== undefined) {
+            warnAlways('Apptics.init: ' + key + ' is no longer supported; use configureApiTracking(new ApiTrackingBuilder().' // no i18n
+                + (key === 'track_api_hosts' ? 'allowOnlyDomains' : 'ignoreDomains') + '(...).build())'); // no i18n
+        }
+    });
+    if (typeof config.track_api === 'boolean') { // no i18n
+        _ZAP._config.track_api = config.track_api;
+    }
+    enableApiTracking(_ZAP._config.track_api);
+    // heatmap capture: a no-op unless the app imported the heatmap entry, which sets the hook
+    _ZAP._config.track_heatmap = typeof config.track_heatmap === 'boolean' // no i18n
+        ? config.track_heatmap
+        : AP_CONFIG.track_heatmap;
+    hooks.enableHeatmap(_ZAP._config.track_heatmap);
+    // automatic screen tracking, on unless the config says false: switched on by start(), once a
+    // screen view can be stored
+    _ZAP._config.track_screen = typeof config.track_screen === 'boolean' ? config.track_screen : AP_CONFIG.track_screen; // no i18n
+    applyIntervals(config);
+    lastConfig = config;
+    _ZAP._initialised = true;
+    _ZAP._ready = false;
+    _ZAP._pending = [];
+    var myGeneration = ++generation;
+    _ZAP._readyPromise = storageReady().then(function (backend) {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        if (!backend) {
+            warnAlways('Apptics.init: no usable storage (IndexedDB or localStorage), not starting'); // no i18n
+            _ZAP._initialised = false;
+            _ZAP._token = ''; // no i18n
+            _ZAP._pending = [];
+            return false;
+        }
+        discardOtherAppData(_ZAP._defaultoptions);
+        // app/addversion is the first call and everything waits on it: it is what turns the four
+        // values init() was given into aaid, the portal and project ids every url carries, and
+        // appreleaseversionid, which metaWebSDKV2 refuses a payload without
+        return registerAppVersion().then(function (registered) {
+            if (myGeneration !== generation) {
+                return false;
+            }
+            if (!registered) {
+                warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
+                _ZAP._initialised = false;
+                _ZAP._token = ''; // no i18n
+                _ZAP._pending = [];
+                return false;
+            }
+            return start(config, myGeneration);
+        });
+    }).catch(function (err) {
+        Console.error('Apptics.init: start-up failed', err); // no i18n
+        return false;
+    });
+    return true;
+}
+/** Resolves true once start-up has finished, false if init() refused or storage is unusable. */
+function ready() {
+    return _ZAP._readyPromise || Promise.resolve(false);
+}
+function start(config, myGeneration) {
+    // app/addversion named the app; data stored for another one was discarded before it ran
+    _ZAP._token = String(_ZAP._defaultoptions.aaid);
+    user_defaults.add('token', _ZAP._token); // no i18n
+    // last known server settings (getupdates) apply before anything is tracked
+    restoreServerSettings();
+    // required by init(), so _defaultoptions.appversion is always the app's own version, as the
+    // text normaliseConfig made of it: there is no default to fall back to, and the stored value
+    // below is kept only to notice when the version changes
+    var uuid = user_defaults.item('uuid'); // no i18n
+    if (isEmpty(uuid)) {
+        uuid = getNewUUID();
+        user_defaults.add('uuid', uuid); // no i18n
+    }
+    _ZAP._uuid = uuid;
+    var stored_appversion = user_defaults.item('appversion'); // no i18n
+    if (isEmpty(stored_appversion)) {
+        user_defaults.add('appversion', _ZAP._defaultoptions.appversion); // no i18n
+        stored_appversion = _ZAP._defaultoptions.appversion;
+    }
+    var appVersionChanged = stored_appversion != _ZAP._defaultoptions.appversion;
+    _ZAP._ignoreDnt = _ZAP._config.ignore_do_not_track;
+    tracking_preference.update_status(getTrackingStatus());
+    checkAndUpdateDeviceInfo();
+    // returning visit: ask the server for its settings now instead of waiting 2 minutes
+    // (first visit: device/add triggers it once the ids exist)
+    refreshServerSettings();
+    if (appVersionChanged) {
+        _ZAP._device_info.appversionid = ''; // no i18n
+        updateDeviceWithApptics(_ZAP._device_info).then(function (result) {
+            if (isSuccess(result)) {
+                user_defaults.add('appversion', _ZAP._defaultoptions.appversion); // no i18n
+                Console.log('init: appversion updated to ' + _ZAP._defaultoptions.appversion); // no i18n
+            }
+        }).catch(function (err) {
+            Console.log('init: error updating appversion: ' + err); // no i18n
+        });
+    }
+    // attempt to resolve connection type
+    _ZAP._device_info.connectionType = getConnectionType();
+    attachListeners();
+    _ZAP._properties.orientation = getOrientation();
+    getUserInfo();
+    return checkAndUpdateSession().then(function () {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        startTimers();
+        sendStoredLogs();
+        _ZAP._ready = true;
+        // replay calls made while storage was loading, in order
+        var pending = _ZAP._pending;
+        _ZAP._pending = [];
+        pending.forEach(function (call) {
+            try {
+                call();
+            }
+            catch (err) {
+                Console.error('apptics: buffered call failed', err); // no i18n
+            }
+        });
+        // after the replay, so a inScreen() the app made during start-up keeps its place, and
+        // the first automatic view is the page as it is now
+        enableScreenTracking(_ZAP._config.track_screen);
+        // a no-op unless the remote-config entry was imported, which sets the hook
+        hooks.remoteConfigStarted();
+        window.appticsReadyStatus = true;
+        if (typeof window.appticsReady == 'function') { // no i18n
+            window.appticsReady();
+        }
+        return true;
+    });
+}
+/** Clears stored identity and queues, then starts again from the snippet. */
+function reset() {
+    generation++;
+    stopTimers();
+    // the wrappers come off with everything else; the init() below puts them back if the config
+    // asked for them, so a reset that has no config to restore leaves XHR and fetch untouched
+    enableApiTracking(false);
+    enableScreenTracking(false);
+    clearAppVersion();
+    hooks.enableHeatmap(false);
+    hooks.resetHeatmap();
+    hooks.resetRemoteConfig();
+    clearStorage();
+    _ZAP._initialised = false;
+    _ZAP._ready = false;
+    _ZAP._pending = [];
+    _ZAP._readyPromise = null;
+    _ZAP._device_info = {};
+    _ZAP._user_info = {};
+    _ZAP._current_screen = {};
+    _ZAP._current_session = {};
+    _ZAP._uuid = ''; // no i18n
+    _ZAP._apid = ''; // no i18n
+    _ZAP._mapid = ''; // no i18n
+    _ZAP._sending = false;
+    Console.log('apptics.reset()'); // no i18n
+    // start again with the config init() was called with
+    if (lastConfig) {
+        init(lastConfig);
+    }
+}
+function isActive() {
+    return _ZAP._ready;
+}
+// Declarative click tracking: <el apeventaction="name" apeventprops='{"k":"v"}'> inside <el apgroupaction="group">
+function onDocumentClick(event) {
+    if (!window.appticsReadyStatus || !isActive()) {
+        return;
+    }
+    var start = event.target;
+    if (start && typeof start.closest !== 'function') { // no i18n
+        start = start.parentElement;
+    }
+    if (!start) {
+        return;
+    }
+    var targetElem = start.closest('[apeventaction]:not([apeventaction=""])'); // no i18n
+    if (!targetElem) {
+        return;
+    }
+    var eventName = targetElem.getAttribute('apeventaction') || ''; // no i18n
+    var groupElem = targetElem.closest('[apgroupaction]'); // no i18n
+    var groupName = (groupElem && groupElem.getAttribute('apgroupaction')) || AP_CONFIG.default_group_name; // no i18n
+    var eventProps = {};
+    var rawProps = targetElem.getAttribute('apeventprops'); // no i18n
+    if (!isEmpty(rawProps)) {
+        try {
+            eventProps = JSON.parse(rawProps);
+        }
+        catch (err) {
+            Console.warn('apptics: invalid JSON in apeventprops for "' + eventName + '", sending no properties'); // no i18n
+            eventProps = {};
+        }
+    }
+    if (!isEmpty(eventName)) {
+        trackEvent(eventName, groupName, eventProps);
+    }
+}
+/**
+ * Page is in the background but still there: close the open screen and send what's queued.
+ * By keepalive, because hidden is often the last moment before the tab closes, and a send still
+ * waiting on its answer would hold the queue as pagehide tries to send it.
+ */
+function onPageHidden() {
+    if (!isActive())
+        return;
+    updateScreenWithEndtime();
+    flush(true);
+    Console.log('page hidden: closing the open screen and flushing'); // no i18n
+}
+/**
+ * The tab is closing, or the page is being replaced or frozen into the back/forward cache.
+ * The session ends here, and everything queued goes out by keepalive, since a normal
+ * request would be cancelled with the page.
+ */
+function onPageClosing() {
+    if (!isActive())
+        return;
+    Console.log('page closing: ending the session and sending what is queued'); // no i18n
+    updateScreenWithEndtime();
+    forgetStoredLogs();
+    endCurrentSession().then(function () {
+        return flush(true);
+    });
+}
+function attachListeners() {
+    if (listenersAttached) {
+        return;
+    }
+    listenersAttached = true;
+    // listen for connection change events (only available in w3c implementation)
+    var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.addEventListener) {
+        connection.addEventListener('change', function () {
+            _ZAP._device_info.connectionType = getConnectionType();
+        });
+    }
+    // Track when the window loses focus (user switches to another window or application)
+    window.addEventListener('blur', function () {
+        if (!isActive())
+            return;
+        Console.log('Window lost focus, user switched to another window or application'); // no i18n
+        updateLastActiveTimeOfSession();
+    });
+    // Track when the window gains focus (user switches back to the window)
+    window.addEventListener('focus', function () {
+        if (!isActive())
+            return;
+        Console.log('Window regained focus, user switched back to the window'); // no i18n
+        checkAndUpdateSession();
+        startTimers();
+    });
+    // IndexedDB writes are async, so unload work starts on pagehide rather than beforeunload
+    window.addEventListener('pagehide', onPageClosing); // no i18n
+    // back/forward cache: pagehide ended the session, so coming back starts a new one
+    window.addEventListener('pageshow', function (event) {
+        if (!isActive() || !event.persisted)
+            return;
+        Console.log('restored from the back/forward cache: starting a new session'); // no i18n
+        // the screen the page was left on starts a new view, in the new session
+        checkAndUpdateSession().then(resumeScreen);
+        startTimers();
+    });
+    document.addEventListener('visibilitychange', function () {
+        if (!isActive())
+            return;
+        if (document.visibilityState === 'hidden') { // no i18n
+            onPageHidden();
+            return;
+        }
+        // back in view: the server's tracking flags may have changed while we were away
+        Console.log('page visible: refreshing the server settings'); // no i18n
+        // hiding ended the screen view; the screen the user is back on starts a new one, after the
+        // session is settled so the view belongs to the right one
+        checkAndUpdateSession().then(resumeScreen);
+        refreshServerSettings();
+    });
+    // if we are running in cordova use ondeviceready otherwise onload
+    window.addEventListener(window.cordova ? 'deviceready' : 'load', function () {
+        if (isActive())
+            checkAndUpdateSession();
+    }, { passive: true });
+    // Always send pending requests when the connection comes back online
+    window.addEventListener('online', function () {
+        if (!isActive())
+            return;
+        // a first visit that started offline has no device ids yet, and nothing can be sent
+        // until it has them: register before flushing, and flush once that has landed
+        if (needsDevice()) {
+            Console.log('back online: registering this device before sending'); // no i18n
+            checkAndUpdateDeviceInfo();
+            deviceReady().then(function () {
+                if (!isActive())
+                    return;
+                flush();
+                // the lines logged while offline are waiting too, and log/add needs the same ids
+                sendStoredLogs();
+            });
+            return;
+        }
+        flush();
+        sendStoredLogs();
+    }, { passive: true });
+    if (window.screen && window.screen.orientation && typeof window.screen.orientation.addEventListener === 'function') { // no i18n
+        window.screen.orientation.addEventListener('change', function () {
+            _ZAP._properties.orientation = getOrientation();
+        });
+    }
+    window.addEventListener('unhandledrejection', function (event) {
+        if (isActive() && _ZAP._isGlobalErrorTracking) {
+            trackError(event);
+        }
+    });
+    window.addEventListener('error', function (event) {
+        if (isActive() && _ZAP._isGlobalErrorTracking) {
+            trackError(event);
+        }
+    });
+    window.addEventListener('click', onDocumentClick, true); // no i18n
+}
+
+export { init, ready, reset };

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/remoteconfig/custom.d.ts

@@ -0,0 +1,10 @@
+/** The value set for a custom criteria key, or undefined when none is. */
+export declare function customConditionValue(key: string): string | undefined;
+/**
+ * Sets what this device is for a custom criteria, or removes it with an empty value. Re-applies
+ * the stored rules as soon as storage is ready, so the next read sees the new result without a
+ * fetch.
+ */
+export declare function setCustomConditionValue(key: string, value: string | number | boolean | null | undefined): void;
+/** reset(): forgets the values set on this page; the stored ones go with the rest of storage. */
+export declare function clearCustomConditionValues(): void;

package/dist/esm/remoteconfig/custom.js

@@ -0,0 +1,74 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { user_defaults, storageReady } from '../core/storage.js';
+import { Console } from '../core/logger.js';
+import { reresolve } from './store.js';
+
+/**
+ * Custom condition values, as Android's AppticsRemoteConfig.setCustomConditionValue: the app says
+ * what this device is for a custom criteria the console defines (a condition key with a list of
+ * values), and a condition on that key matches when the value set here is one of the listed ones.
+ *
+ *   AppticsRemoteConfig.setCustomConditionValue('plan_tier', 'gold');
+ *
+ * The rules are evaluated on the device, so the values have to be here on the next visit too:
+ * they are stored, and a value set on this page wins over a stored one. Setting one before
+ * storage has loaded — before init(), say — is kept in memory and saved once it has.
+ *
+ * Assumed wire format, until the server confirms it: a custom criteria arrives with the custom
+ * key as its `key` and operator 1 ("is one of"), the same shape as the built-in criteria. A
+ * different shape fails closed — the condition does not match and the default is used.
+ */
+const STORE_KEY = 'remoteconfig_custom'; // no i18n
+/** This page's values; null marks a key removed here, so a stored value no longer counts. */
+var mine = {};
+function stored() {
+    var saved = user_defaults.item(STORE_KEY);
+    return saved && typeof saved === 'object' ? saved : {}; // no i18n
+}
+/** The value set for a custom criteria key, or undefined when none is. */
+function customConditionValue(key) {
+    if (Object.prototype.hasOwnProperty.call(mine, key)) {
+        var here = mine[key];
+        return here === null ? undefined : here;
+    }
+    var saved = stored();
+    return Object.prototype.hasOwnProperty.call(saved, key) ? saved[key] : undefined;
+}
+/**
+ * Sets what this device is for a custom criteria, or removes it with an empty value. Re-applies
+ * the stored rules as soon as storage is ready, so the next read sees the new result without a
+ * fetch.
+ */
+function setCustomConditionValue(key, value) {
+    var name = typeof key === 'string' ? key.trim() : ''; // no i18n
+    if (name === '') { // no i18n
+        Console.warn('AppticsRemoteConfig.setCustomConditionValue: a condition key is required'); // no i18n
+        return;
+    }
+    var text = value === null || value === undefined ? '' : String(value).trim(); // no i18n
+    mine[name] = text === '' ? null : text; // no i18n
+    storageReady().then(function (backend) {
+        if (!backend) {
+            return;
+        }
+        var saved = stored();
+        Object.keys(mine).forEach(function (one) {
+            var here = mine[one];
+            if (here === null || here === undefined) {
+                delete saved[one];
+            }
+            else {
+                saved[one] = here;
+            }
+        });
+        user_defaults.add(STORE_KEY, saved);
+        // only once storage has loaded: re-resolving before it would read an empty rule set and keep it
+        reresolve();
+    });
+}
+/** reset(): forgets the values set on this page; the stored ones go with the rest of storage. */
+function clearCustomConditionValues() {
+    mine = {};
+}
+
+export { clearCustomConditionValues, customConditionValue, setCustomConditionValue };

package/dist/esm/remoteconfig/evaluate.d.ts

@@ -0,0 +1,24 @@
+import type { Dict } from '../types.js';
+/** Forgets what has been complained about, so a new rule set is judged afresh. */
+export declare function resetEvaluationWarnings(): void;
+/**
+ * Whether a condition holds: every one of its criteria must. The template requires at least one
+ * (`array-size=">=1"`), so a condition with none is malformed and does not match — rather than
+ * matching vacuously, which would apply it to every device.
+ */
+export declare function conditionMatches(condition: Dict): boolean;
+/**
+ * The value of one parameter on this device, as the string the server stores it as.
+ *
+ * `byId` is every condition the answer carried, keyed by its id — the mapping on the parameter
+ * names a condition but does not repeat its criteria.
+ */
+export declare function resolve(parameter: Dict, byId: Record<string, Dict>): string;
+/**
+ * Every parameter resolved against this device, as a flat name -> value map.
+ *
+ * Built in one pass and kept, rather than resolved per read: the rule set only changes when a
+ * fetch brings a new one, and an app reading twenty flags during a render should not walk every
+ * condition twenty times.
+ */
+export declare function resolveAll(remoteconfig: Dict): Record<string, string>;