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

package/dist/cjs/core/constants.js

@@ -0,0 +1,299 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+const AP_TRACKING_STATUS = Object.freeze({
+    USAGE_TRACKING_WITH_PII: 1,
+    USAGE_TRACKING_WITHOUT_PII: 4,
+    NO_TRACKING: -1,
+});
+const AP_FEEDBACK_TYPE = Object.freeze({
+    BUG: 0,
+    FEEDBACK: 1,
+    HELP: 2,
+    REPORT: 3,
+});
+const AP_CONSTANTS = Object.freeze({
+    SCREEN: 'screen', // no i18n
+    SESSION: 'session', // no i18n
+    EVENT: 'event', // no i18n
+    API: 'api', // no i18n
+    ERROR: 'error', // no i18n
+    SUCCESS: 'success', // no i18n
+    BROWSER: 'Browser', // no i18n
+});
+const DEFAULT_API_PATHS = Object.freeze({
+    // the first call: registers the build and answers with the ids every later call needs
+    addversion: 'app/addversion', // no i18n
+    regdevice: 'device/add', // no i18n
+    reguser: 'user/register', // no i18n
+    engagement: 'engagement/add', // no i18n
+    // the exception group is part of the path, and the proxy matches it with [a-z]+ — no
+    // underscore, so js_error cannot route. 'error' is in the accepted set and is what we send
+    error: 'exception/error', // no i18n
+    feedback: 'feedback/add', // no i18n
+    // the source of truth for which modules are on. v2 replaced the old getupdates answer: it is
+    // per-module flags keyed by id now, not loose booleans
+    sdkconfig: 'getsdkconfig', // no i18n
+    // still its own endpoint, and not a synonym for the one above: it takes a body naming the
+    // modules being asked about, and answers with their payloads - remote config among them
+    getupdates: 'getupdates', // no i18n
+    // v2 replaced console/addlog: one call now carries a batch of lines, not one line
+    consolelog: 'log/add', // no i18n
+    heatmap: 'heatmap/add', // no i18n
+});
+/**
+ * Which API version each path lives under.
+ *
+ * Every path the SDK calls is defined under v2 in the proxy's security-sdk.xml, and four of them —
+ * app/addversion, getsdkconfig, heatmap/add and log/add — are defined there *only* under v2: there
+ * is no v1 url for them to fall back to, so sending v1 reaches nothing. It stays a per-path map
+ * rather than one shared prefix because v1 urls do still exist for the other five, so a path can
+ * be moved back on its own if one of them turns out not to be ready.
+ */
+const API_VERSIONS = Object.freeze({
+    addversion: 'v2', // no i18n
+    regdevice: 'v2', // no i18n
+    engagement: 'v2', // no i18n
+    error: 'v2', // no i18n
+    reguser: 'v2', // no i18n
+    feedback: 'v2', // no i18n
+    sdkconfig: 'v2', // no i18n
+    getupdates: 'v2', // no i18n
+    consolelog: 'v2', // no i18n
+    heatmap: 'v2', // no i18n
+});
+/**
+ * The SDK subsystem a remote log line is about, as console/addlog's `module` param.
+ * These are the server's own names, so they are sent exactly as written here.
+ */
+const AP_LOG_MODULE = Object.freeze({
+    SESSION: 'Session', // no i18n
+    SCREEN: 'Screen', // no i18n
+    EVENT: 'Event', // no i18n
+    API: 'API', // no i18n
+    HEATMAP: 'Heatmap', // no i18n
+    PROPERTIES: 'Properties', // no i18n
+});
+/**
+ * The modules getsdkconfig reports on, by the ids it keys them with. The SDK acts on the ones it
+ * has something to switch off; anything else the server sends is stored but unused.
+ */
+const SDK_MODULE = Object.freeze({
+    /**
+     * Remote config. It is the one module both answers report on: getupdates names it in
+     * `moduleids` and reports its flag back, and getsdkconfig reports the same flag as the
+     * authority. Where they disagree, getsdkconfig wins.
+     */
+    REMOTE_CONFIG: '2', // no i18n
+    SESSION: '11', // no i18n
+    FEEDBACK: '12', // no i18n
+    CRASH: '13', // no i18n
+    REMOTE_LOGGER: '17', // no i18n
+    HEATMAP: '18', // no i18n
+});
+/** logSDK declares max-len="10000" on logmessage, so a line is trimmed to fit that. */
+const CONSOLE_LOG_MAX_BODY = 10000;
+/** logSDK caps `function` at 100 characters. */
+const LOG_FUNCTION_MAX = 100;
+/** logSDK caps `filename` at 100 too, which is why a call site carries a basename, not a url. */
+const LOG_FILENAME_MAX = 100;
+/**
+ * How much of `devicename` is sent. The url declares no max-len, only safe_string, but this is a
+ * label a person reads in a list: anything longer is a paragraph, not a name.
+ */
+const DEVICE_NAME_MAX = 100;
+/**
+ * The `level` every line goes out with. Everything the remote logger carries is a failure inside
+ * the SDK — logFailure is its only caller — so the level never varies. 3 is what the v2 reference
+ * shows in its only example; the scale itself is not documented anywhere we can see.
+ */
+const REMOTE_LOG_LEVEL = 3;
+/**
+ * How long debug mode survives with nothing tracked, before switching itself off.
+ *
+ * An hour is long enough to cover reading a payload, changing the app and reloading, and short
+ * enough that a tab left open overnight is not still sending every call to its debug twin.
+ */
+const DEBUG_IDLE_MS = 60 * 60 * 1000;
+/** Idle minutes that end a session. Lives on state, not in _config, but defaults here. */
+const DEFAULT_INACTIVE_MINUTES = 30;
+/** Global defaults. `state._config` holds a mutable copy per init. */
+const AP_CONFIG = Object.freeze({
+    // the version is per path (API_VERSIONS); this is only the part before it
+    endpoint: '/sdk/web/', // no i18n
+    method: 'POST', // no i18n
+    transport: 'XHR', // no i18n
+    track_link_timeout: 300,
+    cookie_expiration_days: 365,
+    storage_type: 'localStorage', // no i18n
+    enable_batch_requests: true,
+    batch_size: 50,
+    batch_flush_interval: 30000,
+    getupdates_interval: 120000, // 2 minutes in milliseconds
+    batch_request_timeout: 7,
+    auto_starts_batch: true,
+    mode: 1,
+    default_group_name: 'default', // no i18n
+    default_optin_status: AP_TRACKING_STATUS.USAGE_TRACKING_WITHOUT_PII,
+    enable_pageview_tracking: false,
+    save_referrer: true,
+    debug: false,
+    track_by_default: true,
+    ignore_do_not_track: false,
+    // the SDK's own failure reports to the Remote Logger page: off unless the app passes remote_log: true
+    remote_log: false,
+    /**
+     * Wrap XHR and fetch to record the app's API calls without it calling startTrackApi(). Off by
+     * default: the hostnames and paths of every request an app makes is a wider grant than events
+     * and screens, so the app opts in.
+     */
+    track_api: false,
+    /**
+     * Record a screen view for the first page and every navigation after it, from the url. On by
+     * default; the app's own inScreen() during a navigation replaces that navigation's view.
+     */
+    track_screen: true,
+    /**
+     * Print each app logger line to the browser console as well, as Android's showLogs prints to
+     * Logcat. Off by default; console_log is the SDK's own activity, this is the app's lines.
+     */
+    show_logs: false,
+    /**
+     * Record sessions automatically. On by default; false is Android's
+     * automaticSessionsTrackingStatus = false: no sessions, while events and screens still are.
+     */
+    track_session: true,
+    /**
+     * How long a visit must last before its session is stored, in milliseconds. A shorter visit with
+     * nothing tracked in it is dropped: a bounce or a crawler is not a session. Anything tracked
+     * inside the window writes the session immediately, keeping its original start time. 0 disables
+     * the wait and stores every session as it starts.
+     */
+    min_session_duration: 5000,
+    /**
+     * Record where people click and how far they scroll, for the console's heatmaps. Off by default:
+     * coordinates and element labels are a wider grant than events and screens, so the app opts in.
+     */
+    track_heatmap: false,
+    /**
+     * Send engagement, exception and log payloads to their `debug/` twins, which answer with a
+     * request id and a link to the server's own logs for that request. For tracing a payload that
+     * is not showing up in the console; off in normal use, and it does not change what is sent.
+     */
+    debug_api: false,
+    /**
+     * What to call this device in the debug stream. Engagement, exception and log are the three
+     * urls that declare `devicename`, and it is what tells one tester's browser from another's
+     * when several are tracing the same build. Empty by default: it rides on every one of those
+     * calls, so an app that is not tracing should not pay for it. With `debug_api` on and nothing
+     * set here, a label is derived from the browser and OS instead, since an unnamed row in the
+     * debug stream is no use to whoever is reading it.
+     */
+    device_name: '',
+    /**
+     * Most heatmap records one visit may produce. Clicks are cheap, but a page that scrolls a lot
+     * can produce them faster than they are sent, and an unbounded queue is a memory leak on a tab
+     * left open for a day. Reached, capture stops for the rest of the session.
+     */
+    heatmap_max_per_session: 500,
+});
+/**
+ * Config keys `init()` refuses to start without (after the snippet aliases are resolved).
+ *
+ * `appversion` is here rather than defaulted on purpose. Every error, every device registration
+ * and every uploaded source map is only meaningful against the build it came from, and a default
+ * would answer that question wrongly and silently for every app that forgot to set it.
+ */
+/**
+ * What init() must be given. Everything else the SDK needs — aaid, the portal and project ids that
+ * go in every url — comes back from app/addversion, which these four are enough to call.
+ */
+const REQUIRED_CONFIG = Object.freeze(['serviceUrl', 'zak', 'identifier', 'appversion']); // no i18n
+/**
+ * Paths with a `debug/` twin. The debug endpoints take the same body and answer with a request id
+ * and a link to the server-side logs for that request, which is how a payload is traced end to
+ * end when the console does not show what was expected.
+ */
+const DEBUG_CAPABLE_PATHS = Object.freeze({
+    engagement: true, // no i18n
+    error: true, // no i18n
+    consolelog: true, // no i18n
+});
+/**
+ * Paths that declare `attempt`, `firstattempttime` and `lst`.
+ *
+ * Every url that carries data declares all three. app/addversion and getsdkconfig declare none:
+ * they are start-up calls whose answers the SDK needs, not payloads it is pushing, and sending
+ * an undeclared param is refused outright as EXTRA_PARAM_FOUND.
+ */
+const RETRY_CAPABLE_PATHS = Object.freeze({
+    regdevice: true, // no i18n
+    reguser: true, // no i18n
+    engagement: true, // no i18n
+    error: true, // no i18n
+    heatmap: true, // no i18n
+    consolelog: true, // no i18n
+    feedback: true, // no i18n
+    getupdates: true, // no i18n
+});
+/**
+ * Paths that live directly under the version, with no org and project segments. app/addversion is
+ * called before those ids are known, so it cannot carry them.
+ */
+const PATHS_WITHOUT_ORG = Object.freeze({
+    addversion: true, // no i18n
+});
+/** Console-snippet names accepted for the canonical keys above. */
+const CONFIG_ALIASES = Object.freeze({
+    serviceUrl: 'base_domain', // no i18n
+    zak: 'token', // no i18n
+});
+// crawlers reference
+// https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers
+const BLOCKED_WS = Object.freeze([
+    'ahrefsbot', // no i18n
+    'ahrefssiteaudit', // no i18n
+    'baiduspider', // no i18n
+    'bingbot', // no i18n
+    'bingpreview', // no i18n
+    'chrome-lighthouse', // no i18n
+    'facebookexternal', // no i18n
+    'petalbot', // no i18n
+    'pinterest', // no i18n
+    'screaming frog', // no i18n
+    'yahoo! slurp', // no i18n
+    'yandexbot', // no i18n
+    'adsbot-google', // no i18n
+    'apis-google', // no i18n
+    'duplexweb-google', // no i18n
+    'feedfetcher-google', // no i18n
+    'google favicon', // no i18n
+    'google web preview', // no i18n
+    'google-read-aloud', // no i18n
+    'googlebot', // no i18n
+    'googleweblight', // no i18n
+    'mediapartners-google', // no i18n
+    'storebot-google', // no i18n
+]);
+
+exports.API_VERSIONS = API_VERSIONS;
+exports.AP_CONFIG = AP_CONFIG;
+exports.AP_CONSTANTS = AP_CONSTANTS;
+exports.AP_FEEDBACK_TYPE = AP_FEEDBACK_TYPE;
+exports.AP_LOG_MODULE = AP_LOG_MODULE;
+exports.AP_TRACKING_STATUS = AP_TRACKING_STATUS;
+exports.BLOCKED_WS = BLOCKED_WS;
+exports.CONFIG_ALIASES = CONFIG_ALIASES;
+exports.CONSOLE_LOG_MAX_BODY = CONSOLE_LOG_MAX_BODY;
+exports.DEBUG_CAPABLE_PATHS = DEBUG_CAPABLE_PATHS;
+exports.DEBUG_IDLE_MS = DEBUG_IDLE_MS;
+exports.DEFAULT_API_PATHS = DEFAULT_API_PATHS;
+exports.DEFAULT_INACTIVE_MINUTES = DEFAULT_INACTIVE_MINUTES;
+exports.DEVICE_NAME_MAX = DEVICE_NAME_MAX;
+exports.LOG_FILENAME_MAX = LOG_FILENAME_MAX;
+exports.LOG_FUNCTION_MAX = LOG_FUNCTION_MAX;
+exports.PATHS_WITHOUT_ORG = PATHS_WITHOUT_ORG;
+exports.REMOTE_LOG_LEVEL = REMOTE_LOG_LEVEL;
+exports.REQUIRED_CONFIG = REQUIRED_CONFIG;
+exports.RETRY_CAPABLE_PATHS = RETRY_CAPABLE_PATHS;
+exports.SDK_MODULE = SDK_MODULE;

