react-native-onyx 3.0.93 → 3.0.95

package/dist/OnyxCache.js

@@ -286,7 +286,7 @@ class OnyxCache {
         // Initialize frozen snapshots for collection keys
         for (const collectionKey of collectionKeys) {
             if (!this.collectionSnapshots.has(collectionKey)) {
-                this.collectionSnapshots.set(collectionKey, Object.freeze({}));
+                this.collectionSnapshots.set(collectionKey, FROZEN_EMPTY_COLLECTION);
             }
         }
     }
@@ -302,6 +302,7 @@ class OnyxCache {
         const previousSnapshot = this.collectionSnapshots.get(collectionKey);
         const members = {};
         let hasMemberChanges = false;
+        let hasMembers = false;
         // Use the indexed forward lookup for O(collectionMembers) iteration.
         // Falls back to scanning all storageKeys if the index isn't populated yet.
         const memberKeys = OnyxKeys_1.default.getMembersOfCollection(collectionKey);
@@ -318,6 +319,7 @@ class OnyxCache {
             // and should not be included in the frozen collection snapshot.
             if (val !== undefined && val !== null) {
                 members[key] = val;
+                hasMembers = true;
                 // Check if this member's reference changed from the old snapshot
                 if (!hasMemberChanges && (!previousSnapshot || previousSnapshot[key] !== val)) {
                     hasMemberChanges = true;
@@ -342,6 +344,13 @@ class OnyxCache {
         if (!hasMemberChanges && previousSnapshot) {
             return;
         }
+        // When the collection has no members, reuse one shared empty object for every empty
+        // collection. That way reads can tell a collection is empty with a quick `===` check
+        // instead of looping over its keys every time.
+        if (!hasMembers) {
+            this.collectionSnapshots.set(collectionKey, FROZEN_EMPTY_COLLECTION);
+            return;
+        }
         Object.freeze(members);
         this.collectionSnapshots.set(collectionKey, members);
     }
@@ -356,17 +365,18 @@ class OnyxCache {
             this.dirtyCollections.delete(collectionKey);
         }
         const snapshot = this.collectionSnapshots.get(collectionKey);
-        if (utils_1.default.isEmptyObject(snapshot)) {
-            // We check storageKeys.size (not collection-specific keys) to distinguish
-            // "init complete, this collection is genuinely empty" from "init not done yet."
-            // During init, setAllKeys loads ALL keys at once — so if any key exists,
-            // the full storage picture is loaded and an empty collection is truly empty.
-            // Returning undefined before init prevents subscribers from seeing a false empty state.
-            if (this.storageKeys.size > 0) {
-                return FROZEN_EMPTY_COLLECTION;
-            }
+        // We never stored anything for this collection key.
+        if (snapshot === undefined) {
             return undefined;
         }
+        // The collection is empty (it holds our shared empty object). But "empty" is ambiguous
+        // during startup: we can't tell an actually-empty collection apart from one whose data
+        // hasn't loaded yet. Once any key exists, we know setAllKeys has run and loaded everything,
+        // so an empty collection really is empty. Before that, return undefined so subscribers
+        // don't briefly see a collection as empty when it just hasn't loaded.
+        if (snapshot === FROZEN_EMPTY_COLLECTION) {
+            return this.storageKeys.size > 0 ? FROZEN_EMPTY_COLLECTION : undefined;
+        }
         return snapshot;
     }
 }

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/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/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.93",
+  "version": "3.0.95",
   "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;