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

package/dist/cjs/lifecycle.js

@@ -0,0 +1,538 @@
+/*! @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 hooks = require('./core/hooks.js');
+var debug = require('./core/debug.js');
+var env = require('./core/env.js');
+var consent = require('./core/consent.js');
+var index = require('./device/index.js');
+var appversion = require('./device/appversion.js');
+var session = require('./engagement/session.js');
+var autoApi = require('./engagement/auto-api.js');
+var autoScreen = require('./engagement/auto-screen.js');
+var track = require('./engagement/track.js');
+var track$1 = require('./errors/track.js');
+var scheduler = require('./scheduler.js');
+require('./remotelog/index.js');
+var index$1 = require('./user/index.js');
+var attempts = require('./core/attempts.js');
+var send = require('./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(constants.CONFIG_ALIASES).forEach(function (key) {
+        if (utils.isEmpty(settings[key]) && !utils.isEmpty(settings[constants.CONFIG_ALIASES[key]])) {
+            settings[key] = settings[constants.CONFIG_ALIASES[key]];
+        }
+    });
+    if (!utils.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 = storage.user_defaults.item('appkey'); // no i18n
+    if (!utils.isEmpty(stored) && stored !== appKey(settings)) {
+        logger.Console.log('init: stored data belongs to another app, resetting'); // no i18n
+        clearStorage();
+    }
+    storage.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
+        state._ZAP._config[rule.key] = constants.AP_CONFIG[rule.key];
+        if (utils.isEmpty(value)) {
+            return;
+        }
+        var num = Number(value);
+        if (!isFinite(num) || num < rule.min || num > rule.max) {
+            logger.warnAlways('Apptics.init: ' + rule.key + ' must be between ' + rule.min + ' and ' + rule.max + ', keeping ' + state._ZAP._config[rule.key]); // no i18n
+            return;
+        }
+        state._ZAP._config[rule.key] = num;
+        logger.Console.log('Apptics.init: ' + rule.key + ' set to ' + num); // no i18n
+    });
+    // inactiveduration lives on state, not in _config
+    state._ZAP.inactiveduration = constants.DEFAULT_INACTIVE_MINUTES;
+    if (!utils.isEmpty(config.inactiveduration)) {
+        var minutes = Number(config.inactiveduration);
+        if (!isFinite(minutes) || minutes < 1 || minutes > 1440) {
+            logger.warnAlways('Apptics.init: inactiveduration must be between 1 and 1440 minutes, keeping ' + state._ZAP.inactiveduration); // no i18n
+        }
+        else {
+            state._ZAP.inactiveduration = minutes;
+            logger.Console.log('Apptics.init: inactiveduration set to ' + minutes); // no i18n
+        }
+    }
+}
+function clearStorage() {
+    attempts.clearAttempts();
+    storage.user_defaults.clear();
+    storage.engagement_transactions.clear();
+    storage.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
+        logger.warnAlways('Apptics.init: a config object is required, e.g. apptics.init({ serviceUrl, zak, identifier, appversion })'); // no i18n
+        return false;
+    }
+    if (state._ZAP._initialised) {
+        logger.Console.warn('Apptics.init: already initialised; call apptics.reset() to start again'); // no i18n
+        return false;
+    }
+    if (!isBrowser()) {
+        logger.warnAlways('Apptics.init: skipped, no browser with storage and Promise support'); // no i18n
+        return false;
+    }
+    var settings = normaliseConfig(config);
+    var missing = constants.REQUIRED_CONFIG.filter(function (key) {
+        return utils.isEmpty(settings[key]);
+    });
+    if (missing.length > 0) {
+        logger.warnAlways('Apptics.init: missing required config: ' + missing.join(', ')); // no i18n
+        return false;
+    }
+    if (isAppVersionPlaceholder(settings.appversion)) {
+        logger.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;
+    }
+    state._ZAP._defaultoptions = settings;
+    // every request goes to serviceUrl; there is no other host to learn about
+    state._ZAP._defaultoptions.base_domain = settings.serviceUrl;
+    // marks the SDK as started for the checks that need it; app/addversion replaces it with aaid
+    state._ZAP._token = settings.identifier;
+    // console_log: the SDK's own activity in the browser console
+    if (!utils.isEmpty(config.console_log)) {
+        state._ZAP._config.debug = !!config.console_log;
+    }
+    // track_session: false records no sessions, as Android's automaticSessionsTrackingStatus
+    state._ZAP._config.track_session = typeof config.track_session === 'boolean' ? config.track_session : constants.AP_CONFIG.track_session; // no i18n
+    // show_logs: the app's own logger lines in the browser console, as Android's showLogs
+    state._ZAP._config.show_logs = typeof config.show_logs === 'boolean' ? config.show_logs : constants.AP_CONFIG.show_logs; // no i18n
+    if (typeof config.ignore_do_not_track === 'boolean') { // no i18n
+        state._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
+    state._ZAP._config.debug_api = typeof config.debug === 'boolean' ? config.debug // no i18n
+        : typeof config.debug_api === 'boolean' ? config.debug_api : constants.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
+    debug.applyDebugConfig(state._ZAP._config.debug_api);
+    // what to call this device in the debug stream; see devicename in core/transport.ts
+    state._ZAP._config.device_name = typeof config.device_name === 'string' ? config.device_name : constants.AP_CONFIG.device_name; // no i18n
+    // remote logging: the SDK's own diagnostics, sent to console/addlog
+    state._ZAP._config.remote_log = constants.AP_CONFIG.remote_log;
+    if (typeof config.remote_log === 'boolean') { // no i18n
+        state._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
+    state._ZAP._config.track_api = constants.AP_CONFIG.track_api;
+    ['track_api_hosts', 'track_api_exclude_hosts'].forEach(function (key) {
+        if (config[key] !== undefined) {
+            logger.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
+        state._ZAP._config.track_api = config.track_api;
+    }
+    autoApi.enableApiTracking(state._ZAP._config.track_api);
+    // heatmap capture: a no-op unless the app imported the heatmap entry, which sets the hook
+    state._ZAP._config.track_heatmap = typeof config.track_heatmap === 'boolean' // no i18n
+        ? config.track_heatmap
+        : constants.AP_CONFIG.track_heatmap;
+    hooks.hooks.enableHeatmap(state._ZAP._config.track_heatmap);
+    // automatic screen tracking, on unless the config says false: switched on by start(), once a
+    // screen view can be stored
+    state._ZAP._config.track_screen = typeof config.track_screen === 'boolean' ? config.track_screen : constants.AP_CONFIG.track_screen; // no i18n
+    applyIntervals(config);
+    lastConfig = config;
+    state._ZAP._initialised = true;
+    state._ZAP._ready = false;
+    state._ZAP._pending = [];
+    var myGeneration = ++generation;
+    state._ZAP._readyPromise = storage.storageReady().then(function (backend) {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        if (!backend) {
+            logger.warnAlways('Apptics.init: no usable storage (IndexedDB or localStorage), not starting'); // no i18n
+            state._ZAP._initialised = false;
+            state._ZAP._token = ''; // no i18n
+            state._ZAP._pending = [];
+            return false;
+        }
+        discardOtherAppData(state._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 appversion.registerAppVersion().then(function (registered) {
+            if (myGeneration !== generation) {
+                return false;
+            }
+            if (!registered) {
+                logger.warnAlways('Apptics.init: app/addversion did not return the app ids, not starting'); // no i18n
+                state._ZAP._initialised = false;
+                state._ZAP._token = ''; // no i18n
+                state._ZAP._pending = [];
+                return false;
+            }
+            return start(config, myGeneration);
+        });
+    }).catch(function (err) {
+        logger.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 state._ZAP._readyPromise || Promise.resolve(false);
+}
+function start(config, myGeneration) {
+    // app/addversion named the app; data stored for another one was discarded before it ran
+    state._ZAP._token = String(state._ZAP._defaultoptions.aaid);
+    storage.user_defaults.add('token', state._ZAP._token); // no i18n
+    // last known server settings (getupdates) apply before anything is tracked
+    index.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 = storage.user_defaults.item('uuid'); // no i18n
+    if (utils.isEmpty(uuid)) {
+        uuid = utils.getNewUUID();
+        storage.user_defaults.add('uuid', uuid); // no i18n
+    }
+    state._ZAP._uuid = uuid;
+    var stored_appversion = storage.user_defaults.item('appversion'); // no i18n
+    if (utils.isEmpty(stored_appversion)) {
+        storage.user_defaults.add('appversion', state._ZAP._defaultoptions.appversion); // no i18n
+        stored_appversion = state._ZAP._defaultoptions.appversion;
+    }
+    var appVersionChanged = stored_appversion != state._ZAP._defaultoptions.appversion;
+    state._ZAP._ignoreDnt = state._ZAP._config.ignore_do_not_track;
+    storage.tracking_preference.update_status(consent.getTrackingStatus());
+    index.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)
+    index.refreshServerSettings();
+    if (appVersionChanged) {
+        state._ZAP._device_info.appversionid = ''; // no i18n
+        index.updateDeviceWithApptics(state._ZAP._device_info).then(function (result) {
+            if (utils.isSuccess(result)) {
+                storage.user_defaults.add('appversion', state._ZAP._defaultoptions.appversion); // no i18n
+                logger.Console.log('init: appversion updated to ' + state._ZAP._defaultoptions.appversion); // no i18n
+            }
+        }).catch(function (err) {
+            logger.Console.log('init: error updating appversion: ' + err); // no i18n
+        });
+    }
+    // attempt to resolve connection type
+    state._ZAP._device_info.connectionType = env.getConnectionType();
+    attachListeners();
+    state._ZAP._properties.orientation = env.getOrientation();
+    index$1.getUserInfo();
+    return session.checkAndUpdateSession().then(function () {
+        if (myGeneration !== generation) {
+            return false;
+        }
+        scheduler.startTimers();
+        send.sendStoredLogs();
+        state._ZAP._ready = true;
+        // replay calls made while storage was loading, in order
+        var pending = state._ZAP._pending;
+        state._ZAP._pending = [];
+        pending.forEach(function (call) {
+            try {
+                call();
+            }
+            catch (err) {
+                logger.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
+        autoScreen.enableScreenTracking(state._ZAP._config.track_screen);
+        // a no-op unless the remote-config entry was imported, which sets the hook
+        hooks.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++;
+    scheduler.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
+    autoApi.enableApiTracking(false);
+    autoScreen.enableScreenTracking(false);
+    appversion.clearAppVersion();
+    hooks.hooks.enableHeatmap(false);
+    hooks.hooks.resetHeatmap();
+    hooks.hooks.resetRemoteConfig();
+    clearStorage();
+    state._ZAP._initialised = false;
+    state._ZAP._ready = false;
+    state._ZAP._pending = [];
+    state._ZAP._readyPromise = null;
+    state._ZAP._device_info = {};
+    state._ZAP._user_info = {};
+    state._ZAP._current_screen = {};
+    state._ZAP._current_session = {};
+    state._ZAP._uuid = ''; // no i18n
+    state._ZAP._apid = ''; // no i18n
+    state._ZAP._mapid = ''; // no i18n
+    state._ZAP._sending = false;
+    logger.Console.log('apptics.reset()'); // no i18n
+    // start again with the config init() was called with
+    if (lastConfig) {
+        init(lastConfig);
+    }
+}
+function isActive() {
+    return state._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')) || constants.AP_CONFIG.default_group_name; // no i18n
+    var eventProps = {};
+    var rawProps = targetElem.getAttribute('apeventprops'); // no i18n
+    if (!utils.isEmpty(rawProps)) {
+        try {
+            eventProps = JSON.parse(rawProps);
+        }
+        catch (err) {
+            logger.Console.warn('apptics: invalid JSON in apeventprops for "' + eventName + '", sending no properties'); // no i18n
+            eventProps = {};
+        }
+    }
+    if (!utils.isEmpty(eventName)) {
+        track.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;
+    session.updateScreenWithEndtime();
+    scheduler.flush(true);
+    logger.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;
+    logger.Console.log('page closing: ending the session and sending what is queued'); // no i18n
+    session.updateScreenWithEndtime();
+    send.forgetStoredLogs();
+    session.endCurrentSession().then(function () {
+        return scheduler.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 () {
+            state._ZAP._device_info.connectionType = env.getConnectionType();
+        });
+    }
+    // Track when the window loses focus (user switches to another window or application)
+    window.addEventListener('blur', function () {
+        if (!isActive())
+            return;
+        logger.Console.log('Window lost focus, user switched to another window or application'); // no i18n
+        session.updateLastActiveTimeOfSession();
+    });
+    // Track when the window gains focus (user switches back to the window)
+    window.addEventListener('focus', function () {
+        if (!isActive())
+            return;
+        logger.Console.log('Window regained focus, user switched back to the window'); // no i18n
+        session.checkAndUpdateSession();
+        scheduler.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;
+        logger.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
+        session.checkAndUpdateSession().then(track.resumeScreen);
+        scheduler.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
+        logger.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
+        session.checkAndUpdateSession().then(track.resumeScreen);
+        index.refreshServerSettings();
+    });
+    // if we are running in cordova use ondeviceready otherwise onload
+    window.addEventListener(window.cordova ? 'deviceready' : 'load', function () {
+        if (isActive())
+            session.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 (index.needsDevice()) {
+            logger.Console.log('back online: registering this device before sending'); // no i18n
+            index.checkAndUpdateDeviceInfo();
+            index.deviceReady().then(function () {
+                if (!isActive())
+                    return;
+                scheduler.flush();
+                // the lines logged while offline are waiting too, and log/add needs the same ids
+                send.sendStoredLogs();
+            });
+            return;
+        }
+        scheduler.flush();
+        send.sendStoredLogs();
+    }, { passive: true });
+    if (window.screen && window.screen.orientation && typeof window.screen.orientation.addEventListener === 'function') { // no i18n
+        window.screen.orientation.addEventListener('change', function () {
+            state._ZAP._properties.orientation = env.getOrientation();
+        });
+    }
+    window.addEventListener('unhandledrejection', function (event) {
+        if (isActive() && state._ZAP._isGlobalErrorTracking) {
+            track$1.trackError(event);
+        }
+    });
+    window.addEventListener('error', function (event) {
+        if (isActive() && state._ZAP._isGlobalErrorTracking) {
+            track$1.trackError(event);
+        }
+    });
+    window.addEventListener('click', onDocumentClick, true); // no i18n
+}
+
+exports.init = init;
+exports.ready = ready;
+exports.reset = reset;

package/dist/cjs/package.json

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

package/dist/cjs/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/cjs/remoteconfig/custom.js

@@ -0,0 +1,78 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var storage = require('../core/storage.js');
+var logger = require('../core/logger.js');
+var store = require('./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 = storage.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
+        logger.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
+    storage.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;
+            }
+        });
+        storage.user_defaults.add(STORE_KEY, saved);
+        // only once storage has loaded: re-resolving before it would read an empty rule set and keep it
+        store.reresolve();
+    });
+}
+/** reset(): forgets the values set on this page; the stored ones go with the rest of storage. */
+function clearCustomConditionValues() {
+    mine = {};
+}
+
+exports.clearCustomConditionValues = clearCustomConditionValues;
+exports.customConditionValue = customConditionValue;
+exports.setCustomConditionValue = setCustomConditionValue;

package/dist/cjs/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>;