react-native-onyx 1.0.131 → 2.0.2

package/{lib → dist}/metrics/PerformanceUtils.js

@@ -1,15 +1,19 @@
-import lodashTransform from 'lodash/transform';
-import _ from 'underscore';
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setShouldDebugSetState = exports.logSetStateCall = void 0;
+const transform_1 = __importDefault(require("lodash/transform"));
+const underscore_1 = __importDefault(require("underscore"));
 let debugSetState = false;
-
 /**
  * @param {Boolean} debug
  */
 function setShouldDebugSetState(debug) {
     debugSetState = debug;
 }
-
+exports.setShouldDebugSetState = setShouldDebugSetState;
 /**
  * Deep diff between two objects. Useful for figuring out what changed about an object from one render to the next so
  * that state and props updates can be optimized.
@@ -20,18 +24,16 @@ function setShouldDebugSetState(debug) {
  */
 function diffObject(object, base) {
     function changes(obj, comparisonObject) {
-        return lodashTransform(obj, (result, value, key) => {
-            if (_.isEqual(value, comparisonObject[key])) {
+        return (0, transform_1.default)(obj, (result, value, key) => {
+            if (underscore_1.default.isEqual(value, comparisonObject[key])) {
                 return;
             }
-
             // eslint-disable-next-line no-param-reassign
-            result[key] = _.isObject(value) && _.isObject(comparisonObject[key]) ? changes(value, comparisonObject[key]) : value;
+            result[key] = underscore_1.default.isObject(value) && underscore_1.default.isObject(comparisonObject[key]) ? changes(value, comparisonObject[key]) : value;
         });
     }
     return changes(object, base);
 }
-
 /**
  * Provide insights into why a setState() call occurred by diffing the before and after values.
  *
@@ -45,19 +47,17 @@ function logSetStateCall(mapping, previousValue, newValue, caller, keyThatChange
     if (!debugSetState) {
         return;
     }
-
     const logParams = {};
     if (keyThatChanged) {
         logParams.keyThatChanged = keyThatChanged;
     }
-    if (_.isObject(newValue) && _.isObject(previousValue)) {
+    if (underscore_1.default.isObject(newValue) && underscore_1.default.isObject(previousValue)) {
         logParams.difference = diffObject(previousValue, newValue);
-    } else {
+    }
+    else {
         logParams.previousValue = previousValue;
         logParams.newValue = newValue;
     }
-
     console.debug(`[Onyx-Debug] ${mapping.displayName} setState() called. Subscribed to key '${mapping.key}' (${caller})`, logParams);
 }
-
-export {logSetStateCall, setShouldDebugSetState};
+exports.logSetStateCall = logSetStateCall;

package/dist/metrics/index.d.ts

@@ -0,0 +1,4 @@
+export function decorateWithMetrics(func: any): any;
+export function getMetrics(): void;
+export function resetMetrics(): void;
+export function printMetrics(): void;

package/dist/metrics/index.js

@@ -0,0 +1,14 @@
+"use strict";
+// For web-only implementations of Onyx, this module will just be a no-op
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMetrics = exports.resetMetrics = exports.getMetrics = exports.decorateWithMetrics = void 0;
+function decorateWithMetrics(func) {
+    return func;
+}
+exports.decorateWithMetrics = decorateWithMetrics;
+function getMetrics() { }
+exports.getMetrics = getMetrics;
+function printMetrics() { }
+exports.printMetrics = printMetrics;
+function resetMetrics() { }
+exports.resetMetrics = resetMetrics;

package/dist/metrics/index.native.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Wraps a function with metrics capturing logic
+ * @param {function} func
+ * @param {String} [alias]
+ * @returns {function} The wrapped function
+ */
+export function decorateWithMetrics(func: Function, alias?: string | undefined): Function;
+/**
+ * Aggregates and returns benchmark information
+ * @returns {{summaries: Record<string, Object>, totalTime: number, lastCompleteCall: *}}
+ * An object with
+ * - `totalTime` - total time spent by decorated methods
+ * - `lastCompleteCall` - millisecond since launch the last call completed at
+ * - `summaries` - mapping of all captured stats: summaries.methodName -> method stats
+ */
+export function getMetrics(): {
+    summaries: Record<string, Object>;
+    totalTime: number;
+    lastCompleteCall: any;
+};
+/**
+ * Clears all collected metrics.
+ */
+export function resetMetrics(): void;
+/**
+ * Print extensive information on the dev console
+ * max, min, average, total time for each method
+ * and a table of individual calls
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.raw=false] - setting this to true will print raw instead of human friendly times
+ * Useful when you copy the printed table to excel and let excel do the number formatting
+ * @param {'console'|'csv'|'json'|'string'} [options.format=console] The output format of this function
+ * `string` is useful when __DEV__ is set to `false` as writing to the console is disabled, but the result of this
+ * method would still get printed as output
+ * @param {string[]} [options.methods] Print stats only for these method names
+ * @returns {string|undefined}
+ */
+export function printMetrics({ raw, format, methods }?: {
+    raw?: boolean | undefined;
+    format?: "string" | "console" | "csv" | "json" | undefined;
+    methods?: string[] | undefined;
+} | undefined): string | undefined;

package/{lib → dist}/metrics/index.native.js

@@ -1,9 +1,24 @@
-import _ from 'underscore';
-import performance from 'react-native-performance';
-import MDTable from '../MDTable';
-
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMetrics = exports.resetMetrics = exports.getMetrics = exports.decorateWithMetrics = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+const react_native_performance_1 = __importDefault(require("react-native-performance"));
+const MDTable_1 = __importDefault(require("../MDTable"));
 const decoratedAliases = new Set();
-
 /**
  * Capture a start mark to performance entries
  * @param {string} alias
@@ -11,22 +26,20 @@ const decoratedAliases = new Set();
  * @returns {{name: string, startTime:number, detail: {args: [], alias: string}}}
  */
 function addMark(alias, args) {
-    return performance.mark(alias, {detail: {args, alias}});
+    return react_native_performance_1.default.mark(alias, { detail: { args, alias } });
 }
-
 /**
  * Capture a measurement between the start mark and now
  * @param {{name: string, startTime:number, detail: {args: []}}} startMark
  * @param {*} detail
  */
 function measureMarkToNow(startMark, detail) {
-    performance.measure(`${startMark.name} [${startMark.detail.args.toString()}]`, {
+    react_native_performance_1.default.measure(`${startMark.name} [${startMark.detail.args.toString()}]`, {
         start: startMark.startTime,
-        end: performance.now(),
-        detail: {...startMark.detail, ...detail},
+        end: react_native_performance_1.default.now(),
+        detail: Object.assign(Object.assign({}, startMark.detail), detail),
     });
 }
-
 /**
  * Wraps a function with metrics capturing logic
  * @param {function} func
@@ -37,33 +50,27 @@ function decorateWithMetrics(func, alias = func.name) {
     if (decoratedAliases.has(alias)) {
         throw new Error(`"${alias}" is already decorated`);
     }
-
     decoratedAliases.add(alias);
-
     function decorated(...args) {
         const mark = addMark(alias, args);
-
         // eslint-disable-next-line no-invalid-this
         const originalPromise = func.apply(this, args);
-
         /*
          * Then handlers added here are not affecting the original promise
          * They create a separate chain that's not exposed (returned) to the original caller
          * */
         originalPromise
             .then((result) => {
-                measureMarkToNow(mark, {result});
-            })
+            measureMarkToNow(mark, { result });
+        })
             .catch((error) => {
-                measureMarkToNow(mark, {error});
-            });
-
+            measureMarkToNow(mark, { error });
+        });
         return originalPromise;
     }
