react-native-onyx 2.0.125 → 2.0.127

package/README.md

@@ -196,16 +196,7 @@ export default withOnyx({
 })(App);
 ```
 
-Differently from `useOnyx()`, `withOnyx()` will delay the rendering of the wrapped component until all keys/entities have been fetched and passed to the component, this can be convenient for simple cases. This however, can really delay your application if many entities are connected to the same component, you can pass an `initialValue` to each key to allow Onyx to eagerly render your component with this value.
-
-```javascript
-export default withOnyx({
-    session: {
-        key: ONYXKEYS.SESSION,
-        initialValue: {}
-    },
-})(App);
-```
+Differently from `useOnyx()`, `withOnyx()` will delay the rendering of the wrapped component until all keys/entities have been fetched and passed to the component, this can be convenient for simple cases. This however, can really delay your application if many entities are connected to the same component.
 
 Additionally, if your component has many keys/entities when your component will mount but will receive many updates as data is fetched from DB and passed down to it, as every key that gets fetched will trigger a `setState` on the `withOnyx` HOC. This might cause re-renders on the initial mounting, preventing the component from mounting/rendering in reasonable time, making your app feel slow and even delaying animations.
 
@@ -221,8 +212,7 @@ const App = ({session, markReadyForHydration}) => (
 // Second argument to funciton is `shouldDelayUpdates`
 export default withOnyx({
     session: {
-        key: ONYXKEYS.SESSION,
-        initialValue: {}
+        key: ONYXKEYS.SESSION
     },
 }, true)(App);
 ```

package/dist/OnyxUtils.js

@@ -562,6 +562,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
                 }
                 const subscriberCallback = subscriber.callback;
                 subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
+                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection[subscriber.key]);
                 continue;
             }
             continue;

package/dist/useOnyx.d.ts

@@ -1,6 +1,7 @@
 import type { DependencyList } from 'react';
 import type { OnyxKey, OnyxValue } from './types';
-type BaseUseOnyxOptions = {
+type UseOnyxSelector<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>> = (data: OnyxValue<TKey> | undefined) => TReturnValue;
+type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
     /**
      * Determines if this key in this subscription is safe to be evicted.
      */
@@ -29,15 +30,6 @@ type BaseUseOnyxOptions = {
      * is not there, it will log an alert, as it means we are using data that no one loaded and that's most probably a bug.
      */
     canBeMissing?: boolean;
-};
-type UseOnyxInitialValueOption<TInitialValue> = {
-    /**
-     * This value will be returned by the hook on the first render while the data is being read from Onyx.
-     */
-    initialValue?: TInitialValue;
-};
-type UseOnyxSelector<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>> = (data: OnyxValue<TKey> | undefined) => TReturnValue;
-type UseOnyxSelectorOption<TKey extends OnyxKey, TReturnValue> = {
     /**
      * This will be used to subscribe to a subset of an Onyx key's data.
      * Using this setting on `useOnyx` can have very positive performance benefits because the component will only re-render
@@ -47,14 +39,12 @@ type UseOnyxSelectorOption<TKey extends OnyxKey, TReturnValue> = {
      */
     selector?: UseOnyxSelector<TKey, TReturnValue>;
 };
-type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & UseOnyxSelectorOption<TKey, TReturnValue>;
 type FetchStatus = 'loading' | 'loaded';
 type ResultMetadata<TValue> = {
     status: FetchStatus;
     sourceValue?: NonNullable<TValue> | undefined;
 };
 type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata<TValue>];
-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>;
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: UseOnyxOptions<TKey, TReturnValue>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
 export default useOnyx;
 export type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions };

package/dist/useOnyx.js

@@ -141,12 +141,6 @@ function useOnyx(key, options, dependencies = []) {
             newValueRef.current = undefined;
             newFetchStatus = 'loading';
         }
