react-native-onyx 2.0.14 → 2.0.16

package/dist/Onyx.js

@@ -1436,14 +1436,6 @@ function setMemoryOnlyKeys(keyList) {
  * });
  */
 function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false } = {}) {
-    storage_1.default.init();
-    if (shouldSyncMultipleInstances) {
-        storage_1.default.keepInstancesSync((key, value) => {
-            const prevValue = OnyxCache_1.default.getValue(key, false);
-            OnyxCache_1.default.set(key, value);
-            keyChanged(key, value, prevValue);
-        });
-    }
     if (debugSetState) {
         PerformanceUtils.setShouldDebugSetState(true);
     }
@@ -1464,6 +1456,13 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
     evictionAllowList = safeEvictionKeys;
     // Initialize all of our keys with data provided then give green light to any pending connections
     Promise.all([addAllSafeEvictionKeysToRecentlyAccessedList(), initializeWithDefaultKeyStates()]).then(deferredInitTask.resolve);
+    if (shouldSyncMultipleInstances && underscore_1.default.isFunction(storage_1.default.keepInstancesSync)) {
+        storage_1.default.keepInstancesSync((key, value) => {
+            const prevValue = OnyxCache_1.default.getValue(key, false);
+            OnyxCache_1.default.set(key, value);
+            keyChanged(key, value, prevValue);
+        });
+    }
 }
 const Onyx = {
     connect,

package/dist/storage/NativeStorage.d.ts

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

package/dist/storage/{platforms/index.js → NativeStorage.js}

@@ -3,5 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const IDBKeyValProvider_1 = __importDefault(require("../providers/IDBKeyValProvider"));
-exports.default = IDBKeyValProvider_1.default;
+const SQLiteStorage_1 = __importDefault(require("./providers/SQLiteStorage"));
+exports.default = SQLiteStorage_1.default;

package/dist/storage/WebStorage.d.ts

@@ -0,0 +1,3 @@
+import type StorageProvider from './providers/types';
+declare const webStorage: StorageProvider;
+export default webStorage;

package/dist/storage/WebStorage.js

@@ -0,0 +1,62 @@
+"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.
+ */
+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
+ */
+function raiseStorageSyncEvent(onyxKey) {
+    global.localStorage.setItem(SYNC_ONYX, onyxKey);
+    global.localStorage.removeItem(SYNC_ONYX);
+}
+function raiseStorageSyncManyKeysEvent(onyxKeys) {
+    onyxKeys.forEach((onyxKey) => {
+        raiseStorageSyncEvent(onyxKey);
+    });
+}
+const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), { 
+    /**
+     * @param 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) => 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 IDBKeyVal_1.default.getAllKeys()
+                .then((keys) => {
+                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
+                allKeys.forEach(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;
+            IDBKeyVal_1.default.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
+        });
+    } });
+exports.default = webStorage;

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

@@ -2,7 +2,6 @@
 import type { KeyValuePairList } from '../providers/types';
 declare const idbKeyvalMockSpy: {
     idbKeyvalSet: jest.Mock<Promise<any>, [key: any, value: any]>;
-    init: jest.Mock<void, []>;
     setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string, value: IDBValidKey]>;
     getItem: jest.Mock<Promise<IDBValidKey | null>, [key: string]>;
     removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
@@ -20,6 +19,5 @@ declare const idbKeyvalMockSpy: {
         bytesRemaining: number;
     }>, []>;
     setMemoryOnlyKeys: jest.Mock<void, []>;
-    keepInstancesSync: jest.Mock<void, [onStorageKeyChanged: import("../providers/types").OnStorageKeyChanged]>;
 };
 export default idbKeyvalMockSpy;

package/dist/storage/__mocks__/index.js

@@ -10,8 +10,6 @@ const set = jest.fn((key, value) => {
     return Promise.resolve(value);
 });
 const idbKeyvalMock = {
-    name: 'KeyValMockProvider',
-    init: () => undefined,
     setItem(key, value) {
         return set(key, value);
     },
@@ -60,11 +58,9 @@ const idbKeyvalMock = {
     },
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     setMemoryOnlyKeys() { },
-    keepInstancesSync: () => undefined,
 };
 const idbKeyvalMockSpy = {
     idbKeyvalSet: set,
-    init: jest.fn(idbKeyvalMock.init),
     setItem: jest.fn(idbKeyvalMock.setItem),
     getItem: jest.fn(idbKeyvalMock.getItem),
     removeItem: jest.fn(idbKeyvalMock.removeItem),
@@ -81,6 +77,5 @@ const idbKeyvalMockSpy = {
     }),
     getDatabaseSize: jest.fn(idbKeyvalMock.getDatabaseSize),
     setMemoryOnlyKeys: jest.fn(idbKeyvalMock.setMemoryOnlyKeys),
-    keepInstancesSync: jest.fn(idbKeyvalMock.keepInstancesSync),
 };
 exports.default = idbKeyvalMockSpy;

package/dist/storage/index.d.ts

@@ -1,6 +1,2 @@
-import type StorageProvider from './providers/types';
-type Storage = {
-    getStorageProvider: () => StorageProvider;
-} & Omit<StorageProvider, 'name'>;
-declare const Storage: Storage;
-export default Storage;
+import WebStorage from './WebStorage';
+export default WebStorage;

package/dist/storage/index.js

@@ -1,172 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Logger = __importStar(require("../Logger"));
-const platforms_1 = __importDefault(require("./platforms"));
-const InstanceSync_1 = __importDefault(require("./InstanceSync"));
-const NoopProvider_1 = __importDefault(require("./providers/NoopProvider"));
-let provider = platforms_1.default;
-let shouldKeepInstancesSync = false;
-let finishInitalization;
-const initPromise = new Promise((resolve) => {
-    finishInitalization = resolve;
-});
-/**
- * Degrade performance by removing the storage provider and only using cache
- */
-function degradePerformance(error) {
-    Logger.logAlert(`Error while using ${provider.name}. Falling back to only using cache and dropping storage.`);
-    console.error(error);
-    provider = NoopProvider_1.default;
-}
-/**
- * Runs a piece of code and degrades performance if certain errors are thrown
- */
-function tryOrDegradePerformance(fn) {
-    return new Promise((resolve, reject) => {
-        initPromise.then(() => {
-            try {
-                resolve(fn());
-            }
-            catch (error) {
-                // Test for known critical errors that the storage provider throws, e.g. when storage is full
-                if (error instanceof Error) {
-                    // IndexedDB error when storage is full (https://github.com/Expensify/App/issues/29403)
-                    if (error.message.includes('Internal error opening backing store for indexedDB.open')) {
-                        degradePerformance(error);
-                    }
-                }
-                reject(error);
-            }
-        });
-    });
-}
-const Storage = {
-    /**
-     * Returns the storage provider currently in use
-     */
-    getStorageProvider() {
-        return provider;
-    },
-    /**
-     * Initializes all providers in the list of storage providers
-     * and enables fallback providers if necessary
-     */
-    init() {
-        tryOrDegradePerformance(provider.init).finally(() => {
-            finishInitalization();
-        });
-    },
-    /**
-     * Get the value of a given key or return `null` if it's not available
-     */
-    getItem: (key) => tryOrDegradePerformance(() => provider.getItem(key)),
-    /**
-     * Get multiple key-value pairs for the give array of keys in a batch
-     */
-    multiGet: (keys) => tryOrDegradePerformance(() => provider.multiGet(keys)),
-    /**
-     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
-     */
-    setItem: (key, value) => tryOrDegradePerformance(() => {
-        const promise = provider.setItem(key, value);
-        if (shouldKeepInstancesSync) {
-            return promise.then(() => InstanceSync_1.default.setItem(key));
-        }
-        return promise;
-    }),
-    /**
-     * Stores multiple key-value pairs in a batch
-     */
-    multiSet: (pairs) => tryOrDegradePerformance(() => provider.multiSet(pairs)),
-    /**
-     * Merging an existing value with a new one
-     */
-    mergeItem: (key, changes, modifiedData) => tryOrDegradePerformance(() => {
-        const promise = provider.mergeItem(key, changes, modifiedData);
-        if (shouldKeepInstancesSync) {
-            return promise.then(() => InstanceSync_1.default.mergeItem(key));
-        }
-        return promise;
-    }),
-    /**
-     * Multiple merging of existing and new values in a batch
-     * This function also removes all nested null values from an object.
-     */
-    multiMerge: (pairs) => tryOrDegradePerformance(() => provider.multiMerge(pairs)),
-    /**
-     * Removes given key and its value
-     */
-    removeItem: (key) => tryOrDegradePerformance(() => {
-        const promise = provider.removeItem(key);
-        if (shouldKeepInstancesSync) {
-            return promise.then(() => InstanceSync_1.default.removeItem(key));
-        }
-        return promise;
-    }),
-    /**
-     * Remove given keys and their values
-     */
-    removeItems: (keys) => tryOrDegradePerformance(() => {
-        const promise = provider.removeItems(keys);
-        if (shouldKeepInstancesSync) {
-            return promise.then(() => InstanceSync_1.default.removeItems(keys));
-        }
-        return promise;
-    }),
-    /**
-     * Clears everything
-     */
-    clear: () => tryOrDegradePerformance(() => {
-        if (shouldKeepInstancesSync) {
-            return InstanceSync_1.default.clear(() => provider.clear());
-        }
-        return provider.clear();
-    }),
-    // This is a noop for now in order to keep clients from crashing see https://github.com/Expensify/Expensify/issues/312438
-    setMemoryOnlyKeys: () => tryOrDegradePerformance(() => provider.setMemoryOnlyKeys()),
-    /**
-     * Returns all available keys
-     */
-    getAllKeys: () => tryOrDegradePerformance(() => provider.getAllKeys()),
-    /**
-     * Gets the total bytes of the store
-     */
-    getDatabaseSize: () => tryOrDegradePerformance(() => provider.getDatabaseSize()),
-    /**
-     * @param onStorageKeyChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
-     */
-    keepInstancesSync(onStorageKeyChanged) {
-        // If InstanceSync is null, it means we're on a native platform and we don't need to keep instances in sync
-        if (InstanceSync_1.default === null)
-            return;
-        shouldKeepInstancesSync = true;
-        InstanceSync_1.default.init(onStorageKeyChanged);
-    },
-};
-exports.default = Storage;
+const WebStorage_1 = __importDefault(require("./WebStorage"));
+exports.default = WebStorage_1.default;

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

@@ -0,0 +1,2 @@
+import NativeStorage from './NativeStorage';
+export default NativeStorage;

package/dist/storage/{platforms/index.native.js → index.native.js}

@@ -3,5 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteProvider_1 = __importDefault(require("../providers/SQLiteProvider"));
-exports.default = SQLiteProvider_1.default;
+const NativeStorage_1 = __importDefault(require("./NativeStorage"));
+exports.default = NativeStorage_1.default;

package/dist/storage/providers/{IDBKeyValProvider.js → IDBKeyVal.js}

@@ -7,24 +7,17 @@ const idb_keyval_1 = require("idb-keyval");
 const utils_1 = __importDefault(require("../../utils"));
 // We don't want to initialize the store while the JS bundle loads as idb-keyval will try to use global.indexedDB
 // which might not be available in certain environments that load the bundle (e.g. electron main process).
-let idbKeyValStore;
+let customStoreInstance;
+function getCustomStore() {
+    if (!customStoreInstance) {
+        customStoreInstance = (0, idb_keyval_1.createStore)('OnyxDB', 'keyvaluepairs');
+    }
+    return customStoreInstance;
+}
 const provider = {
-    /**
-     * The name of the provider that can be printed to the logs
-     */
-    name: 'IDBKeyValProvider',
-    /**
-     * Initializes the storage provider
-     */
-    init() {
-        const newIdbKeyValStore = (0, idb_keyval_1.createStore)('OnyxDB', 'keyvaluepairs');
-        if (newIdbKeyValStore == null)
-            throw Error('IDBKeyVal store could not be created');
-        idbKeyValStore = newIdbKeyValStore;
-    },
-    setItem: (key, value) => (0, idb_keyval_1.set)(key, value, idbKeyValStore),
-    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, idbKeyValStore).then((values) => values.map((value, index) => [keysParam[index], value])),
-    multiMerge: (pairs) => idbKeyValStore('readwrite', (store) => {
+    setItem: (key, value) => (0, idb_keyval_1.set)(key, value, getCustomStore()),
+    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, getCustomStore()).then((values) => values.map((value, index) => [keysParam[index], value])),
+    multiMerge: (pairs) => getCustomStore()('readwrite', (store) => {
         // Note: we are using the manual store transaction here, to fit the read and update
         // of the items in one transaction to achieve best performance.
         const getValues = Promise.all(pairs.map(([key]) => (0, idb_keyval_1.promisifyRequest)(store.get(key))));
@@ -42,16 +35,16 @@ const provider = {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
         return provider.setItem(key, modifiedData);
     },
-    multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, idbKeyValStore),
-    clear: () => (0, idb_keyval_1.clear)(idbKeyValStore),
+    multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, getCustomStore()),
+    clear: () => (0, idb_keyval_1.clear)(getCustomStore()),
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     setMemoryOnlyKeys: () => { },
-    getAllKeys: () => (0, idb_keyval_1.keys)(idbKeyValStore),
-    getItem: (key) => (0, idb_keyval_1.get)(key, idbKeyValStore)
+    getAllKeys: () => (0, idb_keyval_1.keys)(getCustomStore()),
+    getItem: (key) => (0, idb_keyval_1.get)(key, getCustomStore())
         // idb-keyval returns undefined for missing items, but this needs to return null so that idb-keyval does the same thing as SQLiteStorage.
         .then((val) => (val === undefined ? null : val)),
-    removeItem: (key) => (0, idb_keyval_1.del)(key, idbKeyValStore),
-    removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, idbKeyValStore),
+    removeItem: (key) => (0, idb_keyval_1.del)(key, getCustomStore()),
+    removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, getCustomStore()),
     getDatabaseSize() {
         if (!window.navigator || !window.navigator.storage) {
             throw new Error('StorageManager browser API unavailable');

package/dist/storage/providers/{SQLiteProvider.js → SQLiteStorage.js}

@@ -7,24 +7,14 @@ const react_native_quick_sqlite_1 = require("react-native-quick-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
 const utils_1 = __importDefault(require("../../utils"));
 const DB_NAME = 'OnyxDB';
-let db;
+const db = (0, react_native_quick_sqlite_1.open)({ name: DB_NAME });
+db.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
+// All of the 3 pragmas below were suggested by SQLite team.
+// You can find more info about them here: https://www.sqlite.org/pragma.html
+db.execute('PRAGMA CACHE_SIZE=-20000;');
+db.execute('PRAGMA synchronous=NORMAL;');
+db.execute('PRAGMA journal_mode=WAL;');
 const provider = {
-    /**
-     * The name of the provider that can be printed to the logs
-     */
-    name: 'SQLiteProvider',
-    /**
-     * Initializes the storage provider
-     */
-    init() {
-        db = (0, react_native_quick_sqlite_1.open)({ name: DB_NAME });
-        db.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
-        // All of the 3 pragmas below were suggested by SQLite team.
-        // You can find more info about them here: https://www.sqlite.org/pragma.html
-        db.execute('PRAGMA CACHE_SIZE=-20000;');
-        db.execute('PRAGMA synchronous=NORMAL;');
-        db.execute('PRAGMA journal_mode=WAL;');
-    },
     getItem(key) {
         return db.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
             if (!rows || (rows === null || rows === void 0 ? void 0 : rows.length) === 0) {
@@ -96,5 +86,7 @@ const provider = {
     },
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     setMemoryOnlyKeys: () => { },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    keepInstancesSync: () => { },
 };
 exports.default = provider;

package/dist/storage/providers/types.d.ts

@@ -6,14 +6,6 @@ type KeyList = Key[];
 type KeyValuePairList = KeyValuePair[];
 type OnStorageKeyChanged = (key: Key, value: Value | null) => void;
 type StorageProvider = {
-    /**
-     * The name of the provider that can be printed to the logs
-     */
-    name: string;
-    /**
-     * Initializes the storage provider
-     */
-    init: () => void;
     /**
      * Gets the value of a given key or return `null` if it's not available in storage
      */
@@ -73,4 +65,4 @@ type StorageProvider = {
     keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
 };
 export default StorageProvider;
-export type { Value, Key, KeyList, KeyValuePair, KeyValuePairList, OnStorageKeyChanged };
+export type { Value, Key, KeyList, KeyValuePairList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",

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

@@ -1,13 +0,0 @@
-/**
- *  This is used to keep multiple browser tabs in sync, therefore only needed on web
- *  On native platforms, we omit this syncing logic by setting this to mock implementation.
- */
-declare const InstanceSync: {
-    init: (...args: any[]) => void;
-    setItem: (...args: any[]) => void;
-    removeItem: (...args: any[]) => void;
-    removeItems: (...args: any[]) => void;
-    mergeItem: (...args: any[]) => void;
-    clear: <T extends () => void>(callback: T) => Promise<void>;
-};
-export default InstanceSync;

package/dist/storage/InstanceSync/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const noop_1 = __importDefault(require("lodash/noop"));
-/**
- *  This is used to keep multiple browser tabs in sync, therefore only needed on web
- *  On native platforms, we omit this syncing logic by setting this to mock implementation.
- */
-const InstanceSync = {
-    init: noop_1.default,
-    setItem: noop_1.default,
-    removeItem: noop_1.default,
-    removeItems: noop_1.default,
-    mergeItem: noop_1.default,
-    clear: (callback) => Promise.resolve(callback()),
-};
-exports.default = InstanceSync;

package/dist/storage/InstanceSync/index.web.d.ts

@@ -1,24 +0,0 @@
-/**
- * The InstancesSync object 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 type { KeyList, Key, OnStorageKeyChanged } from '../providers/types';
-/**
- * Raise an event through `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
- */
-declare function raiseStorageSyncEvent(onyxKey: Key): void;
-declare function raiseStorageSyncManyKeysEvent(onyxKeys: KeyList): void;
-declare const InstanceSync: {
-    /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
-     */
-    init: (onStorageKeyChanged: OnStorageKeyChanged) => void;
-    setItem: typeof raiseStorageSyncEvent;
-    removeItem: typeof raiseStorageSyncEvent;
-    removeItems: typeof raiseStorageSyncManyKeysEvent;
-    mergeItem: typeof raiseStorageSyncEvent;
-    clear: (clearImplementation: () => void) => any;
-};
-export default InstanceSync;

package/dist/storage/InstanceSync/index.web.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SYNC_ONYX = 'SYNC_ONYX';
-/**
- * Raise an event through `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
- */
-function raiseStorageSyncEvent(onyxKey) {
-    global.localStorage.setItem(SYNC_ONYX, onyxKey);
-    global.localStorage.removeItem(SYNC_ONYX);
-}
-function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    onyxKeys.forEach((onyxKey) => {
-        raiseStorageSyncEvent(onyxKey);
-    });
-}
-const InstanceSync = {
-    /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
-     */
-    init: (onStorageKeyChanged) => {
-        // 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;
-            // @ts-expect-error `this` will be substituted later in actual function call
-            this.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
-        });
-    },
-    setItem: raiseStorageSyncEvent,
-    removeItem: raiseStorageSyncEvent,
-    removeItems: raiseStorageSyncManyKeysEvent,
-    mergeItem: raiseStorageSyncEvent,
-    clear: (clearImplementation) => {
-        let allKeys;
-        // The keys must be retrieved before storage is cleared or else the list of keys would be empty
-        // @ts-expect-error `this` will be substituted later in actual function call
-        return this.getAllKeys()
-            .then((keys) => {
-            allKeys = keys;
-        })
-            .then(() => clearImplementation())
-            .then(() => {
-            // Now that storage is cleared, the storage sync event can happen which is a more atomic action
-            // for other browser tabs
-            raiseStorageSyncManyKeysEvent(allKeys);
-        });
-    },
-};
-exports.default = InstanceSync;

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

@@ -1,2 +0,0 @@
-import WebStorage from '../providers/IDBKeyValProvider';
-export default WebStorage;

package/dist/storage/platforms/index.native.d.ts

@@ -1,2 +0,0 @@
-import NativeStorage from '../providers/SQLiteProvider';
-export default NativeStorage;

package/dist/storage/providers/NoopProvider.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const provider = {
-    /**
-     * The name of the provider that can be printed to the logs
-     */
-    name: 'NoopProvider',
-    /**
-     * Initializes the storage provider
-     */
-    init() {
-        // do nothing
-    },
-    /**
-     * Get the value of a given key or return `null` if it's not available in memory
-     * @param {String} key
-     * @return {Promise<*>}
-     */
-    getItem() {
-        return Promise.resolve(null);
-    },
-    /**
-     * Get multiple key-value pairs for the give array of keys in a batch.
-     */
-    multiGet() {
-        return Promise.resolve([]);
-    },
-    /**
-     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
-     */
-    setItem() {
-        return Promise.resolve();
-    },
-    /**
-     * Stores multiple key-value pairs in a batch
-     */
-    multiSet() {
-        return Promise.resolve();
-    },
-    /**
-     * Merging an existing value with a new one
-     */
-    mergeItem() {
-        return Promise.resolve();
-    },
-    /**
-     * Multiple merging of existing and new values in a batch
-     * This function also removes all nested null values from an object.
-     */
-    multiMerge() {
-        return Promise.resolve([]);
-    },
-    /**
-     * Remove given key and it's value from memory
-     */
-    removeItem() {
-        return Promise.resolve();
-    },
-    /**
-     * Remove given keys and their values from memory
-     */
-    removeItems() {
-        return Promise.resolve();
-    },
-    /**
-     * Clear everything from memory
-     */
-    clear() {
-        return Promise.resolve();
-    },
-    // This is a noop for now in order to keep clients from crashing see https://github.com/Expensify/Expensify/issues/312438
-    setMemoryOnlyKeys() {
-        // do nothing
-    },
-    /**
-     * Returns all keys available in memory
-     */
-    getAllKeys() {
-        return Promise.resolve([]);
-    },
-    /**
-     * Gets the total bytes of the store.
-     * `bytesRemaining` will always be `Number.POSITIVE_INFINITY` since we don't have a hard limit on memory.
-     */
-    getDatabaseSize() {
-        return Promise.resolve({ bytesRemaining: Number.POSITIVE_INFINITY, bytesUsed: 0 });
-    },
-};
-exports.default = provider;

package/dist/storage/providers/SQLiteProvider.d.ts

@@ -1,3 +0,0 @@
-import type StorageProvider from './types';
-declare const provider: StorageProvider;
-export default provider;