-
     return decorated;
 }
-
+exports.decorateWithMetrics = decorateWithMetrics;
 /**
  * Calculate the total sum of a given key in a list
  * @param {Array<Record<prop, Number>>} list
@@ -71,9 +78,8 @@ function decorateWithMetrics(func, alias = func.name) {
  * @returns {number}
  */
 function sum(list, prop) {
-    return _.reduce(list, (memo, next) => memo + next[prop], 0);
+    return underscore_1.default.reduce(list, (memo, next) => memo + next[prop], 0);
 }
-
 /**
  * Aggregates and returns benchmark information
  * @returns {{summaries: Record<string, Object>, totalTime: number, lastCompleteCall: *}}
@@ -83,46 +89,41 @@ function sum(list, prop) {
  * - `summaries` - mapping of all captured stats: summaries.methodName -> method stats
  */
 function getMetrics() {
-    const summaries = _.chain(performance.getEntriesByType('measure'))
+    const summaries = underscore_1.default.chain(react_native_performance_1.default.getEntriesByType('measure'))
         .filter((entry) => entry.detail && decoratedAliases.has(entry.detail.alias))
         .groupBy((entry) => entry.detail.alias)
         .map((calls, methodName) => {
-            const total = sum(calls, 'duration');
-            const avg = total / calls.length || 0;
-            const max = _.max(calls, 'duration').duration || 0;
-            const min = _.min(calls, 'duration').duration || 0;
-
-            // Latest complete call (by end time) for all the calls made to the current method
-            const lastCall = _.max(calls, (call) => call.startTime + call.duration);
-
-            return [
+        const total = sum(calls, 'duration');
+        const avg = total / calls.length || 0;
+        const max = underscore_1.default.max(calls, 'duration').duration || 0;
+        const min = underscore_1.default.min(calls, 'duration').duration || 0;
+        // Latest complete call (by end time) for all the calls made to the current method
+        const lastCall = underscore_1.default.max(calls, (call) => call.startTime + call.duration);
+        return [
+            methodName,
+            {
                 methodName,
-                {
-                    methodName,
-                    total,
-                    max,
-                    min,
-                    avg,
-                    lastCall,
-                    calls,
-                },
-            ];
-        })
+                total,
+                max,
+                min,
+                avg,
+                lastCall,
+                calls,
+            },
+        ];
+    })
         .object() // Create a map like methodName -> StatSummary
         .value();
