react-native-onyx 2.0.63 → 2.0.65

package/API.md

@@ -8,11 +8,11 @@
 <dt><a href="#init">init()</a></dt>
 <dd><p>Initialize the store with actions and listening for storage events</p>
 </dd>
-<dt><a href="#connect">connect(mapping)</a> ⇒</dt>
-<dd><p>Subscribes a react component&#39;s state directly to a store key</p>
+<dt><a href="#connect">connect(connectOptions)</a> ⇒</dt>
+<dd><p>Connects to an Onyx key given the options passed and listens to its changes.</p>
 </dd>
-<dt><a href="#disconnect">disconnect(connectionID)</a></dt>
-<dd><p>Remove the listener for a react component</p>
+<dt><a href="#disconnect">disconnect(connection)</a></dt>
+<dd><p>Disconnects and removes the listener from the Onyx key.</p>
 </dd>
 <dt><a href="#set">set(key, value)</a></dt>
 <dd><p>Write a value to our store with the given key</p>
@@ -60,45 +60,49 @@ Initialize the store with actions and listening for storage events
 **Kind**: global function  
 <a name="connect"></a>
 
-## connect(mapping) ⇒
-Subscribes a react component's state directly to a store key
+## connect(connectOptions) ⇒
+Connects to an Onyx key given the options passed and listens to its changes.
 
 **Kind**: global function  
-**Returns**: an ID to use when calling disconnect  
+**Returns**: The connection object to use when calling `Onyx.disconnect()`.  
 
 | Param | Description |
 | --- | --- |
-| mapping | the mapping information to connect Onyx to the components state |
-| mapping.key | ONYXKEY to subscribe to |
-| [mapping.statePropertyName] | the name of the property in the state to connect the data to |
-| [mapping.withOnyxInstance] | whose setState() method will be called with any changed data      This is used by React components to connect to Onyx |
-| [mapping.callback] | a method that will be called with changed data      This is used by any non-React code to connect to Onyx |
-| [mapping.initWithStoredValues] | If set to false, then no data will be prefilled into the  component |
-| [mapping.waitForCollectionCallback] | If set to true, it will return the entire collection to the callback as a single object |
-| [mapping.selector] | THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.       The sourceData and withOnyx state are passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive       performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally       cause the component to re-render (and that can be expensive from a performance standpoint). |
-| [mapping.initialValue] | THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be passed to the component so that something can be rendered while data is being fetched from the DB. Note that it will not cause the component to have the loading prop set to true. |
+| connectOptions | The options object that will define the behavior of the connection. |
+| connectOptions.key | The Onyx key to subscribe to. |
+| connectOptions.callback | A function that will be called when the Onyx data we are subscribed changes. |
+| connectOptions.waitForCollectionCallback | If set to `true`, it will return the entire collection to the callback as a single object. |
+| connectOptions.withOnyxInstance | The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.** |
+| connectOptions.statePropertyName | The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.** |
+| connectOptions.displayName | The component's display name. **Only used inside `withOnyx()` HOC.** |
+| connectOptions.selector | This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render        when the subset of data changes. Otherwise, any change of data on any property would normally        cause the component to re-render (and that can be expensive from a performance standpoint). |
 
 **Example**  
-```js
-const connectionID = Onyx.connect({
+```ts
+const connection = Onyx.connect({
     key: ONYXKEYS.SESSION,
     callback: onSessionChange,
 });
 ```
 <a name="disconnect"></a>
 
-## disconnect(connectionID)
-Remove the listener for a react component
+## disconnect(connection)
+Disconnects and removes the listener from the Onyx key.
 
 **Kind**: global function  
 
 | Param | Description |
 | --- | --- |
-| connectionID | unique id returned by call to Onyx.connect() |
+| connection | Connection object returned by calling `Onyx.connect()`. |
 
 **Example**  
-```js
-Onyx.disconnect(connectionID);
+```ts
+const connection = Onyx.connect({
+    key: ONYXKEYS.SESSION,
+    callback: onSessionChange,
+});
+
+Onyx.disconnect(connection);
 ```
 <a name="set"></a>
 

