react-native-onyx 3.0.73 → 3.0.74

package/dist/OnyxConnectionManager.js

@@ -60,21 +60,18 @@ class OnyxConnectionManager {
      * according to their purpose and effect they produce in the Onyx connection.
      */
     generateConnectionID(connectOptions) {
-        const { key, initWithStoredValues, reuseConnection, waitForCollectionCallback } = connectOptions;
+        const { key, reuseConnection, waitForCollectionCallback } = connectOptions;
         // The current session ID is appended to the connection ID so we can have different connections
         // after an `Onyx.clear()` operation.
         let suffix = `,sessionID=${this.sessionID}`;
         // We will generate a unique ID in any of the following situations:
         // - `reuseConnection` is `false`. That means the subscriber explicitly wants the connection to not be reused.
-        // - `initWithStoredValues` is `false`. This flag changes the subscription flow when set to `false`, so the connection can't be reused.
         // - `key` is a collection key AND `waitForCollectionCallback` is `undefined/false`. This combination needs a new connection at every subscription
         //   in order to send all the collection entries, so the connection can't be reused.
-        if (reuseConnection === false ||
-            initWithStoredValues === false ||
-            (OnyxKeys_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
+        if (reuseConnection === false || (OnyxKeys_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
             suffix += `,uniqueID=${Str.guid()}`;
         }
-        return `onyxKey=${key},initWithStoredValues=${initWithStoredValues !== null && initWithStoredValues !== void 0 ? initWithStoredValues : true},waitForCollectionCallback=${waitForCollectionCallback !== null && waitForCollectionCallback !== void 0 ? waitForCollectionCallback : false}${suffix}`;
+        return `onyxKey=${key},waitForCollectionCallback=${waitForCollectionCallback !== null && waitForCollectionCallback !== void 0 ? waitForCollectionCallback : false}${suffix}`;
     }
     /**
      * Fires all the subscribers callbacks associated with that connection ID.

package/dist/OnyxSnapshotCache.d.ts

@@ -38,12 +38,11 @@ declare class OnyxSnapshotCache {
      * according to their purpose and effect they produce in the useOnyx hook behavior:
      *
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
-     * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
      * Other options like `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
-    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues'>): string;
+    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector'>): string;
     /**
      * Deregister a consumer for a cache key.
      * Decrements reference counter and removes cache entry if no consumers remain.

package/dist/OnyxSnapshotCache.js

@@ -35,17 +35,13 @@ class OnyxSnapshotCache {
      * according to their purpose and effect they produce in the useOnyx hook behavior:
      *
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
-     * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
      * Other options like `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer(options) {
-        var _a;
         const selectorID = (options === null || options === void 0 ? void 0 : options.selector) ? this.getSelectorID(options.selector) : 'no_selector';
-        // Create options hash without expensive JSON.stringify
-        const initWithStoredValues = (_a = options === null || options === void 0 ? void 0 : options.initWithStoredValues) !== null && _a !== void 0 ? _a : true;
-        const cacheKey = `${selectorID}_${initWithStoredValues}`;
+        const cacheKey = String(selectorID);
         // Increment reference count for this cache key
         const currentCount = this.cacheKeyRefCounts.get(cacheKey) || 0;
         this.cacheKeyRefCounts.set(cacheKey, currentCount + 1);

package/dist/OnyxUtils.d.ts

@@ -118,9 +118,6 @@ declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionK
 declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
- *
- * @example
- * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
 declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, isProcessingCollectionUpdate?: boolean): void;
 /**

package/dist/OnyxUtils.js

@@ -529,9 +529,6 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
 }
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
- *
- * @example
- * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
 function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCollectionUpdate = false) {
     var _a, _b;
@@ -707,12 +704,11 @@ function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
  * Notifies subscribers and writes current value to cache
  */
 function broadcastUpdate(key, value, hasChanged) {
-    // Update subscribers if the cached value has changed, or when the subscriber specifically requires
-    // all updates regardless of value changes (indicated by initWithStoredValues set to false).
-    if (hasChanged) {
-        OnyxCache_1.default.set(key, value);
+    if (!hasChanged) {
+        return;
     }
-    keyChanged(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false);
+    OnyxCache_1.default.set(key, value);
+    keyChanged(key, value);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -908,9 +904,6 @@ function subscribeToKey(connectOptions) {
     // 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 subscriptionIDs to access the specific list of subscriptionIDs.
     storeKeyBySubscriptions(mapping.key, callbackToStateMapping[subscriptionID].subscriptionID);
-    if (mapping.initWithStoredValues === false) {
-        return subscriptionID;
-    }
     // Commit connection only after init passes
     deferredInitTask.promise
         // This first .then() adds a microtask tick for compatibility reasons and

package/dist/types.d.ts

@@ -178,8 +178,6 @@ type NullishObjectDeep<ObjectType extends object> = {
 type Collection<TKey extends CollectionKeyBase, TValue> = Record<`${TKey}${string}`, TValue>;
 /** Represents the base options used in `Onyx.connect()` method. */
 type BaseConnectOptions = {
-    /** If set to `false`, then the initial data will be only sent to the callback function if it changes. */
-    initWithStoredValues?: boolean;
     /**
      * If set to `false`, the connection won't be reused between other subscribers that are listening to the same Onyx key
      * with the same connect configurations.

package/dist/useOnyx.d.ts

@@ -2,11 +2,6 @@ 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> = {
-    /**
-     * If set to `false`, then no data will be prefilled into the component.
-     * @deprecated This param is going to be removed soon. Use RAM-only keys instead.
-     */
-    initWithStoredValues?: boolean;
     /**
      * If set to `false`, the connection won't be reused between other subscribers that are listening to the same Onyx key
      * with the same connect configurations.

package/dist/useOnyx.js

@@ -83,11 +83,10 @@ function useOnyx(key, options, dependencies = []) {
     const newValueRef = (0, react_1.useRef)(null);
     // Stores the previously result returned by the hook, containing the data from cache and the fetch status.
     // We initialize it to `undefined` and `loading` fetch status to simulate the initial result when the hook is loading from the cache.
-    // However, if `initWithStoredValues` is `false` we set the fetch status to `loaded` since we want to signal that data is ready.
     const resultRef = (0, react_1.useRef)([
         undefined,
         {
-            status: (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false ? 'loaded' : 'loading',
+            status: 'loading',
         },
     ]);
     // Tracks which key has completed its first Onyx connection callback. When this doesn't match the
@@ -110,8 +109,7 @@ function useOnyx(key, options, dependencies = []) {
     // Cache the options key to avoid regenerating it every getSnapshot call
     const cacheKey = (0, react_1.useMemo)(() => OnyxSnapshotCache_1.default.registerConsumer({
         selector: options === null || options === void 0 ? void 0 : options.selector,
-        initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
-    }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues]);
+    }), [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)([]);
@@ -141,23 +139,15 @@ function useOnyx(key, options, dependencies = []) {
     const getSnapshot = (0, react_1.useCallback)(() => {
         var _a, _b, _c;
         // Check if we have any cache for this Onyx key
-        // Don't use cache for first connection with initWithStoredValues: false
-        // Also don't use cache during active data updates (when shouldGetCachedValueRef is true)
+        // Don't use cache during active data updates (when shouldGetCachedValueRef is true)
         const isFirstConnection = connectedKeyRef.current !== key;
-        if (!(isFirstConnection && (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false) && !shouldGetCachedValueRef.current) {
+        if (!shouldGetCachedValueRef.current) {
             const cachedResult = OnyxSnapshotCache_1.default.getCachedResult(key, cacheKey);
             if (cachedResult !== undefined) {
                 resultRef.current = cachedResult;
                 return cachedResult;
             }
         }
-        // We return the initial result right away during the first connection if `initWithStoredValues` is set to `false`.
-        if (isFirstConnection && (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false) {
-            const result = resultRef.current;
-            // Store result in snapshot cache
-            OnyxSnapshotCache_1.default.setCachedResult(key, cacheKey, result);
-            return result;
-        }
         // We get the value from cache while the first connection to Onyx is being made or if the key has changed,
         // so we can return any cached value right away. For the case where the key has changed, If we don't return the cached value right away, then the UI will show the incorrect (previous) value for a brief period which looks like a UI glitch to the user. After the connection is made, we only
         // update `newValueRef` when `Onyx.connect()` callback is fired.
@@ -210,7 +200,7 @@ function useOnyx(key, options, dependencies = []) {
             OnyxSnapshotCache_1.default.setCachedResult(key, cacheKey, resultRef.current);
         }
         return resultRef.current;
-    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, key, memoizedSelector, cacheKey]);
+    }, [key, memoizedSelector, cacheKey]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         // Reset internal state so the hook properly transitions through loading
         // for the new key instead of preserving stale state from the previous one.
@@ -219,7 +209,7 @@ function useOnyx(key, options, dependencies = []) {
             previousValueRef.current = null;
             newValueRef.current = null;
             sourceValueRef.current = undefined;
-            resultRef.current = [undefined, { status: (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false ? 'loaded' : 'loading' }];
+            resultRef.current = [undefined, { status: 'loading' }];
         }
         // Force a cache re-read on every (re)subscription so any side effects from
         // subscribeToKey (e.g. addNullishStorageKey for skippable collection member ids)
@@ -246,7 +236,6 @@ function useOnyx(key, options, dependencies = []) {
                 // Finally, we signal that the store changed, making `getSnapshot()` be called again.
                 onStoreChange();
             },
-            initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
             waitForCollectionCallback: OnyxKeys_1.default.isCollectionKey(key),
             reuseConnection: options === null || options === void 0 ? void 0 : options.reuseConnection,
         });
@@ -259,7 +248,7 @@ function useOnyx(key, options, dependencies = []) {
             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]);
+    }, [key, options === null || options === void 0 ? void 0 : options.reuseConnection]);
     const result = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot);
     return result;
 }

package/package.json

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