react-native-onyx 3.0.94 → 3.0.96

package/dist/Onyx.d.ts

@@ -1,5 +1,5 @@
 import * as Logger from './Logger';
-import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
+import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetCollectionInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
 declare function init({ keys, initialKeyStates, evictableKeys, shouldSyncMultipleInstances, enableDevTools, skippableCollectionMemberIDs, ramOnlyKeys, snapshotMergeKeys, }: InitOptions): void;

package/dist/Onyx.js

@@ -55,18 +55,49 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], shouldSync
     OnyxUtils_1.default.setSnapshotMergeKeys(new Set(snapshotMergeKeys));
     OnyxKeys_1.default.setRamOnlyKeys(new Set(ramOnlyKeys));
     if (shouldSyncMultipleInstances) {
-        (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
-            // RAM-only keys should never sync from storage as they may have stale persisted data
-            // from before the key was migrated to RAM-only.
-            if (OnyxKeys_1.default.isRamOnlyKey(key)) {
-                return;
+        // Cross-tab sync (InstanceSync) hands us the full batch of key/value pairs that changed together in
+        // a single write. We process it synchronously, grouping collection members so each affected
+        // collection is notified once (mirroring the local mergeCollection batching) instead of
+        // re-delivering the whole collection per member.
+        (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (pairs) => {
+            const individual = [];
+            const collectionBatches = new Map();
+            for (const [key, value] of pairs) {
+                // RAM-only keys should never sync from storage as they may have stale persisted data
+                // from before the key was migrated to RAM-only.
+                if (OnyxKeys_1.default.isRamOnlyKey(key)) {
+                    continue;
+                }
+                const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
+                const isCollectionMember = !!collectionKey && OnyxKeys_1.default.isCollectionMemberKey(collectionKey, key);
+                // Capture the previous cached value BEFORE cache.set() so keysChanged() can diff old vs new per member.
+                const previousValue = isCollectionMember ? OnyxCache_1.default.get(key) : undefined;
+                OnyxCache_1.default.set(key, value);
+                if (isCollectionMember && collectionKey) {
+                    let batch = collectionBatches.get(collectionKey);
+                    if (!batch) {
+                        batch = { partial: {}, previous: {} };
+                        collectionBatches.set(collectionKey, batch);
+                    }
+                    batch.partial[key] = value;
+                    // Keep the earliest previous value in case the same member appears twice in one batch.
+                    if (!(key in batch.previous)) {
+                        batch.previous[key] = previousValue;
+                    }
+                }
+                else {
+                    individual.push([key, value]);
+                }
+            }
+            // Non-collection keys: notify individually, matching keyChanged() semantics for exact keys.
+            for (const [key, value] of individual) {
+                OnyxUtils_1.default.keyChanged(key, value);
+            }
+            // One keysChanged() per collection notifies the collection-root subscriber once and lets
+            // keysChanged() decide which individual member subscribers actually changed.
+            for (const [collectionKey, { partial, previous }] of collectionBatches) {
+                OnyxUtils_1.default.keysChanged(collectionKey, partial, previous);
             }
-            OnyxCache_1.default.set(key, value);
-            // Check if this is a collection member key to prevent duplicate callbacks
-            // When a collection is updated, individual members sync separately to other tabs
-            // Setting isProcessingCollectionUpdate=true prevents triggering collection callbacks for each individual update
-            const isKeyCollectionMember = OnyxKeys_1.default.isCollectionMember(key);
-            OnyxUtils_1.default.keyChanged(key, value, undefined, isKeyCollectionMember);
         });
     }
     OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, evictableKeys);

package/dist/createMemoizedSelector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Wraps a selector function so that:
+ * - Calling the wrapper with the same input reference twice short-circuits to the cached output
+ *   (cheap `===` check, no recompute).
+ * - Calling with a different input that produces a deep-equal output returns the *previous*
+ *   output reference, so downstream `===` comparisons treat it as unchanged.
+ *
+ * This is the minimum needed for `useSyncExternalStore` to not loop when consumers pass
+ * inline selectors that allocate fresh objects on every call (e.g. `(e) => ({id: e?.id})`):
+ * without the deep-equal fallback, every `getSnapshot` would return a new reference and React
+ * would re-render (or throw "getSnapshot should be cached") indefinitely.
+ *
+ * Stateful by design — each call to `createMemoizedSelector` produces an independent wrapper
+ * with its own `lastInput`/`lastOutput` cache, so a wrapper must not be shared across
+ * subscriptions that can see different inputs.
+ */
+declare function createMemoizedSelector<TInput, TOutput>(selector: (input: TInput) => TOutput): (input: TInput) => TOutput;
+export default createMemoizedSelector;

package/dist/createMemoizedSelector.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fast_equals_1 = require("fast-equals");
+/**
+ * Wraps a selector function so that:
+ * - Calling the wrapper with the same input reference twice short-circuits to the cached output
+ *   (cheap `===` check, no recompute).
+ * - Calling with a different input that produces a deep-equal output returns the *previous*
+ *   output reference, so downstream `===` comparisons treat it as unchanged.
+ *
+ * This is the minimum needed for `useSyncExternalStore` to not loop when consumers pass
+ * inline selectors that allocate fresh objects on every call (e.g. `(e) => ({id: e?.id})`):
+ * without the deep-equal fallback, every `getSnapshot` would return a new reference and React
+ * would re-render (or throw "getSnapshot should be cached") indefinitely.
+ *
+ * Stateful by design — each call to `createMemoizedSelector` produces an independent wrapper
+ * with its own `lastInput`/`lastOutput` cache, so a wrapper must not be shared across
+ * subscriptions that can see different inputs.
+ */
+function createMemoizedSelector(selector) {
+    let lastInput;
+    let lastOutput;
+    let hasComputed = false;
+    return (input) => {
+        if (hasComputed && lastInput === input) {
+            return lastOutput;
+        }
+        const next = selector(input);
+        lastInput = input;
+        if (!hasComputed || !(0, fast_equals_1.deepEqual)(lastOutput, next)) {
+            lastOutput = next;
+            hasComputed = true;
+        }
+        return lastOutput;
+    };
+}
+exports.default = createMemoizedSelector;

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

@@ -1,23 +1,29 @@
-/**
- * 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 { OnyxKey } from '../../types';
-import type { StorageKeyList, OnStorageKeyChanged } from '../providers/types';
+import type { StorageKeyList, OnStorageKeysChanged } from '../providers/types';
 import type StorageProvider from '../providers/types';
 /**
- * Raise an event through `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
+ * Raise cross-tab event(s) for a batch of changed keys. Sending keys together (instead of one event per
+ * key) preserves the write's batch boundary across tabs, so the receiving tab notifies collection
+ * subscribers once for the whole batch — matching the local mergeCollection behavior — instead of
+ * re-delivering the whole collection once per member (O(N^2), which can crash the tab). Large batches are
+ * chunked so no single payload approaches the localStorage quota.
  */
-declare function raiseStorageSyncEvent(onyxKey: OnyxKey): void;
 declare function raiseStorageSyncManyKeysEvent(onyxKeys: StorageKeyList): void;
+/**
+ * Raise an event through `localStorage` to let other tabs know a single key changed.
+ *
+ * This intentionally emits the raw key (the legacy, pre-batching format) rather than a JSON array, so a
+ * tab still running the previous bundle during a deploy keeps receiving single-key updates (a new message,
+ * a pin, a rename, etc.). Only multi-key writes use the batched JSON-array format; the receiver here
+ * understands both. The mixed-version gap is therefore limited to bulk collection writes, which resolve on reload.
+ */
+declare function raiseStorageSyncEvent(onyxKey: OnyxKey): void;
 declare const InstanceSync: {
     shouldBeUsed: boolean;
     /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     * @param {Function} onStorageKeysChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
-    init: (onStorageKeyChanged: OnStorageKeyChanged, store: StorageProvider<unknown>) => void;
+    init: (onStorageKeysChanged: OnStorageKeysChanged, store: StorageProvider<unknown>) => void;
     setItem: typeof raiseStorageSyncEvent;
     removeItem: typeof raiseStorageSyncEvent;
     removeItems: typeof raiseStorageSyncManyKeysEvent;

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

@@ -1,30 +1,130 @@
 "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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 });
+/**
+ * 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.
+ */
+const Logger = __importStar(require("../../Logger"));
 const NoopProvider_1 = __importDefault(require("../providers/NoopProvider"));
 const SYNC_ONYX = 'SYNC_ONYX';
+// localStorage stores values as UTF-16 (~2 bytes/char). The per-origin quota isn't fixed by the spec —
+// it's user-agent dependent and commonly ~5MB — so we keep each SYNC_ONYX payload conservatively small
+// (and pair it with a try/catch in emitSyncEvent). This way a large key batch (e.g. Onyx.clear() on a
+// heavy account, or a bulk import) is split across several events instead of throwing QuotaExceededError.
+// See https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API
+const MAX_SYNC_PAYLOAD_LENGTH = 1000000;
 /**
- * Raise an event through `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
+ * Parses the SYNC_ONYX storage event value.
+ * The payload is a JSON array of the changed keys (a batch). It falls back to treating the raw
+ * value as a single key for backwards compatibility with the previous one-key-per-event format.
  */
-function raiseStorageSyncEvent(onyxKey) {
-    global.localStorage.setItem(SYNC_ONYX, onyxKey);
-    global.localStorage.removeItem(SYNC_ONYX);
+function parseSyncOnyxStorageEventValue(value) {
+    let onyxKeys;
+    try {
+        const parsed = JSON.parse(value);
+        onyxKeys = Array.isArray(parsed) ? parsed : [value];
+    }
+    catch (_a) {
+        onyxKeys = [value];
+    }
+    return onyxKeys;
 }
+/**
+ * Emit a single SYNC_ONYX storage event. Wrapped so a failed cross-tab signal
+ * degrades gracefully — other tabs simply miss this update until their next organic sync/reload — instead
+ * of throwing an uncaught rejection in the writing tab.
+ */
+function emitSyncEvent(value) {
+    try {
+        global.localStorage.setItem(SYNC_ONYX, value);
+        global.localStorage.removeItem(SYNC_ONYX);
+    }
+    catch (error) {
+        Logger.logAlert(`[InstanceSync] Failed to raise storage sync event: ${error}`);
+    }
+}
+/**
+ * Raise cross-tab event(s) for a batch of changed keys. Sending keys together (instead of one event per
+ * key) preserves the write's batch boundary across tabs, so the receiving tab notifies collection
+ * subscribers once for the whole batch — matching the local mergeCollection behavior — instead of
+ * re-delivering the whole collection once per member (O(N^2), which can crash the tab). Large batches are
+ * chunked so no single payload approaches the localStorage quota.
+ */
 function raiseStorageSyncManyKeysEvent(onyxKeys) {
+    if (onyxKeys.length === 0) {
+        return;
+    }
+    let chunk = [];
+    let chunkLength = 2; // accounts for the surrounding `[]`
     for (const onyxKey of onyxKeys) {
-        raiseStorageSyncEvent(onyxKey);
+        const keyLength = onyxKey.length + 3; // quotes + comma separator
+        if (chunk.length > 0 && chunkLength + keyLength > MAX_SYNC_PAYLOAD_LENGTH) {
+            emitSyncEvent(JSON.stringify(chunk));
+            chunk = [];
+            chunkLength = 2;
+        }
+        chunk.push(onyxKey);
+        chunkLength += keyLength;
+    }
+    if (chunk.length > 0) {
+        emitSyncEvent(JSON.stringify(chunk));
     }
 }
+/**
+ * Raise an event through `localStorage` to let other tabs know a single key changed.
+ *
+ * This intentionally emits the raw key (the legacy, pre-batching format) rather than a JSON array, so a
+ * tab still running the previous bundle during a deploy keeps receiving single-key updates (a new message,
+ * a pin, a rename, etc.). Only multi-key writes use the batched JSON-array format; the receiver here
+ * understands both. The mixed-version gap is therefore limited to bulk collection writes, which resolve on reload.
+ */
+function raiseStorageSyncEvent(onyxKey) {
+    emitSyncEvent(onyxKey);
+}
 let storage = NoopProvider_1.default;
 const InstanceSync = {
     shouldBeUsed: true,
     /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     * @param {Function} onStorageKeysChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
-    init: (onStorageKeyChanged, store) => {
+    init: (onStorageKeysChanged, store) => {
         storage = store;
         // This listener will only be triggered by events coming from other tabs
         global.addEventListener('storage', (event) => {
@@ -32,8 +132,8 @@ const InstanceSync = {
             if (event.key !== SYNC_ONYX || !event.newValue) {
                 return;
             }
-            const onyxKey = event.newValue;
-            storage.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
+            const onyxKeys = parseSyncOnyxStorageEventValue(event.newValue);
+            storage.multiGet(onyxKeys).then((pairs) => onStorageKeysChanged(pairs));
         });
     },
     setItem: raiseStorageSyncEvent,

package/dist/storage/index.js

@@ -181,14 +181,14 @@ const storage = {
      */
     getDatabaseSize: () => tryOrDegradePerformance(() => provider.getDatabaseSize()),
     /**
-     * @param onStorageKeyChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
+     * @param onStorageKeysChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
      */
-    keepInstancesSync(onStorageKeyChanged) {
+    keepInstancesSync(onStorageKeysChanged) {
         // If InstanceSync shouldn't be used, it means we're on a native platform and we don't need to keep instances in sync
         if (!InstanceSync_1.default.shouldBeUsed)
             return;
         shouldKeepInstancesSync = true;
-        InstanceSync_1.default.init(onStorageKeyChanged, this);
+        InstanceSync_1.default.init(onStorageKeysChanged, this);
     },
 };
 exports.default = storage;

package/dist/storage/providers/IDBKeyValProvider/classifyError.js

@@ -12,6 +12,12 @@ function classifyIDBError(error) {
     if (message.includes("failed to execute 'put' on 'idbobjectstore'")) {
         return errors_1.StorageErrorClass.INVALID_DATA;
     }
+    // A queued File/Blob whose backing bytes are gone — the source OS file was modified, deleted, or
+    // renamed after being picked, so the structured clone fails at write time. Chromium reports it as
+    // InvalidBlob (Windows) or IOError (macOS). Retrying re-reads the same dead blob and can never succeed.
+    if (message.includes('failed to write blobs')) {
+        return errors_1.StorageErrorClass.INVALID_DATA;
+    }
     // Browser quota exceeded.
     if (name.includes('quotaexceedederror') || message.includes('quotaexceedederror')) {
         return errors_1.StorageErrorClass.CAPACITY;

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

@@ -9,7 +9,8 @@ type DatabaseSize = {
     bytesRemaining: number;
     usageDetails?: Record<string, number>;
 };
-type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => void;
+/** Called with the full batch of key/value pairs that changed together in a single cross-tab sync event. */
+type OnStorageKeysChanged = (pairs: StorageKeyValuePair[]) => void;
 type StorageProvider<TStore> = {
     store: TStore;
     /**
@@ -77,9 +78,9 @@ type StorageProvider<TStore> = {
      */
     classifyError: (error: unknown) => ValueOf<typeof StorageErrorClass>;
     /**
-     * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     * @param onStorageKeysChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
-    keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
+    keepInstancesSync?: (onStorageKeysChanged: OnStorageKeysChanged) => void;
 };
 export default StorageProvider;
-export type { StorageKeyList, StorageKeyValuePair, OnStorageKeyChanged };
+export type { StorageKeyList, StorageKeyValuePair, OnStorageKeysChanged };

package/dist/useOnyx.d.ts

@@ -1,4 +1,3 @@
-import type { DependencyList } from 'react';
 import type { OnyxKey, OnyxValue } from './types';
 type UseOnyxSelector<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>> = (data: OnyxValue<TKey> | undefined) => TReturnValue;
 type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
@@ -21,6 +20,6 @@ type ResultMetadata = {
     status: FetchStatus;
 };
 type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
-declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: UseOnyxOptions<TKey, TReturnValue>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: UseOnyxOptions<TKey, TReturnValue>): UseOnyxResult<TReturnValue>;
 export default useOnyx;
 export type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions, UseOnyxSelector };

package/dist/useOnyx.js

@@ -36,46 +36,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const fast_equals_1 = require("fast-equals");
 const react_1 = require("react");
+const createMemoizedSelector_1 = __importDefault(require("./createMemoizedSelector"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
 const memoizedShallowEqual_1 = __importDefault(require("./memoizedShallowEqual"));
-const useLiveRef_1 = __importDefault(require("./useLiveRef"));
-function useOnyx(key, options, dependencies = []) {
+function useOnyx(key, options) {
     const connectionRef = (0, react_1.useRef)(null);
-    const currentDependenciesRef = (0, useLiveRef_1.default)(dependencies);
     const selector = options === null || options === void 0 ? void 0 : options.selector;
-    // Create memoized version of selector for performance
+    // Create memoized version of selector for performance. It caches by input reference
+    // with a deepEqual fallback on the output to keep the returned reference stable.
     const memoizedSelector = (0, react_1.useMemo)(() => {
         if (!selector) {
             return null;
         }
-        let lastInput;
-        let lastOutput;
-        let lastDependencies = [];
-        let hasComputed = false;
-        return (input) => {
-            const currentDependencies = currentDependenciesRef.current;
-            // Recompute if input changed, dependencies changed, or first time
-            const dependenciesChanged = !(0, fast_equals_1.shallowEqual)(lastDependencies, currentDependencies);
-            if (!hasComputed || lastInput !== input || dependenciesChanged) {
-                const newOutput = selector(input);
-                // Always track the current input to avoid re-running the selector
-                // when the same input is seen again (even if the output didn't change).
-                lastInput = input;
-                // Only update the output reference if it actually changed
-                if (!hasComputed || !(0, fast_equals_1.deepEqual)(lastOutput, newOutput) || dependenciesChanged) {
-                    lastOutput = newOutput;
-                    lastDependencies = [...currentDependencies];
-                    hasComputed = true;
-                }
-            }
-            return lastOutput;
-        };
-    }, [currentDependenciesRef, selector]);
+        return (0, createMemoizedSelector_1.default)(selector);
+    }, [selector]);
     // Stores the previous cached value as it's necessary to compare with the new value in `getSnapshot()`.
     // We initialize it to `null` to simulate that we don't have any value from cache yet.
     const previousValueRef = (0, react_1.useRef)(null);
@@ -109,27 +87,6 @@ function useOnyx(key, options, dependencies = []) {
         selector: options === null || options === void 0 ? void 0 : options.selector,
     }), [key, options === null || options === void 0 ? void 0 : options.selector]);
     (0, react_1.useEffect)(() => () => OnyxSnapshotCache_1.default.deregisterConsumer(key, cacheKey), [key, cacheKey]);
-    // Track previous dependencies to prevent infinite loops
-    const previousDependenciesRef = (0, react_1.useRef)([]);
-    (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.
-        // Deep equality check to prevent infinite loops when dependencies array reference changes
-        // but content remains the same
-        if ((0, fast_equals_1.shallowEqual)(previousDependenciesRef.current, dependencies)) {
-            return;
-        }
-        previousDependenciesRef.current = dependencies;
-        if (connectionRef.current === null || isConnectingRef.current || connectedKeyRef.current !== key || !onStoreChangeFnRef.current) {
-            return;
-        }
-        // Invalidate cache when dependencies change so selector runs with new closure values
-        OnyxSnapshotCache_1.default.invalidateForKey(key);
-        shouldGetCachedValueRef.current = true;
-        onStoreChangeFnRef.current();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [...dependencies]);
     // Tracks the last memoizedSelector reference that getSnapshot() has computed with.
     // When the selector changes, this mismatch forces getSnapshot() to re-evaluate
     // even if all other conditions (isFirstConnection, shouldGetCachedValue, key) are false.

package/package.json

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

package/dist/useLiveRef.d.ts

@@ -1,9 +0,0 @@
-/**
- * Creates a mutable reference to a value, useful when you need to
- * maintain a reference to a value that may change over time without triggering re-renders.
- *
- * @deprecated This hook breaks the Rules of React, and should not be used.
- * The migration effort to remove it safely is not currently planned.
- */
-declare function useLiveRef<T>(value: T): import("react").MutableRefObject<T>;
-export default useLiveRef;

package/dist/useLiveRef.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-/**
- * Creates a mutable reference to a value, useful when you need to
- * maintain a reference to a value that may change over time without triggering re-renders.
- *
- * @deprecated This hook breaks the Rules of React, and should not be used.
- * The migration effort to remove it safely is not currently planned.
- */
-function useLiveRef(value) {
-    const ref = (0, react_1.useRef)(value);
-    ref.current = value;
-    return ref;
-}
-exports.default = useLiveRef;