package/dist/Onyx.d.ts

@@ -1,44 +1,49 @@
 import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate } from './types';
+import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
 declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, }: InitOptions): void;
 /**
- * Subscribes a react component's state directly to a store key
+ * Connects to an Onyx key given the options passed and listens to its changes.
  *
  * @example
- * const connectionID = Onyx.connect({
+ * ```ts
+ * const connection = Onyx.connect({
  *     key: ONYXKEYS.SESSION,
  *     callback: onSessionChange,
  * });
- *
- * @param mapping the mapping information to connect Onyx to the components state
- * @param mapping.key ONYXKEY to subscribe to
- * @param [mapping.statePropertyName] the name of the property in the state to connect the data to
- * @param [mapping.withOnyxInstance] whose setState() method will be called with any changed data
- *      This is used by React components to connect to Onyx
- * @param [mapping.callback] a method that will be called with changed data
- *      This is used by any non-React code to connect to Onyx
- * @param [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
- *  component. Default is true.
- * @param [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
- * @param [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
- *       The sourceData and withOnyx state are passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive
- *       performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally
- *       cause the component to re-render (and that can be expensive from a performance standpoint).
- * @param [mapping.initialValue] THIS PARAM IS ONLY USED WITH withOnyx().
- * If included, this will be passed to the component so that something can be rendered while data is being fetched from the DB.
- * Note that it will not cause the component to have the loading prop set to true.
- * @returns an ID to use when calling disconnect
+ * ```
+ *
+ * @param connectOptions The options object that will define the behavior of the connection.
+ * @param connectOptions.key The Onyx key to subscribe to.
+ * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
+ * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
+ * @param connectOptions.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
+ *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ *        when the subset of data changes. Otherwise, any change of data on any property would normally
+ *        cause the component to re-render (and that can be expensive from a performance standpoint).
+ * @returns The connection object to use when calling `Onyx.disconnect()`.
  */
-declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TKey>): number;
+declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TKey>): Connection;
 /**
- * Remove the listener for a react component
+ * Disconnects and removes the listener from the Onyx key.
+ *
  * @example
- * Onyx.disconnect(connectionID);
+ * ```ts
+ * const connection = Onyx.connect({
+ *     key: ONYXKEYS.SESSION,
+ *     callback: onSessionChange,
+ * });
+ *
+ * Onyx.disconnect(connection);
+ * ```
  *
- * @param connectionID unique id returned by call to Onyx.connect()
+ * @param connection Connection object returned by calling `Onyx.connect()`.
  */
-declare function disconnect(connectionID: number, keyToRemoveFromEvictionBlocklist?: OnyxKey): void;
+declare function disconnect(connection: Connection): void;
 /**
  * Write a value to our store with the given key
  *

package/dist/Onyx.js

@@ -31,17 +31,13 @@ const underscore_1 = __importDefault(require("underscore"));
 const pick_1 = __importDefault(require("lodash/pick"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
-const createDeferredTask_1 = __importDefault(require("./createDeferredTask"));
 const PerformanceUtils = __importStar(require("./PerformanceUtils"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const logMessages_1 = __importDefault(require("./logMessages"));
-// Keeps track of the last connectionID that was used so we can keep incrementing it
-let lastConnectionID = 0;
-// Connections can be made before `Onyx.init`. They would wait for this task before resolving
-const deferredInitTask = (0, createDeferredTask_1.default)();
+const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 /** Initialize the store with actions and listening for storage events */
 function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, }) {
     var _a;
@@ -61,142 +57,52 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
     }
     OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, safeEvictionKeys);
     // Initialize all of our keys with data provided then give green light to any pending connections
