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

package/dist/esm/remoteconfig/evaluate.js

@@ -0,0 +1,166 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { Console } from '../core/logger.js';
+import { _ZAP } from '../core/state.js';
+import { isEmpty } from '../core/utils.js';
+import { customConditionValue } from './custom.js';
+
+/**
+ * Working out what a parameter is worth on this device.
+ *
+ * The server sends the whole rule set, not an answer: every parameter with its default, every
+ * condition with its criteria, and the mapping between them. Resolving it here rather than on
+ * the server is what lets a value be read with no network at all on the next visit.
+ *
+ * A parameter resolves by walking its conditions in `conditionorder` and taking the value of the
+ * first one that matches this device. Nothing matches, or nothing is mapped: the default.
+ *
+ * Everything fails closed. An operator we do not recognise, a criteria key we cannot answer, a
+ * condition the parameter names but the server did not send — each one means "does not match",
+ * never "matches". A config system that guesses hands an app a value its author never chose, on
+ * a device they cannot see, and that is far worse than falling back to the default.
+ */
+/**
+ * Criteria operators, by the code the server sends in `status`.
+ *
+ * Only `1` is confirmed, from the one worked example we have: key `appversion`, status `"1"`,
+ * value `["1.1"]`, meaning the version is one of the listed values. The rest of the series is
+ * not written down anywhere we can see, so an unrecognised code is treated as no match and said
+ * once in the log — rather than guessed at, which would silently hand out the wrong value.
+ */
+const OPERATORS = Object.freeze({
+    '1': 'in', // no i18n
+});
+/** Criteria keys this SDK can answer about a browser. */
+const FACTS = Object.freeze({
+    appversion: function () { return String(_ZAP._defaultoptions.appversion || ''); }, // no i18n
+    platform: function () { return String(_ZAP._platform || ''); }, // no i18n
+    browser: function () { return String(_ZAP._device_info.browser || ''); }, // no i18n
+    browserversion: function () { return String(_ZAP._device_info.browserversion || ''); }, // no i18n
+    osversion: function () { return String(_ZAP._device_info.osversion || ''); }, // no i18n
+    devicetype: function () { return String(_ZAP._device_info.devicetype || ''); }, // no i18n
+    language: function () { return String(navigator.language || ''); }, // no i18n
+    customergroupid: function () { return String(_ZAP._user_info.groupid || ''); }, // no i18n
+    userid: function () { return String(_ZAP._user_info.userid || ''); }, // no i18n
+});
+/** Codes and keys already complained about, so one unknown rule is not a log per read. */
+var reported = {};
+function sayOnce(key, message) {
+    if (reported[key]) {
+        return;
+    }
+    reported[key] = true;
+    Console.warn(message);
+}
+/** Forgets what has been complained about, so a new rule set is judged afresh. */
+function resetEvaluationWarnings() {
+    reported = {};
+}
+/** The values of a criteria, as strings: the template types them as an array of safe_string. */
+function valuesOf(criteria) {
+    var raw = criteria.value;
+    if (!Array.isArray(raw)) {
+        return isEmpty(raw) ? [] : [String(raw)];
+    }
+    return raw.map(function (one) { return String(one); });
+}
+/** Whether one criteria holds on this device. */
+function criteriaMatches(criteria) {
+    var key = String(criteria.key || ''); // no i18n
+    var operator = OPERATORS[String(criteria.status)];
+    if (operator === undefined) {
+        sayOnce('op:' + criteria.status, 'AppticsRemoteConfig: unknown criteria operator "' + criteria.status // no i18n
+            + '", so conditions using it will not match'); // no i18n
+        return false;
+    }
+    var fact = FACTS[key];
+    // not something a browser knows about itself: a custom criteria, answered by what the app set
+    // with setCustomConditionValue
+    var actual = fact !== undefined ? fact() : customConditionValue(key);
+    if (actual === undefined) {
+        sayOnce('key:' + key, 'AppticsRemoteConfig: no value for criteria "' + key // no i18n
+            + '"; set one with setCustomConditionValue, or conditions using it will not match'); // no i18n
+        return false;
+    }
+    if (actual === '') {
+        return false;
+    }
+    // 'in': the device's value is one of the listed ones. Compared as strings because that is
+    // what both sides are - '1.1' is a version, not the number 1.1
+    return valuesOf(criteria).indexOf(actual) !== -1;
+}
+/**
+ * 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.
+ */
+function conditionMatches(condition) {
+    var criterias = condition && condition.criterias;
+    if (!Array.isArray(criterias) || criterias.length === 0) {
+        return false;
+    }
+    for (var i = 0; i < criterias.length; i++) {
+        if (!criteriaMatches(criterias[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The conditions a parameter names, in the order the console put them in. */
+function orderedConditions(parameter) {
+    var mapped = parameter.conditions;
+    if (!Array.isArray(mapped)) {
+        return [];
+    }
+    return mapped.slice().sort(function (a, b) {
+        return Number(a.conditionorder || 0) - Number(b.conditionorder || 0); // no i18n
+    });
+}
+/**
+ * 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.
+ */
+function resolve(parameter, byId) {
+    var mapped = orderedConditions(parameter);
+    for (var i = 0; i < mapped.length; i++) {
+        var link = mapped[i];
+        var condition = byId[String(link.conditionid)];
+        if (condition === undefined) {
+            // the parameter points at a condition the answer did not include
+            sayOnce('missing:' + link.conditionid, 'AppticsRemoteConfig: parameter "' + parameter.paramname // no i18n
+                + '" uses condition ' + link.conditionid + ', which the server did not send'); // no i18n
+            continue;
+        }
+        if (conditionMatches(condition)) {
+            return String(link.value === undefined || link.value === null ? '' : link.value);
+        }
+    }
+    return String(parameter.defaultvalue === undefined || parameter.defaultvalue === null ? '' : parameter.defaultvalue);
+}
+/**
+ * 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.
+ */
+function resolveAll(remoteconfig) {
+    var out = {};
+    var parameters = Array.isArray(remoteconfig.all_parameter) ? remoteconfig.all_parameter : [];
+    var conditions = Array.isArray(remoteconfig.all_condition) ? remoteconfig.all_condition : [];
+    var byId = {};
+    conditions.forEach(function (condition) {
+        byId[String(condition.conditionid)] = condition;
+    });
+    parameters.forEach(function (parameter) {
+        var name = String(parameter.paramname || ''); // no i18n
+        if (name === '') {
+            return;
+        }
+        out[name] = resolve(parameter, byId);
+    });
+    return out;
+}
+
+export { conditionMatches, resetEvaluationWarnings, resolve, resolveAll };

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

@@ -0,0 +1,24 @@
+/**
+ * Asks for the rule set, if anything has changed since the last one.
+ *
+ * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
+ * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
+ * normal case and not a failure.
+ *
+ * A second caller joins the first rather than making another request.
+ */
+export declare function fetchRemoteConfig(): Promise<Record<string, unknown>>;
+/**
+ * reset(): forgets the rule set, its values and what the server last reported, and disowns a
+ * request still in flight, whose answer would otherwise put the old rule set back.
+ */
+export declare function resetRemoteConfig(): void;
+/**
+ * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
+ * CACHE_MS. Resolves true when they are, false when the fetch failed, could not be made, or was
+ * past the coldFetch limit — the caller then decides whether stored values will do. Never rejects.
+ *
+ * Waits for start-up and for the device to be registered, which a first visit is still doing
+ * when ready() resolves: getupdates is refused without the device ids.
+ */
+export declare function obtain(coldFetch?: boolean): Promise<boolean>;

package/dist/esm/remoteconfig/fetch.js

@@ -0,0 +1,210 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { SDK_MODULE } from '../core/constants.js';
+import { hooks } from '../core/hooks.js';
+import { _ZAP } from '../core/state.js';
+import { Console } from '../core/logger.js';
+import { nowMs } from '../core/utils.js';
+import { rejectIfOffline, rejectIfNoDeviceIds, postToApptics, apiHeaders } from '../core/transport.js';
+import { deviceReady } from '../device/index.js';
+import { ready } from '../lifecycle.js';
+import { reresolve, clearRemoteConfig, store, storeUnchanged, flagtime } from './store.js';
+import { clearCustomConditionValues } from './custom.js';
+
+/**
+ * The getupdates call.
+ *
+ * getupdates is not a synonym for getsdkconfig. It takes a body naming the modules being asked
+ * about and answers with their payloads — remote config's rule set among them — while
+ * getsdkconfig answers only with which modules are on at all.
+ *
+ * getsdkconfig stays the source of truth for that. getupdates also reports a `tracking_status`,
+ * but only for modules that have something to say in that answer, and it can disagree with
+ * getsdkconfig when the two are in flight together: an app update prompt shown by one and
+ * switched off moments later by the other. Where they disagree, getsdkconfig wins; what
+ * getupdates says is used for one thing only, which is to stop asking about a module it has
+ * reported off.
+ */
+const LABEL = 'AppticsRemoteConfig'; // no i18n
+/** getupdatesobj caps moduleids at nine entries; this SDK asks about one. */
+const MODULES = [Number(SDK_MODULE.REMOTE_CONFIG)];
+var inFlight = null;
+/** Bumped by reset(); an answer to a request made before it is not stored. */
+var generation = 0;
+/**
+ * How long a fetch that succeeded on this page answers for later ones, as on Android: a value
+ * read on every render must not be a request on every render. coldFetch skips it.
+ */
+const CACHE_MS = 5 * 60 * 1000;
+/** coldFetch goes to the network every time, so it is limited: three in any minute, as on Android. */
+const COLD_LIMIT = 3;
+const COLD_WINDOW_MS = 60 * 1000;
+/** When a fetch on this page last succeeded; 0 until one has. */
+var fetchedAt = 0;
+/** When the coldFetch calls of the last minute went out. */
+var coldCalls = [];
+/**
+ * Whether remote config is still worth asking about.
+ *
+ * Two switches, and they are not the same one. getsdkconfig's module flag is the authority and
+ * is read from `_ZAP._remoteConfigEnabled`; `_remoteConfigReported` is what the last getupdates
+ * answer said, which exists only so that a module reported off is dropped from the next
+ * request's `moduleids` rather than asked about again.
+ */
+function wanted() {
+    return _ZAP._remoteConfigEnabled !== false && _ZAP._remoteConfigReported !== false;
+}
+/**
+ * The body. appversionid and flagtime are the two keys getupdatesobj declares mandatory.
+ *
+ * osversionid and apilevel are left out on purpose: both are declared, and both are Android's —
+ * an int api level means nothing in a browser, and the osversionid a browser holds is a server
+ * id for "macOS 15", not the small int this template types. languagecode is sent when there is
+ * one, since safe_string cannot match an empty string.
+ */
+function body() {
+    var payload = {
+        appversionid: String(_ZAP._device_info.appversionid || ''), // no i18n
+        moduleids: MODULES,
+        flagtime: flagtime(),
+    };
+    var language = String(navigator.language || '').slice(0, 10); // no i18n
+    if (language !== '') {
+        payload.languagecode = language; // no i18n
+    }
+    return JSON.stringify(payload);
+}
+/**
+ * Reads the module flags getupdates reports.
+ *
+ * Only to stop asking: getsdkconfig decides whether the feature is on. A module reported off
+ * here is dropped from the next request, which is what the API asks for.
+ */
+function applyReportedModules(data) {
+    var status = data.tracking_status;
+    if (!status || typeof status !== 'object') {
+        return;
+    }
+    var entry = status[SDK_MODULE.REMOTE_CONFIG];
+    if (entry && typeof entry === 'object') {
+        _ZAP._remoteConfigReported = entry.enabled !== false;
+    }
+}
+/**
+ * Asks for the rule set, if anything has changed since the last one.
+ *
+ * Resolves with the parameters as they stand afterwards, whether or not the answer carried a new
+ * rule set — an answer with no `remoteconfig` block means nothing has changed, which is the
+ * normal case and not a failure.
+ *
+ * A second caller joins the first rather than making another request.
+ */
+function fetchRemoteConfig() {
+    if (inFlight !== null) {
+        return inFlight;
+    }
+    if (!wanted()) {
+        Console.log(LABEL + ': switched off by the server, not asking'); // no i18n
+        return Promise.resolve({});
+    }
+    var blocked = rejectIfOffline(LABEL) || rejectIfNoDeviceIds(LABEL);
+    if (blocked) {
+        return blocked;
+    }
+    var asked = generation;
+    var request = postToApptics('getupdates', body(), apiHeaders(), LABEL).then(function (result) {
+        var data = (result.data || {});
+        if (asked !== generation) {
+            // asked before a reset(): the answer is about the device and app that were just forgotten
+            return data;
+        }
+        applyReportedModules(data);
+        var rules = data.remoteconfig;
+        var at = nowMs();
+        fetchedAt = at;
+        if (rules && typeof rules === 'object') {
+            store(rules, at);
+        }
+        else {
+            // nothing has changed since our flagtime, which is the answer most of the time
+            storeUnchanged(at);
+            Console.log(LABEL + ': no changes since ' + flagtime()); // no i18n
+        }
+        return data;
+    }).then(function (data) {
+        settle();
+        return data;
+    }, function (err) {
+        settle();
+        return Promise.reject(err);
+    });
+    // a request reset() has disowned must not clear the in-flight slot of one made after it
+    function settle() {
+        if (inFlight === request) {
+            inFlight = null;
+        }
+    }
+    inFlight = request;
+    return inFlight;
+}
+/**
+ * reset(): forgets the rule set, its values and what the server last reported, and disowns a
+ * request still in flight, whose answer would otherwise put the old rule set back.
+ */
+function resetRemoteConfig() {
+    generation++;
+    inFlight = null;
+    fetchedAt = 0;
+    coldCalls = [];
+    _ZAP._remoteConfigReported = true;
+    clearCustomConditionValues();
+    clearRemoteConfig();
+}
+/**
+ * Makes sure the values are this page's own: from a fetch that just succeeded, or one within
+ * CACHE_MS. Resolves true when they are, false when the fetch failed, could not be made, or was
+ * past the coldFetch limit — the caller then decides whether stored values will do. Never rejects.
+ *
+ * Waits for start-up and for the device to be registered, which a first visit is still doing
+ * when ready() resolves: getupdates is refused without the device ids.
+ */
+function obtain(coldFetch) {
+    return ready().then(function (running) {
+        if (!running) {
+            return false;
+        }
+        var now = nowMs();
+        if (coldFetch !== true && fetchedAt > 0 && now - fetchedAt < CACHE_MS) {
+            return true;
+        }
+        if (coldFetch === true) {
+            coldCalls = coldCalls.filter(function (at) { return now - at < COLD_WINDOW_MS; });
+            if (coldCalls.length >= COLD_LIMIT) {
+                Console.warn(LABEL + ': coldFetch is limited to ' + COLD_LIMIT + ' a minute; this one is not sent'); // no i18n
+                return false;
+            }
+            coldCalls.push(now);
+        }
+        return deviceReady().then(function () {
+            return fetchRemoteConfig();
+        }).then(function () {
+            return true;
+        }, function (err) {
+            Console.log(LABEL + ': fetch failed: ' + String(err)); // no i18n
+            return false;
+        });
+    });
+}
+/** Start-up's own fetch, so values are this session's without the app asking. */
+function fetchOnStart() {
+    obtain(false);
+}
+hooks.resetRemoteConfig = resetRemoteConfig;
+hooks.remoteConfigStarted = fetchOnStart;
+// a condition on the customer group answers differently once AppticsSetUser has named one
+hooks.remoteConfigUserChanged = reresolve;
+// imported after start-up has already finished (a lazy import, say): fetch now, as start-up would have
+if (_ZAP._ready) {
+    fetchOnStart();
+}
+
+export { fetchRemoteConfig, obtain, resetRemoteConfig };

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

@@ -0,0 +1,13 @@
+/** Android's AppticsRemoteConfig: fetchValue, fetchValues, setCustomConditionValue, setFallbackWithOfflineValue. */
+export declare const AppticsRemoteConfig: {
+    fetchValue: (name: string, callback?: (value: string | null) => void, coldFetch?: boolean) => Promise<string | null>;
+    fetchValues: (defaults: Record<string, string | null>, callback?: (values: Record<string, string | null>) => void, coldFetch?: boolean) => Promise<Record<string, string | null>>;
+    /** Whether a failed fetch answers with the values fetched before (the default) or with null. */
+    setFallbackWithOfflineValue: (enabled?: boolean) => void;
+    /**
+     * What this device is for a custom criteria the console defines, as Android's
+     * setCustomConditionValue; an empty value removes it. Kept across visits.
+     */
+    setCustomConditionValue: (key: string, value: string | number | boolean | null) => void;
+};
+export default AppticsRemoteConfig;

package/dist/esm/remoteconfig/index.js

@@ -0,0 +1,85 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { guard } from '../core/guard.js';
+import { Console } from '../core/logger.js';
+import { obtain } from './fetch.js';
+import { setCustomConditionValue } from './custom.js';
+import { all } from './store.js';
+
+/**
+ * Remote config, shipped as its own entry point:
+ *   import { AppticsRemoteConfig } from '@zoho_apptics/apptics-js-sdk/remote-config';
+ *
+ * Four calls, as on Android: fetchValue(name) and fetchValues({ name: default }) read parameters,
+ * setCustomConditionValue says what this device is for a custom criteria, and
+ * setFallbackWithOfflineValue chooses what a failed fetch answers with. The rule set is stored and
+ * resolved on the device, so a fetch within five minutes, or a failed one with the offline fallback
+ * on, answers without waiting on the network. The SDK fetches on start-up, and re-applies the rules
+ * on its own when AppticsSetUser or setCustomConditionValue changes what this device is.
+ *
+ * A parameter the console does not have is null from fetchValue and the caller's default from
+ * fetchValues, never undefined: a config system whose failure mode is `undefined` moves the
+ * problem into the app's rendering code.
+ */
+function raw(name) {
+    var values = all();
+    return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : undefined;
+}
+/**
+ * Whether a fetch that failed still answers with what was fetched before. On by default, as
+ * `fallbackWithOfflineValue` is on Android: a page offline for a moment keeps its config.
+ */
+var fallbackWithOfflineValue = true;
+/** Off: a failed fetch answers with null, or the caller's defaults, rather than stored values. */
+function setFallbackWithOfflineValue(enabled) {
+    fallbackWithOfflineValue = typeof enabled === 'boolean' ? enabled : true; // no i18n
+}
+/** Hands a result to the app's callback, which must not be able to break the Promise. */
+function answer(value, callback) {
+    if (typeof callback === 'function') { // no i18n
+        try {
+            callback(value);
+        }
+        catch (err) {
+            Console.warn('AppticsRemoteConfig: the callback threw', err); // no i18n
+        }
+    }
+    return value;
+}
+/**
+ * One parameter, fetched for this page, as Android's fetchValue: resolves with its value, or null
+ * when the console has no such parameter or the fetch failed with the offline fallback off.
+ */
+function fetchValue(name, callback, coldFetch) {
+    return obtain(coldFetch).then(function (fresh) {
+        var value = fresh || fallbackWithOfflineValue ? raw(name) : undefined;
+        return answer(value === undefined ? null : value, callback);
+    });
+}
+/**
+ * Several parameters at once, as Android's fetchValues: `defaults` maps each name to the value to
+ * use when there is none, and the result has exactly those names.
+ */
+function fetchValues(defaults, callback, coldFetch) {
+    return obtain(coldFetch).then(function (fresh) {
+        var out = {};
+        Object.keys(defaults || {}).forEach(function (name) {
+            var value = fresh || fallbackWithOfflineValue ? raw(name) : undefined;
+            out[name] = value === undefined ? defaults[name] : value;
+        });
+        return answer(out, callback);
+    });
+}
+/** Android's AppticsRemoteConfig: fetchValue, fetchValues, setCustomConditionValue, setFallbackWithOfflineValue. */
+const AppticsRemoteConfig = {
+    fetchValue: guard('AppticsRemoteConfig.fetchValue', fetchValue), // no i18n
+    fetchValues: guard('AppticsRemoteConfig.fetchValues', fetchValues), // no i18n
+    /** Whether a failed fetch answers with the values fetched before (the default) or with null. */
+    setFallbackWithOfflineValue: guard('AppticsRemoteConfig.setFallbackWithOfflineValue', setFallbackWithOfflineValue), // no i18n
+    /**
+     * What this device is for a custom criteria the console defines, as Android's
+     * setCustomConditionValue; an empty value removes it. Kept across visits.
+     */
+    setCustomConditionValue: guard('AppticsRemoteConfig.setCustomConditionValue', setCustomConditionValue), // no i18n
+};
+
+export { AppticsRemoteConfig, AppticsRemoteConfig as default };

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

@@ -0,0 +1,18 @@
+import type { Dict } from '../types.js';
+/** The flagtime to send: 0 until we hold a rule set, which asks the server for everything. */
+export declare function flagtime(): number;
+/** Re-resolves the stored rules against this device, without fetching. */
+export declare function reresolve(): void;
+/** Stores a rule set the server just sent, and resolves it. */
+export declare function store(rules: Dict, at: number): void;
+/**
+ * Records a fetch that brought no rule set.
+ *
+ * That is the normal answer when nothing has changed, and it is not a failure: what is stored
+ * stays, and only the fetch time moves.
+ */
+export declare function storeUnchanged(at: number): void;
+/** Forgets the rule set and its values, so the next fetch asks with flagtime 0. */
+export declare function clearRemoteConfig(): void;
+/** Every parameter resolved for this device. Loads from storage on the first read. */
+export declare function all(): Record<string, string>;

package/dist/esm/remoteconfig/store.js

@@ -0,0 +1,91 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { Console } from '../core/logger.js';
+import { user_defaults } from '../core/storage.js';
+import { resolveAll, resetEvaluationWarnings } from './evaluate.js';
+
+/**
+ * What remote config keeps between visits.
+ *
+ * The rule set is stored, not just the resolved values, for two reasons. The server only resends
+ * it when something changed — a fetch with a non-zero `flagtime` and no changes answers with no
+ * `remoteconfig` block at all — so throwing it away would mean asking for it again with
+ * flagtime 0 on every visit. And the resolved values depend on the device: an app version or a
+ * customer group that changed since the last visit has to re-resolve against the same rules.
+ *
+ * `flagtime` is the whole protocol here: it is the moment this SDK last had a rule set, and
+ * sending it back is how the server decides whether anything needs saying.
+ */
+const STORE_KEY = 'remoteconfig'; // no i18n
+var values = {};
+var loaded = false;
+function read() {
+    var saved = user_defaults.item(STORE_KEY);
+    return saved && typeof saved === 'object' ? saved : null;
+}
+/** The flagtime to send: 0 until we hold a rule set, which asks the server for everything. */
+function flagtime() {
+    var saved = read();
+    return saved && typeof saved.flagtime === 'number' ? saved.flagtime : 0;
+}
+/**
+ * The newest `version[].date` in a rule set, which is what the next fetch sends as flagtime.
+ *
+ * The array is a publication history and is not promised to be in order, so it is the highest
+ * date that matters rather than the first or last entry.
+ */
+function publishedAt(rules) {
+    var versions = Array.isArray(rules.version) ? rules.version : [];
+    var newest = 0;
+    versions.forEach(function (one) {
+        var at = Number(one.date);
+        if (isFinite(at) && at > newest) {
+            newest = at;
+        }
+    });
+    return newest;
+}
+/** Re-resolves the stored rules against this device, without fetching. */
+function reresolve() {
+    var saved = read();
+    values = saved && saved.rules ? resolveAll(saved.rules) : {};
+    loaded = true;
+}
+/** Stores a rule set the server just sent, and resolves it. */
+function store(rules, at) {
+    resetEvaluationWarnings();
+    var record = { flagtime: publishedAt(rules) || at, rules: rules, fetchedat: at };
+    user_defaults.add(STORE_KEY, record);
+    values = resolveAll(rules);
+    loaded = true;
+    Console.log('AppticsRemoteConfig: ' + Object.keys(values).length + ' parameters, published ' + record.flagtime); // no i18n
+}
+/**
+ * Records a fetch that brought no rule set.
+ *
+ * That is the normal answer when nothing has changed, and it is not a failure: what is stored
+ * stays, and only the fetch time moves.
+ */
+function storeUnchanged(at) {
+    var saved = read();
+    if (saved === null) {
+        return;
+    }
+    saved.fetchedat = at;
+    user_defaults.add(STORE_KEY, saved);
+}
+/** Forgets the rule set and its values, so the next fetch asks with flagtime 0. */
+function clearRemoteConfig() {
+    user_defaults.add(STORE_KEY, undefined);
+    values = {};
+    loaded = false;
+    resetEvaluationWarnings();
+}
+/** Every parameter resolved for this device. Loads from storage on the first read. */
+function all() {
+    if (!loaded) {
+        reresolve();
+    }
+    return values;
+}
+
+export { all, clearRemoteConfig, flagtime, reresolve, store, storeUnchanged };

package/dist/esm/remotelog/gate.d.ts

@@ -0,0 +1,11 @@
+export declare function setAppLogger(on: boolean): void;
+export declare function appLoggerEnabled(): boolean;
+/** The SDK's own diagnostics may be recorded: `remote_log` is on and the logger is reachable. */
+export declare function remoteLogEnabled(): boolean;
+/** An app's own log line may be recorded: the app enabled the logger and it is reachable. */
+export declare function appLogEnabled(): boolean;
+/**
+ * What is stored may be sent. Either writer is enough: app logging works with `remote_log`
+ * off, since that switch covers only the SDK's own diagnostics.
+ */
+export declare function remoteLogSendable(): boolean;

package/dist/esm/remotelog/gate.js

@@ -0,0 +1,48 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+import { getConfig, _ZAP } from '../core/state.js';
+import { is_apptics_disabled } from '../core/env.js';
+import { shouldTrackOrSendData } from '../core/consent.js';
+
+/**
+ * The one switch both halves of the remote logger ask: may this line be recorded, and may
+ * what is stored be sent? It lives on its own so recording and sending don't import each other.
+ */
+/** The app logger's switch: off until the app calls logger.enable(), as on Android and iOS. */
+let appLoggerOn = false;
+function setAppLogger(on) {
+    appLoggerOn = on;
+}
+function appLoggerEnabled() {
+    return appLoggerOn;
+}
+/**
+ * What every remote-log line needs, whoever wrote it: a running SDK, a client we send anything
+ * for, the server's remote logger switch, and consent.
+ */
+function remoteLoggerReachable() {
+    if (!_ZAP._token || is_apptics_disabled()) {
+        return false;
+    }
+    // getsdkconfig module 17: the server can switch the remote logger off on its own
+    if (!_ZAP._remoteLoggerEnabled) {
+        return false;
+    }
+    return shouldTrackOrSendData();
+}
+/** The SDK's own diagnostics may be recorded: `remote_log` is on and the logger is reachable. */
+function remoteLogEnabled() {
+    return getConfig('remote_log') && remoteLoggerReachable(); // no i18n
+}
+/** An app's own log line may be recorded: the app enabled the logger and it is reachable. */
+function appLogEnabled() {
+    return appLoggerOn && remoteLoggerReachable();
+}
+/**
+ * What is stored may be sent. Either writer is enough: app logging works with `remote_log`
+ * off, since that switch covers only the SDK's own diagnostics.
+ */
+function remoteLogSendable() {
+    return (getConfig('remote_log') || appLoggerOn) && remoteLoggerReachable(); // no i18n
+}
+
+export { appLogEnabled, appLoggerEnabled, remoteLogEnabled, remoteLogSendable, setAppLogger };