react-native-onyx 2.0.82 → 2.0.84

package/dist/GlobalSettings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Stores settings from Onyx.init globally so they can be made accessible by other parts of the library.
+ */
+declare const globalSettings: {
+    enablePerformanceMetrics: boolean;
+};
+type GlobalSettings = typeof globalSettings;
+declare function addGlobalSettingsChangeListener(listener: (settings: GlobalSettings) => unknown): () => void;
+declare function setPerformanceMetricsEnabled(enabled: boolean): void;
+declare function isPerformanceMetricsEnabled(): boolean;
+export { setPerformanceMetricsEnabled, isPerformanceMetricsEnabled, addGlobalSettingsChangeListener };

package/dist/GlobalSettings.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Stores settings from Onyx.init globally so they can be made accessible by other parts of the library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addGlobalSettingsChangeListener = exports.isPerformanceMetricsEnabled = exports.setPerformanceMetricsEnabled = void 0;
+const globalSettings = {
+    enablePerformanceMetrics: false,
+};
+const listeners = new Set();
+function addGlobalSettingsChangeListener(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+exports.addGlobalSettingsChangeListener = addGlobalSettingsChangeListener;
+function notifyListeners() {
+    listeners.forEach((listener) => listener(globalSettings));
+}
+function setPerformanceMetricsEnabled(enabled) {
+    globalSettings.enablePerformanceMetrics = enabled;
+    notifyListeners();
+}
+exports.setPerformanceMetricsEnabled = setPerformanceMetricsEnabled;
+function isPerformanceMetricsEnabled() {
+    return globalSettings.enablePerformanceMetrics;
+}
+exports.isPerformanceMetricsEnabled = isPerformanceMetricsEnabled;

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ 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;
+declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  *
@@ -134,7 +134,7 @@ declare function update(data: OnyxUpdate[]): Promise<void>;
  */
 declare function setCollection<TKey extends CollectionKeyBase, TMap extends string>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TMap>): Promise<void>;
 declare const Onyx: {
-    readonly METHOD: {
+    METHOD: {
         readonly SET: "set";
         readonly MERGE: "merge";
         readonly MERGE_COLLECTION: "mergecollection";
@@ -142,17 +142,17 @@ declare const Onyx: {
         readonly MULTI_SET: "multiset";
         readonly CLEAR: "clear";
     };
-    readonly connect: typeof connect;
-    readonly disconnect: typeof disconnect;
-    readonly set: typeof set;
-    readonly multiSet: typeof multiSet;
-    readonly merge: typeof merge;
-    readonly mergeCollection: typeof mergeCollection;
-    readonly setCollection: typeof setCollection;
-    readonly update: typeof update;
-    readonly clear: typeof clear;
-    readonly init: typeof init;
-    readonly registerLogger: typeof Logger.registerLogger;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    set: typeof set;
+    multiSet: typeof multiSet;
+    merge: typeof merge;
+    mergeCollection: typeof mergeCollection;
+    setCollection: typeof setCollection;
+    update: typeof update;
+    clear: typeof clear;
+    init: typeof init;
+    registerLogger: typeof Logger.registerLogger;
 };
 export default Onyx;
 export type { OnyxUpdate, Mapping, ConnectOptions };

package/dist/Onyx.js

@@ -38,9 +38,15 @@ const DevTools_1 = __importDefault(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const logMessages_1 = __importDefault(require("./logMessages"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
+const GlobalSettings = __importStar(require("./GlobalSettings"));
+const metrics_1 = __importDefault(require("./metrics"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, }) {
+function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, enablePerformanceMetrics = false, }) {
     var _a;
+    if (enablePerformanceMetrics) {
+        GlobalSettings.setPerformanceMetricsEnabled(true);
+        applyDecorators();
+    }
     storage_1.default.init();
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
@@ -672,4 +678,23 @@ const Onyx = {
     init,
     registerLogger: Logger.registerLogger,
 };
+function applyDecorators() {
+    // We are reassigning the functions directly so that internal function calls are also decorated
+    /* eslint-disable rulesdir/prefer-actions-set-data */
+    // @ts-expect-error Reassign
+    connect = (0, metrics_1.default)(connect, 'Onyx.connect');
+    // @ts-expect-error Reassign
+    set = (0, metrics_1.default)(set, 'Onyx.set');
+    // @ts-expect-error Reassign
+    multiSet = (0, metrics_1.default)(multiSet, 'Onyx.multiSet');
+    // @ts-expect-error Reassign
+    merge = (0, metrics_1.default)(merge, 'Onyx.merge');
+    // @ts-expect-error Reassign
+    mergeCollection = (0, metrics_1.default)(mergeCollection, 'Onyx.mergeCollection');
+    // @ts-expect-error Reassign
+    update = (0, metrics_1.default)(update, 'Onyx.update');
+    // @ts-expect-error Reassign
+    clear = (0, metrics_1.default)(clear, 'Onyx.clear');
+    /* eslint-enable rulesdir/prefer-actions-set-data */
+}
 exports.default = Onyx;

package/dist/OnyxUtils.js

@@ -39,6 +39,8 @@ const batch_1 = __importDefault(require("./batch"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const createDeferredTask_1 = __importDefault(require("./createDeferredTask"));
+const GlobalSettings = __importStar(require("./GlobalSettings"));
+const metrics_1 = __importDefault(require("./metrics"));
 // Method constants
 const METHOD = {
     SET: 'set',
@@ -1161,4 +1163,48 @@ const OnyxUtils = {
     unsubscribeFromKey,
     getEvictionBlocklist,
 };
+GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
+    if (!enablePerformanceMetrics) {
+        return;
+    }
+    // We are reassigning the functions directly so that internal function calls are also decorated
+    // @ts-expect-error Reassign
+    initStoreValues = (0, metrics_1.default)(initStoreValues, 'OnyxUtils.initStoreValues');
+    // @ts-expect-error Reassign
+    maybeFlushBatchUpdates = (0, metrics_1.default)(maybeFlushBatchUpdates, 'OnyxUtils.maybeFlushBatchUpdates');
+    // @ts-expect-error Reassign
+    batchUpdates = (0, metrics_1.default)(batchUpdates, 'OnyxUtils.batchUpdates');
+    // @ts-expect-error Complex type signature
+    get = (0, metrics_1.default)(get, 'OnyxUtils.get');
+    // @ts-expect-error Reassign
+    getAllKeys = (0, metrics_1.default)(getAllKeys, 'OnyxUtils.getAllKeys');
+    // @ts-expect-error Reassign
+    getCollectionKeys = (0, metrics_1.default)(getCollectionKeys, 'OnyxUtils.getCollectionKeys');
+    // @ts-expect-error Reassign
+    addAllSafeEvictionKeysToRecentlyAccessedList = (0, metrics_1.default)(addAllSafeEvictionKeysToRecentlyAccessedList, 'OnyxUtils.addAllSafeEvictionKeysToRecentlyAccessedList');
+    // @ts-expect-error Reassign
+    keysChanged = (0, metrics_1.default)(keysChanged, 'OnyxUtils.keysChanged');
+    // @ts-expect-error Reassign
+    keyChanged = (0, metrics_1.default)(keyChanged, 'OnyxUtils.keyChanged');
+    // @ts-expect-error Reassign
+    sendDataToConnection = (0, metrics_1.default)(sendDataToConnection, 'OnyxUtils.sendDataToConnection');
+    // @ts-expect-error Reassign
+    scheduleSubscriberUpdate = (0, metrics_1.default)(scheduleSubscriberUpdate, 'OnyxUtils.scheduleSubscriberUpdate');
+    // @ts-expect-error Reassign
+    scheduleNotifyCollectionSubscribers = (0, metrics_1.default)(scheduleNotifyCollectionSubscribers, 'OnyxUtils.scheduleNotifyCollectionSubscribers');
+    // @ts-expect-error Reassign
+    remove = (0, metrics_1.default)(remove, 'OnyxUtils.remove');
+    // @ts-expect-error Reassign
+    reportStorageQuota = (0, metrics_1.default)(reportStorageQuota, 'OnyxUtils.reportStorageQuota');
+    // @ts-expect-error Complex type signature
+    evictStorageAndRetry = (0, metrics_1.default)(evictStorageAndRetry, 'OnyxUtils.evictStorageAndRetry');
+    // @ts-expect-error Reassign
+    broadcastUpdate = (0, metrics_1.default)(broadcastUpdate, 'OnyxUtils.broadcastUpdate');
+    // @ts-expect-error Reassign
+    initializeWithDefaultKeyStates = (0, metrics_1.default)(initializeWithDefaultKeyStates, 'OnyxUtils.initializeWithDefaultKeyStates');
+    // @ts-expect-error Complex type signature
+    multiGet = (0, metrics_1.default)(multiGet, 'OnyxUtils.multiGet');
+    // @ts-expect-error Reassign
+    subscribeToKey = (0, metrics_1.default)(subscribeToKey, 'OnyxUtils.subscribeToKey');
+});
 exports.default = OnyxUtils;

package/dist/dependencies/ModuleProxy.d.ts

@@ -0,0 +1,10 @@
+type ImportType = ReturnType<typeof require>;
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+declare const createModuleProxy: <TModule>(getModule: () => ImportType) => TModule;
+declare class OptionalDependencyNotInstalledError extends Error {
+    constructor(name: string);
+}
+export { createModuleProxy, OptionalDependencyNotInstalledError };

package/dist/dependencies/ModuleProxy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalDependencyNotInstalledError = exports.createModuleProxy = void 0;
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+const createModuleProxy = (getModule) => {
+    const holder = { module: undefined };
+    const proxy = new Proxy(holder, {
+        get: (target, property) => {
+            if (property === '$$typeof') {
+                // If inlineRequires is enabled, Metro will look up all imports
+                // with the $$typeof operator. In this case, this will throw the
+                // `OptionalDependencyNotInstalledError` error because we try to access the module
+                // even though we are not using it (Metro does it), so instead we return undefined
+                // to bail out of inlineRequires here.
+                return undefined;
+            }
+            if (target.module == null) {
+                // lazy initialize module via require()
+                // caller needs to make sure the require() call is wrapped in a try/catch
+                // eslint-disable-next-line no-param-reassign
+                target.module = getModule();
+            }
+            return target.module[property];
+        },
+    });
+    return proxy;
+};
+exports.createModuleProxy = createModuleProxy;
+class OptionalDependencyNotInstalledError extends Error {
+    constructor(name) {
+        super(`${name} is not installed!`);
+    }
+}
+exports.OptionalDependencyNotInstalledError = OptionalDependencyNotInstalledError;

package/dist/dependencies/PerformanceProxy/index.d.ts

@@ -0,0 +1 @@
+export default performance;

package/dist/dependencies/PerformanceProxy/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Use the existing performance API on web
+exports.default = performance;

package/dist/dependencies/PerformanceProxy/index.native.d.ts

@@ -0,0 +1,20 @@
+declare const PerformanceProxy: {
+    timeOrigin: number;
+    now: () => number;
+    mark: (markName: string, markOptions?: import("react-native-performance/lib/typescript/performance").MarkOptions | undefined) => import("react-native-performance").PerformanceMark;
+    clearMarks: (name?: string | undefined) => void;
+    measure: (measureName: string, startOrMeasureOptions?: import("react-native-performance/lib/typescript/performance").StartOrMeasureOptions, endMark?: string | number | undefined) => import("react-native-performance").PerformanceMeasure;
+    clearMeasures: (name?: string | undefined) => void;
+    metric: (name: string, valueOrOptions: import("react-native-performance/lib/typescript/performance").ValueOrOptions) => import("react-native-performance").PerformanceMetric;
+    clearMetrics: (name?: string | undefined) => void;
+    getEntries: () => import("react-native-performance").PerformanceEntry[];
+    getEntriesByName: (name: string, type?: import("react-native-performance").EntryType | undefined) => import("react-native-performance").PerformanceEntry[];
+    getEntriesByType: {
+        (type: "measure"): import("react-native-performance").PerformanceMeasure[];
+        (type: "mark"): import("react-native-performance").PerformanceMark[];
+        (type: "resource"): import("react-native-performance").PerformanceResourceTiming[];
+        (type: "metric"): import("react-native-performance").PerformanceMetric[];
+        (type: "react-native-mark"): import("react-native-performance").PerformanceReactNativeMark[];
+    };
+};
+export default PerformanceProxy;

package/dist/dependencies/PerformanceProxy/index.native.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleProxy_1 = require("../ModuleProxy");
+const PerformanceProxy = (0, ModuleProxy_1.createModuleProxy)(() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('react-native-performance').default;
+    }
+    catch (_a) {
+        throw new ModuleProxy_1.OptionalDependencyNotInstalledError('react-native-performance');
+    }
+});
+exports.default = PerformanceProxy;

package/dist/metrics.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a function with metrics capturing logic
+ */
+declare function decorateWithMetrics<Args extends unknown[], ReturnType>(func: (...args: Args) => ReturnType, alias?: string): {
+    (...args: Args): ReturnType;
+    name: string;
+};
+export default decorateWithMetrics;

package/dist/metrics.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PerformanceProxy_1 = __importDefault(require("./dependencies/PerformanceProxy"));
+const decoratedAliases = new Set();
+/**
+ * Capture a measurement between the start mark and now
+ */
+function measureMarkToNow(startMark, detail) {
+    PerformanceProxy_1.default.measure(`${startMark.name} [${startMark.detail.args.toString()}]`, {
+        start: startMark.startTime,
+        end: PerformanceProxy_1.default.now(),
+        detail: Object.assign(Object.assign({}, startMark.detail), detail),
+    });
+}
+function isPromiseLike(value) {
+    return value != null && typeof value === 'object' && 'then' in value;
+}
+/**
+ * Wraps a function with metrics capturing logic
+ */
+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 = PerformanceProxy_1.default.mark(alias, { detail: { args, alias } });
+        const originalReturnValue = func(...args);
+        if (isPromiseLike(originalReturnValue)) {
+            /*
+             * The handlers added here are not affecting the original promise
+             * They create a separate chain that's not exposed (returned) to the original caller
+             */
+            originalReturnValue
+                .then((result) => {
+                measureMarkToNow(mark, { result });
+            })
+                .catch((error) => {
+                measureMarkToNow(mark, { error });
+            });
+            return originalReturnValue;
+        }
+        measureMarkToNow(mark, { result: originalReturnValue });
+        return originalReturnValue;
+    }
+    decorated.name = `${alias}_DECORATED`;
+    return decorated;
+}
+exports.default = decorateWithMetrics;

package/dist/storage/index.d.ts

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

package/dist/storage/index.js

@@ -30,6 +30,8 @@ const Logger = __importStar(require("../Logger"));
 const platforms_1 = __importDefault(require("./platforms"));
 const InstanceSync_1 = __importDefault(require("./InstanceSync"));
 const MemoryOnlyProvider_1 = __importDefault(require("./providers/MemoryOnlyProvider"));
+const GlobalSettings = __importStar(require("../GlobalSettings"));
+const metrics_1 = __importDefault(require("../metrics"));
 let provider = platforms_1.default;
 let shouldKeepInstancesSync = false;
 let finishInitalization;
@@ -71,7 +73,7 @@ function tryOrDegradePerformance(fn, waitForInitialization = true) {
         });
     });
 }