-    Promise.all([OnyxUtils_1.default.addAllSafeEvictionKeysToRecentlyAccessedList(), OnyxUtils_1.default.initializeWithDefaultKeyStates()]).then(deferredInitTask.resolve);
+    Promise.all([OnyxUtils_1.default.addAllSafeEvictionKeysToRecentlyAccessedList(), OnyxUtils_1.default.initializeWithDefaultKeyStates()]).then(OnyxUtils_1.default.getDeferredInitTask().resolve);
 }
 /**
- * Subscribes a react component's state directly to a store key
+ * Connects to an Onyx key given the options passed and listens to its changes.
  *
  * @example
- * const connectionID = Onyx.connect({
+ * ```ts
+ * const connection = Onyx.connect({
  *     key: ONYXKEYS.SESSION,
  *     callback: onSessionChange,
  * });
+ * ```
  *
- * @param mapping the mapping information to connect Onyx to the components state
- * @param mapping.key ONYXKEY to subscribe to
- * @param [mapping.statePropertyName] the name of the property in the state to connect the data to
- * @param [mapping.withOnyxInstance] whose setState() method will be called with any changed data
- *      This is used by React components to connect to Onyx
- * @param [mapping.callback] a method that will be called with changed data
- *      This is used by any non-React code to connect to Onyx
- * @param [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
- *  component. Default is true.
- * @param [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
- * @param [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
- *       The sourceData and withOnyx state are passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive
- *       performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally
- *       cause the component to re-render (and that can be expensive from a performance standpoint).
- * @param [mapping.initialValue] THIS PARAM IS ONLY USED WITH withOnyx().
- * If included, this will be passed to the component so that something can be rendered while data is being fetched from the DB.
- * Note that it will not cause the component to have the loading prop set to true.
- * @returns an ID to use when calling disconnect
+ * @param connectOptions The options object that will define the behavior of the connection.
+ * @param connectOptions.key The Onyx key to subscribe to.
+ * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
+ * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
+ * @param connectOptions.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
+ * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
+ *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ *        when the subset of data changes. Otherwise, any change of data on any property would normally
+ *        cause the component to re-render (and that can be expensive from a performance standpoint).
+ * @returns The connection object to use when calling `Onyx.disconnect()`.
  */
 function connect(connectOptions) {
-    const mapping = connectOptions;
-    const connectionID = lastConnectionID++;
-    const callbackToStateMapping = OnyxUtils_1.default.getCallbackToStateMapping();
-    callbackToStateMapping[connectionID] = mapping;
-    callbackToStateMapping[connectionID].connectionID = connectionID;
-    // When keyChanged is called, a key is passed and the method looks through all the Subscribers in callbackToStateMapping for the matching key to get the connectionID
-    // to avoid having to loop through all the Subscribers all the time (even when just one connection belongs to one key),
-    // We create a mapping from key to lists of connectionIDs to access the specific list of connectionIDs.
-    OnyxUtils_1.default.storeKeyByConnections(mapping.key, callbackToStateMapping[connectionID].connectionID);
-    if (mapping.initWithStoredValues === false) {
-        return connectionID;
-    }
-    // Commit connection only after init passes
-    deferredInitTask.promise
-        .then(() => OnyxUtils_1.default.addKeyToRecentlyAccessedIfNeeded(mapping))
-        .then(() => {
-        // Performance improvement
-        // If the mapping is connected to an onyx key that is not a collection
-        // we can skip the call to getAllKeys() and return an array with a single item
-        if (Boolean(mapping.key) && typeof mapping.key === 'string' && !mapping.key.endsWith('_') && OnyxCache_1.default.getAllKeys().has(mapping.key)) {
-            return new Set([mapping.key]);
-        }
-        return OnyxUtils_1.default.getAllKeys();
-    })
-        .then((keys) => {
-        // We search all the keys in storage to see if any are a "match" for the subscriber we are connecting so that we
-        // can send data back to the subscriber. Note that multiple keys can match as a subscriber could either be
-        // subscribed to a "collection key" or a single key.
-        const matchingKeys = [];
-        keys.forEach((key) => {
-            if (!OnyxUtils_1.default.isKeyMatch(mapping.key, key)) {
-                return;
-            }
-            matchingKeys.push(key);
-        });
-        // If the key being connected to does not exist we initialize the value with null. For subscribers that connected
-        // directly via connect() they will simply get a null value sent to them without any information about which key matched
-        // since there are none matched. In withOnyx() we wait for all connected keys to return a value before rendering the child
-        // component. This null value will be filtered out so that the connected component can utilize defaultProps.
-        if (matchingKeys.length === 0) {
-            if (mapping.key && !OnyxUtils_1.default.isCollectionKey(mapping.key)) {
-                OnyxCache_1.default.addNullishStorageKey(mapping.key);
-            }
-            // Here we cannot use batching because the nullish value is expected to be set immediately for default props
-            // or they will be undefined.
-            OnyxUtils_1.default.sendDataToConnection(mapping, null, undefined, false);
-            return;
-        }
-        // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
-        // into an object and just make a single call. The latter behavior is enabled by providing a waitForCollectionCallback key
-        // combined with a subscription to a collection key.
-        if (typeof mapping.callback === 'function') {
-            if (OnyxUtils_1.default.isCollectionKey(mapping.key)) {
-                if (mapping.waitForCollectionCallback) {
-                    OnyxUtils_1.default.getCollectionDataAndSendAsObject(matchingKeys, mapping);
-                    return;
-                }
-                // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                OnyxUtils_1.default.multiGet(matchingKeys).then((values) => {
-                    values.forEach((val, key) => {
-                        OnyxUtils_1.default.sendDataToConnection(mapping, val, key, true);
-                    });
-                });
-                return;
-            }
-            // If we are not subscribed to a collection key then there's only a single key to send an update for.
-            OnyxUtils_1.default.get(mapping.key).then((val) => OnyxUtils_1.default.sendDataToConnection(mapping, val, mapping.key, true));
-            return;
-        }
-        // If we have a withOnyxInstance that means a React component has subscribed via the withOnyx() HOC and we need to
-        // group collection key member data into an object.
-        if ('withOnyxInstance' in mapping && mapping.withOnyxInstance) {
-            if (OnyxUtils_1.default.isCollectionKey(mapping.key)) {
-                OnyxUtils_1.default.getCollectionDataAndSendAsObject(matchingKeys, mapping);
-                return;
-            }
-            // If the subscriber is not using a collection key then we just send a single value back to the subscriber
-            OnyxUtils_1.default.get(mapping.key).then((val) => OnyxUtils_1.default.sendDataToConnection(mapping, val, mapping.key, true));
-            return;
-        }
-        console.error('Warning: Onyx.connect() was found without a callback or withOnyxInstance');
-    });
-    // The connectionID is returned back to the caller so that it can be used to clean up the connection when it's no longer needed
-    // by calling Onyx.disconnect(connectionID).
-    return connectionID;
+    return OnyxConnectionManager_1.default.connect(connectOptions);
 }
 /**
- * Remove the listener for a react component
+ * Disconnects and removes the listener from the Onyx key.
+ *
  * @example
- * Onyx.disconnect(connectionID);
+ * ```ts
+ * const connection = Onyx.connect({
+ *     key: ONYXKEYS.SESSION,
+ *     callback: onSessionChange,
+ * });
+ *
+ * Onyx.disconnect(connection);
+ * ```
  *
- * @param connectionID unique id returned by call to Onyx.connect()
+ * @param connection Connection object returned by calling `Onyx.connect()`.
  */