-        // If data is not present in cache and `initialValue` is set during the first connection,
-        // we set the new value to `initialValue` and fetch status to `loaded` since we already have some data to return to the consumer.
-        if (isFirstConnectionRef.current && !hasCacheForKey && (options === null || options === void 0 ? void 0 : options.initialValue) !== undefined) {
-            newValueRef.current = options.initialValue;
-            newFetchStatus = 'loaded';
-        }
         // We do a deep equality check if `selector` is defined, since each `tryGetCachedValue()` call will
         // generate a plain new primitive/object/array that was created using the `selector` function.
         // For the other cases we will only deal with object reference checks, so just a shallow equality check is enough.
@@ -183,7 +177,7 @@ function useOnyx(key, options, dependencies = []) {
             }
         }
         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, options === null || options === void 0 ? void 0 : options.canBeMissing, key, selectorRef]);
+    }, [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.canBeMissing, key, selectorRef]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         isConnectingRef.current = true;
         onStoreChangeFnRef.current = onStoreChange;

package/dist/withOnyx/index.js

@@ -39,7 +39,7 @@ const OnyxCache_1 = __importDefault(require("../OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("../OnyxConnectionManager"));
 // This is a list of keys that can exist on a `mapping`, but are not directly related to loading data from Onyx. When the keys of a mapping are looped over to check
 // if a key has changed, it's a good idea to skip looking at these properties since they would have unexpected results.
-const mappingPropertiesToIgnoreChangesTo = ['initialValue', 'allowStaleData'];
+const mappingPropertiesToIgnoreChangesTo = ['allowStaleData'];
 /**
  * Returns the display name of a component
  */
@@ -85,11 +85,8 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                 this.activeConnections = {};
                 const cachedState = mapOnyxToStateEntries(mapOnyxToState).reduce((resultObj, [propName, mapping]) => {
                     const key = Str.result(mapping.key, props);
-                    let value = OnyxUtils_1.default.tryGetCachedValue(key, mapping);
+                    const value = OnyxUtils_1.default.tryGetCachedValue(key, mapping);
                     const hasCacheForKey = OnyxCache_1.default.hasCacheForKey(key);
-                    if (!hasCacheForKey && !value && mapping.initialValue) {
-                        value = mapping.initialValue;
-                    }
                     /**
                      * If we have a pending merge for a key it could mean that data is being set via Onyx.merge() and someone expects a component to have this data immediately.
                      *
@@ -220,15 +217,8 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                         if (key === 'loading') {
                             return result;
                         }
-                        const initialValue = mapOnyxToState[key].initialValue;
-                        // If initialValue is there and the state contains something different it means
-                        // an update has already been received and we can discard the value we are trying to hydrate
-                        if (initialValue !== undefined && prevState[key] !== undefined && prevState[key] !== initialValue && prevState[key] !== null) {
-                            // eslint-disable-next-line no-param-reassign
-                            result[key] = prevState[key];
-                        }
-                        else if (prevState[key] !== undefined && prevState[key] !== null) {
-                            // if value is already there (without initial value) then we can discard the value we are trying to hydrate
+                        // if value is already there then we can discard the value we are trying to hydrate
+                        if (prevState[key] !== undefined && prevState[key] !== null) {
                             // eslint-disable-next-line no-param-reassign
                             result[key] = prevState[key];
                         }

package/dist/withOnyx/types.d.ts

@@ -9,18 +9,6 @@ type BaseMapping<TComponentProps, TOnyxProps> = {
     initWithStoredValues?: boolean;
     allowStaleData?: boolean;
 };
-/**
- * Represents the base mapping options when an Onyx collection key is supplied.
- */
-type CollectionBaseMapping<TOnyxKey extends CollectionKeyBase> = {
-    initialValue?: OnyxCollection<KeyValueMapping[TOnyxKey]>;
-};
-/**
- * Represents the base mapping options when an Onyx non-collection key is supplied.
- */
-type EntryBaseMapping<TOnyxKey extends OnyxKey> = {
-    initialValue?: OnyxEntry<KeyValueMapping[TOnyxKey]>;
-};
 /**
  * Represents the string / function `key` mapping option between an Onyx key and the component's prop.
  *
@@ -87,7 +75,7 @@ type BaseMappingFunctionKeyAndSelector<TComponentProps, TOnyxProps, TReturnType,
 /**
  * Represents the mapping options between an Onyx key and the component's prop with all its possibilities.
  */
-type Mapping<TComponentProps, TOnyxProps, TOnyxProp extends keyof TOnyxProps, TOnyxKey extends OnyxKey> = BaseMapping<TComponentProps, TOnyxProps> & EntryBaseMapping<TOnyxKey> & (BaseMappingKey<TComponentProps, TOnyxProps, TOnyxProp, TOnyxKey, OnyxEntry<KeyValueMapping[TOnyxKey]>> | BaseMappingStringKeyAndSelector<TComponentProps, TOnyxProps, TOnyxProps[TOnyxProp], TOnyxKey> | BaseMappingFunctionKeyAndSelector<TComponentProps, TOnyxProps, TOnyxProps[TOnyxProp], TOnyxKey>);
+type Mapping<TComponentProps, TOnyxProps, TOnyxProp extends keyof TOnyxProps, TOnyxKey extends OnyxKey> = BaseMapping<TComponentProps, TOnyxProps> & (BaseMappingKey<TComponentProps, TOnyxProps, TOnyxProp, TOnyxKey, OnyxEntry<KeyValueMapping[TOnyxKey]>> | BaseMappingStringKeyAndSelector<TComponentProps, TOnyxProps, TOnyxProps[TOnyxProp], TOnyxKey> | BaseMappingFunctionKeyAndSelector<TComponentProps, TOnyxProps, TOnyxProps[TOnyxProp], TOnyxKey>);
 /**
  * Represents a superset of `Mapping` type with internal properties included.
  */
@@ -98,7 +86,7 @@ type WithOnyxMapping<TComponentProps, TOnyxProps> = Mapping<TComponentProps, TOn
 /**
  * Represents the mapping options between an Onyx collection key without suffix and the component's prop with all its possibilities.
  */
-type CollectionMapping<TComponentProps, TOnyxProps, TOnyxProp extends keyof TOnyxProps, TOnyxKey extends CollectionKeyBase> = BaseMapping<TComponentProps, TOnyxProps> & CollectionBaseMapping<TOnyxKey> & (BaseMappingKey<TComponentProps, TOnyxProps, TOnyxProp, TOnyxKey, OnyxCollection<KeyValueMapping[TOnyxKey]>> | BaseMappingStringKeyAndSelector<TComponentProps, TOnyxProps, ExtractOnyxCollectionValue<TOnyxProps[TOnyxProp]>, TOnyxKey> | BaseMappingFunctionKeyAndSelector<TComponentProps, TOnyxProps, ExtractOnyxCollectionValue<TOnyxProps[TOnyxProp]>, TOnyxKey>);
+type CollectionMapping<TComponentProps, TOnyxProps, TOnyxProp extends keyof TOnyxProps, TOnyxKey extends CollectionKeyBase> = BaseMapping<TComponentProps, TOnyxProps> & (BaseMappingKey<TComponentProps, TOnyxProps, TOnyxProp, TOnyxKey, OnyxCollection<KeyValueMapping[TOnyxKey]>> | BaseMappingStringKeyAndSelector<TComponentProps, TOnyxProps, ExtractOnyxCollectionValue<TOnyxProps[TOnyxProp]>, TOnyxKey> | BaseMappingFunctionKeyAndSelector<TComponentProps, TOnyxProps, ExtractOnyxCollectionValue<TOnyxProps[TOnyxProp]>, TOnyxKey>);
 /**
  * Represents an union type of all the possible Onyx key mappings.
  * Each `OnyxPropMapping` will be associated with its respective Onyx key, ensuring different type-safety for each object.

package/package.json

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