-const Storage = {
+const storage = {
     /**
      * Returns the storage provider currently in use
      */
@@ -184,4 +186,20 @@ const Storage = {
         InstanceSync_1.default.init(onStorageKeyChanged, this);
     },
 };
-exports.default = Storage;
+GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
+    if (!enablePerformanceMetrics) {
+        return;
+    }
+    // Apply decorators
+    storage.getItem = (0, metrics_1.default)(storage.getItem, 'Storage.getItem');
+    storage.multiGet = (0, metrics_1.default)(storage.multiGet, 'Storage.multiGet');
+    storage.setItem = (0, metrics_1.default)(storage.setItem, 'Storage.setItem');
+    storage.multiSet = (0, metrics_1.default)(storage.multiSet, 'Storage.multiSet');
+    storage.mergeItem = (0, metrics_1.default)(storage.mergeItem, 'Storage.mergeItem');
+    storage.multiMerge = (0, metrics_1.default)(storage.multiMerge, 'Storage.multiMerge');
+    storage.removeItem = (0, metrics_1.default)(storage.removeItem, 'Storage.removeItem');
+    storage.removeItems = (0, metrics_1.default)(storage.removeItems, 'Storage.removeItems');
+    storage.clear = (0, metrics_1.default)(storage.clear, 'Storage.clear');
+    storage.getAllKeys = (0, metrics_1.default)(storage.getAllKeys, 'Storage.getAllKeys');
+});
+exports.default = storage;