-function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
-    const callbackToStateMapping = OnyxUtils_1.default.getCallbackToStateMapping();
-    if (!callbackToStateMapping[connectionID]) {
-        return;
-    }
-    // Remove this key from the eviction block list as we are no longer
-    // subscribing to it and it should be safe to delete again
-    if (keyToRemoveFromEvictionBlocklist) {
-        OnyxUtils_1.default.removeFromEvictionBlockList(keyToRemoveFromEvictionBlocklist, connectionID);
-    }
-    OnyxUtils_1.default.deleteKeyByConnections(lastConnectionID);
-    delete callbackToStateMapping[connectionID];
+function disconnect(connection) {
+    OnyxConnectionManager_1.default.disconnect(connection);
 }
 /**
  * Write a value to our store with the given key
@@ -510,8 +416,8 @@ function clear(keysToPreserve = []) {
                 const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
                 if (newValue !== oldValue) {
                     OnyxCache_1.default.set(key, newValue);
-                    const collectionKey = key.substring(0, key.indexOf('_') + 1);
-                    if (collectionKey) {
+                    const collectionKey = OnyxUtils_1.default.getCollectionKey(key);
+                    if (OnyxUtils_1.default.isCollectionKey(collectionKey)) {
                         if (!keyValuesToResetAsCollection[collectionKey]) {
                             keyValuesToResetAsCollection[collectionKey] = {};
                         }

package/dist/OnyxConnectionManager.d.ts

@@ -0,0 +1,69 @@
+import type { ConnectOptions } from './Onyx';
+import type { OnyxKey } from './types';
+/**
+ * Represents the connection object returned by `Onyx.connect()`.
+ */
+type Connection = {
+    /**
+     * The ID used to identify this particular connection.
+     */
+    id: string;
+    /**
+     * The ID of the subscriber's callback that is associated to this connection.
+     */
+    callbackID: string;
+};
+/**
+ * Manages Onyx connections of `Onyx.connect()`, `useOnyx()` and `withOnyx()` subscribers.
+ */
+declare class OnyxConnectionManager {
+    /**
+     * A map where the key is the connection ID generated inside `connect()` and the value is the metadata of that connection.
+     */
+    private connectionsMap;
+    /**
+     * Stores the last generated callback ID which will be incremented when making a new connection.
+     */
+    private lastCallbackID;
+    constructor();
+    /**
+     * Generates a connection ID based on the `connectOptions` object passed to the function.
+     *
+     * The properties used to generate the ID are handpicked for performance reasons and
+     * according to their purpose and effect they produce in the Onyx connection.
+     */
+    private generateConnectionID;
+    /**
+     * Fires all the subscribers callbacks associated with that connection ID.
+     */
+    private fireCallbacks;
+    /**
+     * Connects to an Onyx key given the options passed and listens to its changes.
+     *
+     * @param connectOptions The options object that will define the behavior of the connection.
+     * @returns The connection object to use when calling `disconnect()`.
+     */
+    connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TKey>): Connection;
+    /**
+     * Disconnects and removes the listener from the Onyx key.
+     *
+     * @param connection Connection object returned by calling `connect()`.
+     */
+    disconnect(connection: Connection): void;
+    /**
+     * Disconnect all subscribers from Onyx.
+     */
+    disconnectAll(): void;
+    /**
+     * Adds the connection to the eviction block list. Connections added to this list can never be evicted.
+     * */
+    addToEvictionBlockList(connection: Connection): void;
+    /**
+     * Removes a connection previously added to this list
+     * which will enable it to be evicted again.
+     */
+    removeFromEvictionBlockList(connection: Connection): void;
+}
+declare const connectionManager: OnyxConnectionManager;
+export default connectionManager;
+export type { Connection };

