react-native-onyx 3.0.94 → 3.0.95

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.94",
+  "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;