-
-    const totalTime = sum(_.values(summaries), 'total');
-
+    const totalTime = sum(underscore_1.default.values(summaries), 'total');
     // Latest complete call (by end time) of all methods up to this point
-    const lastCompleteCall = _.max(_.values(summaries), (summary) => summary.lastCall.startTime + summary.lastCall.duration).lastCall;
-
+    const lastCompleteCall = underscore_1.default.max(underscore_1.default.values(summaries), (summary) => summary.lastCall.startTime + summary.lastCall.duration).lastCall;
     return {
         totalTime,
         summaries,
         lastCompleteCall,
     };
 }
-
+exports.getMetrics = getMetrics;
 /**
  * Convert milliseconds to human readable time
  * @param {number} millis
@@ -133,20 +134,16 @@ function toDuration(millis, raw = false) {
     if (raw) {
         return millis;
     }
-
     const minute = 60 * 1000;
     if (millis > minute) {
         return `${(millis / minute).toFixed(1)}min`;
     }
-
     const second = 1000;
     if (millis > second) {
         return `${(millis / second).toFixed(2)}sec`;
     }
-
     return `${millis.toFixed(3)}ms`;
 }
-
 /**
  * Print extensive information on the dev console
  * max, min, average, total time for each method
@@ -161,53 +158,39 @@ function toDuration(millis, raw = false) {
  * @param {string[]} [options.methods] Print stats only for these method names
  * @returns {string|undefined}
  */