package/dist/cjs/core/db.d.ts

@@ -0,0 +1,40 @@
+import type { Dict, QueueItem } from '../types.js';
+export type QueueName = 'engagements' | 'errors' | 'logs' | 'consolelogs' | 'heatmaps';
+/** One storage implementation. storage.ts talks only to this interface. */
+export interface Backend {
+    readonly kind: 'indexeddb' | 'localstorage';
+    loadSettings(): Promise<Dict>;
+    putSetting(key: string, value: unknown): Promise<void>;
+    clearSettings(): Promise<void>;
+    /** Items in insertion order. */
+    queueAll(store: QueueName): Promise<QueueItem[]>;
+    /** Adds items, or replaces the item with the same id (keeping its position). */
+    queuePut(store: QueueName, items: QueueItem[]): Promise<void>;
+    queueDelete(store: QueueName, ids: string[]): Promise<void>;
+    queueClear(store: QueueName): Promise<void>;
+    /** One-transaction import of 1.x data; existing settings and items win. IndexedDB only. */
+    importAll?(settings: Dict, queues: Record<QueueName, QueueItem[]>): Promise<void>;
+}
+export declare const DB_NAME = "apptics";
+export declare const DB_VERSION = 3;
+/** 1.x localStorage keys; also the layout of the localStorage backend. */
+export declare const LEGACY_KEYS: Readonly<{
+    readonly settings: "apptics-device-info";
+    readonly engagements: "apptics-engagements-transactions";
+    readonly errors: "apptics-errors-transactions";
+    readonly logs: "apptics-log-transactions";
+    readonly consolelogs: "apptics-consolelog-transactions";
+    readonly heatmaps: "apptics-heatmap-transactions";
+}>;
+/** Shape guards shared by both backends and the 1.x migration. */
+export declare function asList(value: unknown): QueueItem[];
+export declare function asDict(value: unknown): Dict;
+export declare function createLocalStorageBackend(): Backend;
+/**
+ * Opens the database, and repairs it once if something else created an "apptics" database
+ * without our stores (then onupgradeneeded never fires and every read would fail).
+ */
+export declare function openIndexedDB(factory?: IDBFactory, timeoutMs?: number): Promise<IDBDatabase>;
+export declare function createIndexedDBBackend(db: IDBDatabase): Backend;
+/** IndexedDB when it opens, otherwise localStorage, otherwise null. Never rejects. */
+export declare function openBackend(): Promise<Backend | null>;