package/dist/types.d.ts

@@ -393,6 +393,11 @@ type InitOptions = {
     shouldSyncMultipleInstances?: boolean;
     /** Enables debugging setState() calls to connected components */
     debugSetState?: boolean;
+    /**
+     * If enabled it will use the performance API to measure the time taken by Onyx operations.
+     * @default false
+     */
+    enablePerformanceMetrics?: boolean;
 };
 type GenericFunction = (...args: any[]) => any;
 /**

package/dist/useOnyx.d.ts

@@ -1,3 +1,4 @@
+import type { DependencyList } from 'react';
 import type { OnyxKey, OnyxValue } from './types';
 type BaseUseOnyxOptions = {
     /**
@@ -40,7 +41,7 @@ type ResultMetadata = {
     status: FetchStatus;
 };
 type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
-declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & Required<UseOnyxSelectorOption<TKey, TReturnValue>>): UseOnyxResult<TReturnValue>;
-declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<NoInfer<TReturnValue>>): UseOnyxResult<TReturnValue>;
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & Required<UseOnyxSelectorOption<TKey, TReturnValue>>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<NoInfer<TReturnValue>>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
 export default useOnyx;
 export type { FetchStatus, ResultMetadata, UseOnyxResult };

package/dist/useOnyx.js

@@ -64,7 +64,7 @@ function getCachedValue(key, selector) {
     const selectedValue = selector ? selector(value) : value;
     return selectedValue !== null && selectedValue !== void 0 ? selectedValue : undefined;
 }
-function useOnyx(key, options) {
+function useOnyx(key, options, dependencies = []) {
     const connectionRef = (0, react_1.useRef)(null);
     const previousKey = (0, usePrevious_1.default)(key);
     // Used to stabilize the selector reference and avoid unnecessary calls to `getSnapshot()`.
@@ -86,6 +86,10 @@ function useOnyx(key, options) {
     // Indicates if it's the first Onyx connection of this hook or not, as we don't want certain use cases
     // in `getSnapshot()` to be satisfied several times.
     const isFirstConnectionRef = (0, react_1.useRef)(true);
+    // Indicates if the hook is connecting to a Onyx key.
+    const isConnectingRef = (0, react_1.useRef)(false);
+    // Stores the `onStoreChange()` function, which can be used to trigger a `getSnapshot()` update when desired.
+    const onStoreChangeFnRef = (0, react_1.useRef)(null);
     // Indicates if we should get the newest cached value from Onyx during `getSnapshot()` execution.
     const shouldGetCachedValueRef = (0, react_1.useRef)(true);
     (0, react_1.useEffect)(() => {
@@ -107,6 +111,17 @@ function useOnyx(key, options) {
         }
         throw new Error(`'${previousKey}' key can't be changed to '${key}'. useOnyx() only supports dynamic keys if they are both collection member keys from the same collection e.g. from 'collection_id1' to 'collection_id2'.`);
     }, [previousKey, key]);
+    (0, react_1.useEffect)(() => {
+        // This effect will only run if the `dependencies` array changes. If it changes it will force the hook
+        // to trigger a `getSnapshot()` update by calling the stored `onStoreChange()` function reference, thus
+        // re-running the hook and returning the latest value to the consumer.
+        if (connectionRef.current === null || isConnectingRef.current || !onStoreChangeFnRef.current) {
+            return;
+        }
+        shouldGetCachedValueRef.current = true;
+        onStoreChangeFnRef.current();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...dependencies]);
     // Mimics withOnyx's checkEvictableKeys() behavior.
     const checkEvictableKey = (0, react_1.useCallback)(() => {
         if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionRef.current) {
@@ -182,9 +197,13 @@ function useOnyx(key, options) {
         return resultRef.current;
     }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.initialValue, key, selectorRef]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
+        isConnectingRef.current = true;
+        onStoreChangeFnRef.current = onStoreChange;
         connectionRef.current = OnyxConnectionManager_1.default.connect({
             key,
             callback: () => {
+                isConnectingRef.current = false;
+                onStoreChangeFnRef.current = onStoreChange;
                 // Signals that the first connection was made, so some logics in `getSnapshot()`
                 // won't be executed anymore.
                 isFirstConnectionRef.current = false;
@@ -204,6 +223,8 @@ function useOnyx(key, options) {
             }
             OnyxConnectionManager_1.default.disconnect(connectionRef.current);
             isFirstConnectionRef.current = false;
+            isConnectingRef.current = false;
+            onStoreChangeFnRef.current = null;
         };
     }, [key, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.reuseConnection, checkEvictableKey]);
     (0, react_1.useEffect)(() => {

package/lib/index.ts

@@ -0,0 +1,51 @@
+import type {ConnectOptions, OnyxUpdate} from './Onyx';
+import Onyx from './Onyx';
+import type {
+    CustomTypeOptions,
+    KeyValueMapping,
+    NullishDeep,
+    OnyxCollection,
+    OnyxEntry,
+    OnyxKey,
+    OnyxValue,
+    Selector,
+    OnyxInputValue,
+    OnyxCollectionInputValue,
+    OnyxInput,
+    OnyxSetInput,
+    OnyxMultiSetInput,
+    OnyxMergeInput,
+    OnyxMergeCollectionInput,
+} from './types';
+import type {FetchStatus, ResultMetadata, UseOnyxResult} from './useOnyx';
+import type {Connection} from './OnyxConnectionManager';
+import useOnyx from './useOnyx';
+import withOnyx from './withOnyx';
+import type {WithOnyxState} from './withOnyx/types';
+
+export default Onyx;
+export {useOnyx, withOnyx};
+export type {
+    ConnectOptions,
+    CustomTypeOptions,
+    FetchStatus,
+    KeyValueMapping,
+    NullishDeep,
+    OnyxCollection,
+    OnyxEntry,
+    OnyxKey,
+    OnyxInputValue,
+    OnyxCollectionInputValue,
+    OnyxInput,
+    OnyxSetInput,
+    OnyxMultiSetInput,
+    OnyxMergeInput,
+    OnyxMergeCollectionInput,
+    OnyxUpdate,
+    OnyxValue,
+    ResultMetadata,
+    Selector,
+    UseOnyxResult,
+    WithOnyxState,
+    Connection,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.82",
+  "version": "2.0.84",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -25,8 +25,7 @@
     "README.md",
     "LICENSE.md"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "lib/index.ts",
   "scripts": {
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",