package/dist/OnyxConnectionManager.js

@@ -0,0 +1,195 @@
+"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 bindAll_1 = __importDefault(require("lodash/bindAll"));
+const Logger = __importStar(require("./Logger"));
+const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const Str = __importStar(require("./Str"));
+const utils_1 = __importDefault(require("./utils"));
+/**
+ * Manages Onyx connections of `Onyx.connect()`, `useOnyx()` and `withOnyx()` subscribers.
+ */
+class OnyxConnectionManager {
+    constructor() {
+        this.connectionsMap = new Map();
+        this.lastCallbackID = 0;
+        // Binds all public methods to prevent problems with `this`.
+        (0, bindAll_1.default)(this, 'generateConnectionID', 'fireCallbacks', 'connect', 'disconnect', 'disconnectAll', 'addToEvictionBlockList', 'removeFromEvictionBlockList');
+    }
+    /**
+     * Generates a connection ID based on the `connectOptions` object passed to the function.
+     *
+     * The properties used to generate the ID are handpicked for performance reasons and
+     * according to their purpose and effect they produce in the Onyx connection.
+     */
+    generateConnectionID(connectOptions) {
+        var _a, _b;
+        let suffix = '';
+        // We will generate a unique ID in any of the following situations:
+        // - `connectOptions.reuseConnection` is `false`. That means the subscriber explicitly wants the connection to not be reused.
+        // - `connectOptions.initWithStoredValues` is `false`. This flag changes the subscription flow when set to `false`, so the connection can't be reused.
+        // - `withOnyxInstance` is defined inside `connectOptions`. That means the subscriber is a `withOnyx` HOC and therefore doesn't support connection reuse.
+        if (connectOptions.reuseConnection === false || connectOptions.initWithStoredValues === false || utils_1.default.hasWithOnyxInstance(connectOptions)) {
+            suffix += `,uniqueID=${Str.guid()}`;
+        }
+        return `onyxKey=${connectOptions.key},initWithStoredValues=${(_a = connectOptions.initWithStoredValues) !== null && _a !== void 0 ? _a : true},waitForCollectionCallback=${(_b = connectOptions.waitForCollectionCallback) !== null && _b !== void 0 ? _b : false}${suffix}`;
+    }
+    /**
+     * Fires all the subscribers callbacks associated with that connection ID.
+     */
+    fireCallbacks(connectionID) {
+        const connection = this.connectionsMap.get(connectionID);
+        connection === null || connection === void 0 ? void 0 : connection.callbacks.forEach((callback) => {
+            callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
+        });
+    }
+    /**
+     * Connects to an Onyx key given the options passed and listens to its changes.
+     *
+     * @param connectOptions The options object that will define the behavior of the connection.
+     * @returns The connection object to use when calling `disconnect()`.
+     */
+    connect(connectOptions) {
+        const connectionID = this.generateConnectionID(connectOptions);
+        let connectionMetadata = this.connectionsMap.get(connectionID);
+        let subscriptionID;
+        const callbackID = String(this.lastCallbackID++);
+        // If there is no connection yet for that connection ID, we create a new one.
+        if (!connectionMetadata) {
+            let callback;
+            // If the subscriber is a `withOnyx` HOC we don't define `callback` as the HOC will use
+            // its own logic to handle the data.
+            if (!utils_1.default.hasWithOnyxInstance(connectOptions)) {
+                callback = (value, key) => {
+                    const createdConnection = this.connectionsMap.get(connectionID);
+                    if (createdConnection) {
+                        // We signal that the first connection was made and now any new subscribers
+                        // can fire their callbacks immediately with the cached value when connecting.
+                        createdConnection.isConnectionMade = true;
+                        createdConnection.cachedCallbackValue = value;
+                        createdConnection.cachedCallbackKey = key;
+                        this.fireCallbacks(connectionID);
+                    }
+                };
+            }
+            subscriptionID = OnyxUtils_1.default.subscribeToKey(Object.assign(Object.assign({}, connectOptions), { callback }));
+            connectionMetadata = {
+                subscriptionID,
+                onyxKey: connectOptions.key,
+                isConnectionMade: false,
+                callbacks: new Map(),
+            };
+            this.connectionsMap.set(connectionID, connectionMetadata);
+        }
+        // We add the subscriber's callback to the list of callbacks associated with this connection.
+        if (connectOptions.callback) {
+            connectionMetadata.callbacks.set(callbackID, connectOptions.callback);
+        }
+        // If the first connection is already made we want any new subscribers to receive the cached callback value immediately.
+        if (connectionMetadata.isConnectionMade) {
+            // Defer the callback execution to the next tick of the event loop.
+            // This ensures that the current execution flow completes and the result connection object is available when the callback fires.
+            Promise.resolve().then(() => {
+                var _a, _b;
+                (_b = (_a = connectOptions).callback) === null || _b === void 0 ? void 0 : _b.call(_a, connectionMetadata.cachedCallbackValue, connectionMetadata.cachedCallbackKey);
+            });
+        }
+        return { id: connectionID, callbackID };
+    }
+    /**
+     * Disconnects and removes the listener from the Onyx key.
+     *
+     * @param connection Connection object returned by calling `connect()`.
+     */
+    disconnect(connection) {
+        if (!connection) {
+            Logger.logInfo(`[ConnectionManager] Attempted to disconnect passing an undefined connection object.`);
+            return;
+        }
+        const connectionMetadata = this.connectionsMap.get(connection.id);
+        if (!connectionMetadata) {
+            Logger.logInfo(`[ConnectionManager] Attempted to disconnect but no connection was found.`);
+            return;
+        }
+        // Removes the callback from the connection's callbacks map.
+        connectionMetadata.callbacks.delete(connection.callbackID);
+        // If the connection's callbacks map is empty we can safely unsubscribe from the Onyx key.
+        if (connectionMetadata.callbacks.size === 0) {
+            OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
+            this.removeFromEvictionBlockList(connection);
+            this.connectionsMap.delete(connection.id);
+        }
+    }
+    /**
+     * Disconnect all subscribers from Onyx.
+     */
+    disconnectAll() {
+        this.connectionsMap.forEach((connectionMetadata, connectionID) => {
+            OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
+            connectionMetadata.callbacks.forEach((_, callbackID) => {
+                this.removeFromEvictionBlockList({ id: connectionID, callbackID });
+            });
+        });
+        this.connectionsMap.clear();
+    }
+    /**
+     * Adds the connection to the eviction block list. Connections added to this list can never be evicted.
+     * */
+    addToEvictionBlockList(connection) {
+        var _a;
+        const connectionMetadata = this.connectionsMap.get(connection.id);
+        if (!connectionMetadata) {
+            return;
+        }
+        const evictionBlocklist = OnyxUtils_1.default.getEvictionBlocklist();
+        if (!evictionBlocklist[connectionMetadata.onyxKey]) {
+            evictionBlocklist[connectionMetadata.onyxKey] = [];
+        }
+        (_a = evictionBlocklist[connectionMetadata.onyxKey]) === null || _a === void 0 ? void 0 : _a.push(`${connection.id}_${connection.callbackID}`);
+    }
+    /**
+     * Removes a connection previously added to this list
+     * which will enable it to be evicted again.
+     */
+    removeFromEvictionBlockList(connection) {
+        var _a, _b, _c;
+        const connectionMetadata = this.connectionsMap.get(connection.id);
+        if (!connectionMetadata) {
+            return;
+        }
+        const evictionBlocklist = OnyxUtils_1.default.getEvictionBlocklist();
+        evictionBlocklist[connectionMetadata.onyxKey] =
+            (_b = (_a = evictionBlocklist[connectionMetadata.onyxKey]) === null || _a === void 0 ? void 0 : _a.filter((evictionKey) => evictionKey !== `${connection.id}_${connection.callbackID}`)) !== null && _b !== void 0 ? _b : [];
+        // Remove the key if there are no more subscribers.
+        if (((_c = evictionBlocklist[connectionMetadata.onyxKey]) === null || _c === void 0 ? void 0 : _c.length) === 0) {
+            delete evictionBlocklist[connectionMetadata.onyxKey];
+        }
+    }
+}
+const connectionManager = new OnyxConnectionManager();
+exports.default = connectionManager;