package/dist/cjs/core/db.js

@@ -0,0 +1,334 @@
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+'use strict';
+
+var logger = require('./logger.js');
+var utils = require('./utils.js');
+
+const DB_NAME = 'apptics'; // no i18n
+// 3 added the heatmaps store. The upgrade only creates stores that are missing, so an existing
+// database keeps everything already queued in it.
+const DB_VERSION = 3;
+const OPEN_TIMEOUT_MS = 3000;
+const QUEUES = ['engagements', 'errors', 'logs', 'consolelogs', 'heatmaps']; // no i18n
+/** 1.x localStorage keys; also the layout of the localStorage backend. */
+const LEGACY_KEYS = Object.freeze({
+    settings: 'apptics-device-info', // no i18n
+    engagements: 'apptics-engagements-transactions', // no i18n
+    errors: 'apptics-errors-transactions', // no i18n
+    logs: 'apptics-log-transactions', // no i18n
+    consolelogs: 'apptics-consolelog-transactions', // no i18n
+    // not a 1.x key: heatmaps did not exist then. It is here because this map is also the
+    // localStorage backend's layout, so the store needs a name there too
+    heatmaps: 'apptics-heatmap-transactions', // no i18n
+});
+/** Shape guards shared by both backends and the 1.x migration. */
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asDict(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/* ---------------- localStorage backend ---------------- */
+function readJSON(key) {
+    try {
+        const raw = localStorage.getItem(key);
+        return raw === null || raw === '' ? null : JSON.parse(raw); // no i18n
+    }
+    catch (err) {
+        logger.Console.warn('apptics: could not read ' + key + ', treating it as empty'); // no i18n
+        return null;
+    }
+}
+function writeJSON(key, value) {
+    try {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch (err) {
+        logger.Console.warn('apptics: could not write ' + key + ': ' + String(err)); // no i18n
+    }
+}
+function createLocalStorageBackend() {
+    return {
+        kind: 'localstorage', // no i18n
+        loadSettings() {
+            return Promise.resolve(asDict(readJSON(LEGACY_KEYS.settings)));
+        },
+        putSetting(key, value) {
+            const all = asDict(readJSON(LEGACY_KEYS.settings));
+            all[key] = value;
+            writeJSON(LEGACY_KEYS.settings, all);
+            return Promise.resolve();
+        },
+        clearSettings() {
+            writeJSON(LEGACY_KEYS.settings, {});
+            return Promise.resolve();
+        },
+        queueAll(store) {
+            return Promise.resolve(asList(readJSON(LEGACY_KEYS[store])));
+        },
+        queuePut(store, items) {
+            const list = asList(readJSON(LEGACY_KEYS[store]));
+            items.forEach(function (item) {
+                const index = list.findIndex(function (existing) { return existing.id === item.id; });
+                if (index === -1) {
+                    list.push(item);
+                }
+                else {
+                    list[index] = item;
+                }
+            });
+            writeJSON(LEGACY_KEYS[store], list);
+            return Promise.resolve();
+        },
+        queueDelete(store, ids) {
+            const remaining = asList(readJSON(LEGACY_KEYS[store])).filter(function (item) {
+                return ids.indexOf(item.id) === -1;
+            });
+            writeJSON(LEGACY_KEYS[store], remaining);
+            return Promise.resolve();
+        },
+        queueClear(store) {
+            writeJSON(LEGACY_KEYS[store], []);
+            return Promise.resolve();
+        },
+    };
+}
+let lastSeq = 0;
+/**
+ * Strictly increasing, and time-based so tabs interleave in roughly the right order.
+ * Counting up from the last value rather than a counter that wraps keeps insertion order
+ * even when a chatty caller adds more than a thousand items inside one millisecond.
+ */
+function nextSeq() {
+    const base = utils.nowMs() * 1000;
+    lastSeq = base > lastSeq ? base : lastSeq + 1;
+    return lastSeq;
+}
+function request(req) {
+    return new Promise(function (resolve, reject) {
+        req.onsuccess = function () { resolve(req.result); };
+        req.onerror = function () { reject(req.error); };
+    });
+}
+function completed(tx) {
+    return new Promise(function (resolve, reject) {
+        tx.oncomplete = function () { resolve(); };
+        tx.onerror = function () { reject(tx.error); };
+        tx.onabort = function () { reject(tx.error); };
+    });
+}
+/** Puts `item` unless it exists (keepExisting) or replaces it keeping its seq. Runs inside `store`'s transaction. */
+function putRecord(store, item, keepExisting) {
+    const id = String(item.id);
+    const lookup = store.get(id);
+    lookup.onsuccess = function () {
+        const existing = lookup.result;
+        if (existing && keepExisting) {
+            return;
+        }
+        store.put({ id: id, seq: existing ? existing.seq : nextSeq(), type: item.type, item: item });
+    };
+}
+/** Our stores, as created by onupgradeneeded. */
+function hasAllStores(db) {
+    return db.objectStoreNames.contains('settings') && QUEUES.every(function (name) {
+        return db.objectStoreNames.contains(name);
+    });
+}
+function deleteDatabase(factory) {
+    return new Promise(function (resolve) {
+        var req = factory.deleteDatabase(DB_NAME);
+        req.onsuccess = function () { resolve(); };
+        req.onerror = function () { resolve(); };
+        req.onblocked = function () { resolve(); };
+    });
+}
+/**
+ * Opens the database, and repairs it once if something else created an "apptics" database
+ * without our stores (then onupgradeneeded never fires and every read would fail).
+ */
+function openIndexedDB(factory = indexedDB, timeoutMs = OPEN_TIMEOUT_MS) {
+    return openOnce(factory, timeoutMs).then(function (db) {
+        if (hasAllStores(db)) {
+            return db;
+        }
+        logger.Console.warn('apptics: the "' + DB_NAME + '" database is missing its stores, recreating it'); // no i18n
+        db.close();
+        return deleteDatabase(factory).then(function () {
+            return openOnce(factory, timeoutMs);
+        }).then(function (fresh) {
+            if (!hasAllStores(fresh)) {
+                fresh.close();
+                throw new Error('indexedDB: stores could not be created'); // no i18n
+            }
+            return fresh;
+        });
+    });
+}
+function openOnce(factory, timeoutMs) {
+    return new Promise(function (resolve, reject) {
+        let settled = false;
+        const fail = function (reason) {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(reason);
+            }
+        };
+        const timer = setTimeout(function () {
+            fail(new Error('indexedDB open timed out')); // no i18n
+        }, timeoutMs);
+        let req;
+        try {
+            req = factory.open(DB_NAME, DB_VERSION);
+        }
+        catch (err) {
+            fail(err);
+            return;
+        }
+        req.onupgradeneeded = function () {
+            const db = req.result;
+            if (!db.objectStoreNames.contains('settings')) { // no i18n
+                db.createObjectStore('settings'); // no i18n
+            }
+            QUEUES.forEach(function (name) {
+                if (!db.objectStoreNames.contains(name)) {
+                    db.createObjectStore(name, { keyPath: 'id' }).createIndex('seq', 'seq'); // no i18n
+                }
+            });
+        };
+        req.onsuccess = function () {
+            if (settled) {
+                req.result.close(); // we already gave up (timeout or blocked)
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            // Another tab running a newer build needs to upgrade the schema, and cannot while this
+            // connection is open. Letting go is the only cooperative answer: holding on blocks that
+            // tab's upgrade until this one is closed, and it spends the whole time with no storage.
+            // This tab keeps working from memory and picks the new schema up on its next load.
+            req.result.onversionchange = function () {
+                logger.Console.warn('apptics: another tab is upgrading the database, closing this connection'); // no i18n
+                req.result.close();
+            };
+            resolve(req.result);
+        };
+        req.onerror = function () {
+            fail(req.error);
+        };
+        req.onblocked = function () {
+            // Another tab is holding an older version open. A build that sets onversionchange
+            // (above) lets go by itself, so this resolves on its own in a moment; the open is left
+            // to run until the timeout rather than abandoned, because giving up here would mean
+            // running with no storage for the rest of the visit.
+            logger.Console.warn('apptics: waiting for another tab to release the database'); // no i18n
+        };
+    });
+}
+function createIndexedDBBackend(db) {
+    return {
+        kind: 'indexeddb', // no i18n
+        loadSettings() {
+            const store = db.transaction('settings', 'readonly').objectStore('settings'); // no i18n
+            return Promise.all([request(store.getAllKeys()), request(store.getAll())]).then(function ([keys, values]) {
+                const out = {};
+                keys.forEach(function (key, i) {
+                    out[String(key)] = values[i];
+                });
+                return out;
+            });
+        },
+        putSetting(key, value) {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').put(value, key); // no i18n
+            return completed(tx);
+        },
+        clearSettings() {
+            const tx = db.transaction('settings', 'readwrite'); // no i18n
+            tx.objectStore('settings').clear(); // no i18n
+            return completed(tx);
+        },
+        queueAll(store) {
+            const index = db.transaction(store, 'readonly').objectStore(store).index('seq'); // no i18n
+            return request(index.getAll()).then(function (records) {
+                return records.map(function (record) { return record.item; });
+            });
+        },
+        queuePut(store, items) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            const objectStore = tx.objectStore(store);
+            items.forEach(function (item) { putRecord(objectStore, item, false); });
+            return completed(tx);
+        },
+        queueDelete(store, ids) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            const objectStore = tx.objectStore(store);
+            ids.forEach(function (id) { objectStore.delete(id); });
+            return completed(tx);
+        },
+        queueClear(store) {
+            const tx = db.transaction(store, 'readwrite'); // no i18n
+            tx.objectStore(store).clear();
+            return completed(tx);
+        },
+        importAll(settings, queues) {
+            // scope derived from QUEUES, not repeated: the loop below opens every one of them,
+            // and a store left out of the scope throws NotFoundError the moment it is reached
+            const tx = db.transaction(['settings'].concat(QUEUES), 'readwrite'); // no i18n
+            const settingsStore = tx.objectStore('settings'); // no i18n
+            Object.keys(settings).forEach(function (key) {
+                const lookup = settingsStore.get(key);
+                lookup.onsuccess = function () {
+                    if (lookup.result === undefined) {
+                        settingsStore.put(settings[key], key);
+                    }
+                };
+            });
+            QUEUES.forEach(function (name) {
+                const objectStore = tx.objectStore(name);
+                queues[name].forEach(function (item) { putRecord(objectStore, item, true); });
+            });
+            return completed(tx);
+        },
+    };
+}
+function localStorageUsable() {
+    try {
+        const probe = '__apptics_probe__'; // no i18n
+        localStorage.setItem(probe, '1');
+        localStorage.removeItem(probe);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/** IndexedDB when it opens, otherwise localStorage, otherwise null. Never rejects. */
+function openBackend() {
+    const fallback = function (reason) {
+        logger.Console.warn('apptics: IndexedDB unavailable (' + String(reason) + '), using localStorage'); // no i18n
+        return localStorageUsable() ? createLocalStorageBackend() : null;
+    };
+    let factory;
+    try {
+        factory = typeof indexedDB !== 'undefined' ? indexedDB : undefined; // no i18n
+    }
+    catch (err) {
+        factory = undefined; // access can throw in sandboxed frames
+    }
+    if (!factory) {
+        return Promise.resolve(fallback('not supported')); // no i18n
+    }
+    return openIndexedDB(factory).then(createIndexedDBBackend, fallback);
+}
+
+exports.DB_NAME = DB_NAME;
+exports.DB_VERSION = DB_VERSION;
+exports.LEGACY_KEYS = LEGACY_KEYS;
+exports.asDict = asDict;
+exports.asList = asList;
+exports.createIndexedDBBackend = createIndexedDBBackend;
+exports.createLocalStorageBackend = createLocalStorageBackend;
+exports.openBackend = openBackend;
+exports.openIndexedDB = openIndexedDB;