-function printMetrics({raw = false, format = 'console', methods} = {}) {
-    const {totalTime, summaries, lastCompleteCall} = getMetrics();
-
-    const tableSummary = MDTable.factory({
+function printMetrics({ raw = false, format = 'console', methods } = {}) {
+    const { totalTime, summaries, lastCompleteCall } = getMetrics();
+    const tableSummary = MDTable_1.default.factory({
         heading: ['method', 'total time spent', 'max', 'min', 'avg', 'time last call completed', 'calls made'],
         leftAlignedCols: [0],
     });
-
     /* Performance marks (startTimes) are relative to system uptime
      * timeOrigin is the point at which the app started to init
      * We use timeOrigin to display times relative to app launch time
      * See: https://github.com/oblador/react-native-performance/issues/50 */
-    const timeOrigin = performance.timeOrigin;
-    const methodNames = _.isArray(methods) ? methods : _.keys(summaries);
-
-    const methodCallTables = _.chain(methodNames)
+    const timeOrigin = react_native_performance_1.default.timeOrigin;
+    const methodNames = underscore_1.default.isArray(methods) ? methods : underscore_1.default.keys(summaries);
+    const methodCallTables = underscore_1.default.chain(methodNames)
         .filter((methodName) => summaries[methodName] && summaries[methodName].avg > 0)
         .map((methodName) => {
-            const {calls, ...methodStats} = summaries[methodName];
-            tableSummary.addRow(
-                methodName,
-                toDuration(methodStats.total, raw),
-                toDuration(methodStats.max, raw),
-                toDuration(methodStats.min, raw),
-                toDuration(methodStats.avg, raw),
-                toDuration(methodStats.lastCall.startTime + methodStats.lastCall.duration - timeOrigin, raw),
-                calls.length,
-            );
-
-            return MDTable.factory({
-                title: methodName,
-                heading: ['start time', 'end time', 'duration', 'args'],
-                leftAlignedCols: [3],
-                rows: _.map(calls, (call) => [
-                    toDuration(call.startTime - performance.timeOrigin, raw),
-                    toDuration(call.startTime + call.duration - timeOrigin, raw),
-                    toDuration(call.duration, raw),
-                    _.map(call.detail.args, String).join(', ').slice(0, 60), // Restrict cell width to 60 chars max
-                ]),
-            });
-        })
+        const _a = summaries[methodName], { calls } = _a, methodStats = __rest(_a, ["calls"]);
+        tableSummary.addRow(methodName, toDuration(methodStats.total, raw), toDuration(methodStats.max, raw), toDuration(methodStats.min, raw), toDuration(methodStats.avg, raw), toDuration(methodStats.lastCall.startTime + methodStats.lastCall.duration - timeOrigin, raw), calls.length);
+        return MDTable_1.default.factory({
+            title: methodName,
+            heading: ['start time', 'end time', 'duration', 'args'],
+            leftAlignedCols: [3],
+            rows: underscore_1.default.map(calls, (call) => [
+                toDuration(call.startTime - react_native_performance_1.default.timeOrigin, raw),
+                toDuration(call.startTime + call.duration - timeOrigin, raw),
+                toDuration(call.duration, raw),
+                underscore_1.default.map(call.detail.args, String).join(', ').slice(0, 60), // Restrict cell width to 60 chars max
+            ]),
+        });
+    })
         .value();
-
     if (/csv|json|string/i.test(format)) {
         const allTables = [tableSummary, ...methodCallTables];
-
-        return _.map(allTables, (table) => {
+        return underscore_1.default.map(allTables, (table) => {
             switch (format.toLowerCase()) {
                 case 'csv':
                     return table.toCSV();
@@ -218,11 +201,8 @@ function printMetrics({raw = false, format = 'console', methods} = {}) {
             }
         }).join('\n\n');
     }
-
     const lastComplete = lastCompleteCall && toDuration(lastCompleteCall.startTime + lastCompleteCall.duration - timeOrigin, raw);
-
     const mainOutput = ['### Onyx Benchmark', `  - Total: ${toDuration(totalTime, raw)}`, `  - Last call finished at: ${lastComplete || 'N/A'}`, '', tableSummary.toString()];
-
     /* eslint-disable no-console */
     console.info(mainOutput.join('\n'));
     methodCallTables.forEach((table) => {
@@ -232,20 +212,18 @@ function printMetrics({raw = false, format = 'console', methods} = {}) {
     });
     /* eslint-enable */
 }
-
+exports.printMetrics = printMetrics;
 /**
  * Clears all collected metrics.
  */
 function resetMetrics() {
-    const {summaries} = getMetrics();
-
-    _.chain(summaries)
+    const { summaries } = getMetrics();
+    underscore_1.default.chain(summaries)
         .map((summary) => summary.calls)
         .flatten()
         .each((measure) => {
-            performance.clearMarks(measure.detail.alias);
-            performance.clearMeasures(measure.name);
-        });
+        react_native_performance_1.default.clearMarks(measure.detail.alias);
+        react_native_performance_1.default.clearMeasures(measure.name);
+    });
 }
-
-export {decorateWithMetrics, getMetrics, resetMetrics, printMetrics};
+exports.resetMetrics = resetMetrics;

package/{lib/storage/NativeStorage.js → dist/storage/NativeStorage.d.ts}

@@ -1,3 +1,2 @@
-import SQLiteStorage from './providers/SQLiteStorage';
-
 export default SQLiteStorage;
+import SQLiteStorage from './providers/SQLiteStorage';

package/dist/storage/NativeStorage.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SQLiteStorage_1 = __importDefault(require("./providers/SQLiteStorage"));
+exports.default = SQLiteStorage_1.default;

package/dist/storage/WebStorage.d.ts

@@ -0,0 +1,19 @@
+export default webStorage;
+declare const webStorage: {
+    /**
+     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     */
+    keepInstancesSync(onStorageKeyChanged: Function): void;
+    setItem: (key: string, value: any) => Promise<void>;
+    multiGet: (keysParam: string[]) => Promise<[key, value][]>;
+    multiMerge: (pairs: [key, value][]) => Promise<void>;
+    mergeItem(key: string, _changes: any, modifiedData: any): Promise<void>;
+    multiSet: (pairs: [key, value][]) => Promise<void>;
+    clear: () => Promise<void>;
+    setMemoryOnlyKeys: () => void;
+    getAllKeys: () => Promise<string[]>;
+    getItem: (key: string) => Promise<any>;
+    removeItem: (key: string) => Promise<void>;
+    removeItems: (keysParam: any[]) => Promise<any>;
+    getDatabaseSize(): Promise<number>;
+};

package/{lib → dist}/storage/WebStorage.js

@@ -1,13 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * This file is here to wrap IDBKeyVal with a layer that provides data-changed events like the ones that exist
  * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
  * data changes and then stay up-to-date with everything happening in Onyx.
  */
-import _ from 'underscore';
-import Storage from './providers/IDBKeyVal';
-
+const underscore_1 = __importDefault(require("underscore"));
+const IDBKeyVal_1 = __importDefault(require("./providers/IDBKeyVal"));
 const SYNC_ONYX = 'SYNC_ONYX';
-
 /**
  * Raise an event thorough `localStorage` to let other tabs know a value changed
  * @param {String} onyxKey
@@ -16,59 +19,46 @@ function raiseStorageSyncEvent(onyxKey) {
     global.localStorage.setItem(SYNC_ONYX, onyxKey);
     global.localStorage.removeItem(SYNC_ONYX, onyxKey);
 }
-
 function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    _.each(onyxKeys, (onyxKey) => {
+    underscore_1.default.each(onyxKeys, (onyxKey) => {
         raiseStorageSyncEvent(onyxKey);
     });
 }
-
-const webStorage = {
-    ...Storage,
-
+const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), { 
     /**
      * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
     keepInstancesSync(onStorageKeyChanged) {
         // Override set, remove and clear to raise storage events that we intercept in other tabs
-        this.setItem = (key, value) => Storage.setItem(key, value).then(() => raiseStorageSyncEvent(key));
-
-        this.removeItem = (key) => Storage.removeItem(key).then(() => raiseStorageSyncEvent(key));
-
-        this.removeItems = (keys) => Storage.removeItems(keys).then(() => raiseStorageSyncManyKeysEvent(keys));
-
-        this.mergeItem = (key, batchedChanges, modifiedData) => Storage.mergeItem(key, batchedChanges, modifiedData).then(() => raiseStorageSyncEvent(key));
-
+        this.setItem = (key, value) => IDBKeyVal_1.default.setItem(key, value).then(() => raiseStorageSyncEvent(key));
+        this.removeItem = (key) => IDBKeyVal_1.default.removeItem(key).then(() => raiseStorageSyncEvent(key));
+        this.removeItems = (keys) => IDBKeyVal_1.default.removeItems(keys).then(() => raiseStorageSyncManyKeysEvent(keys));
+        this.mergeItem = (key, batchedChanges, modifiedData) => IDBKeyVal_1.default.mergeItem(key, batchedChanges, modifiedData).then(() => raiseStorageSyncEvent(key));
         // If we just call Storage.clear other tabs will have no idea which keys were available previously
         // so that they can call keysChanged for them. That's why we iterate over every key and raise a storage sync
         // event for each one
         this.clear = () => {
             let allKeys;
-
             // The keys must be retrieved before storage is cleared or else the list of keys would be empty
-            return Storage.getAllKeys()
+            return IDBKeyVal_1.default.getAllKeys()
                 .then((keys) => {
-                    allKeys = keys;
-                })
-                .then(() => Storage.clear())
+                allKeys = keys;
+            })
+                .then(() => IDBKeyVal_1.default.clear())
                 .then(() => {
-                    // Now that storage is cleared, the storage sync event can happen which is a more atomic action
-                    // for other browser tabs
-                    _.each(allKeys, raiseStorageSyncEvent);
-                });
+                // Now that storage is cleared, the storage sync event can happen which is a more atomic action
+                // for other browser tabs
+                underscore_1.default.each(allKeys, raiseStorageSyncEvent);
+            });
         };
-
         // This listener will only be triggered by events coming from other tabs
         global.addEventListener('storage', (event) => {
             // Ignore events that don't originate from the SYNC_ONYX logic
             if (event.key !== SYNC_ONYX || !event.newValue) {
                 return;
             }
-
             const onyxKey = event.newValue;
-            Storage.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
+            IDBKeyVal_1.default.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
         });
-    },
-};
-
-export default webStorage;
+    } });
+exports.default = webStorage;

package/dist/storage/__mocks__/index.d.ts

@@ -0,0 +1,23 @@
+export default idbKeyvalMockSpy;
+declare namespace idbKeyvalMockSpy {
+    export { set as idbKeyvalSet };
+    export let setItem: jest.Mock<Promise<any>, [key?: any, value?: any]>;
+    export let getItem: jest.Mock<Promise<any>, [key?: any]>;
+    export let removeItem: jest.Mock<Promise<void>, [key?: any]>;
+    export let removeItems: jest.Mock<Promise<void>, [keys?: any]>;
+    export let clear: jest.Mock<Promise<void>, []>;
+    export let getAllKeys: jest.Mock<Promise<any>, []>;
+    export let config: jest.Mock<void, []>;
+    export let multiGet: jest.Mock<Promise<any>, [keys?: any]>;
+    export let multiSet: jest.Mock<Promise<any>, [pairs?: any]>;
+    export let multiMerge: jest.Mock<Promise<{}>, [pairs?: any]>;
+    export let mergeItem: jest.Mock<Promise<any>, [key?: any, _changes?: any, modifiedData?: any]>;
+    export let getStorageMap: jest.Mock<{}, []>;
+    export let setInitialMockData: jest.Mock<void, [data?: any]>;
+    export let getDatabaseSize: jest.Mock<Promise<{
+        bytesRemaining: number;
+        bytesUsed: number;
+    }>, []>;
+    export let setMemoryOnlyKeys: jest.Mock<void, []>;
+}
+declare const set: jest.Mock<Promise<any>, [key?: any, value?: any]>;