react-native-onyx 2.0.126 → 2.0.128

package/README.md

@@ -61,30 +61,23 @@ The data will then be cached and stored via [`AsyncStorage`](https://github.com/
 
 ### Performance Options for Large Objects
 
-For performance-critical scenarios with large objects, `Onyx.set()` accepts optional flags to skip expensive operations:
+For performance-critical scenarios with large objects, `Onyx.set()` accepts optional flag to skip expensive operations:
 
 ```javascript
 Onyx.set(ONYXKEYS.LARGE_DATA, computedValue, {
     skipCacheCheck: true,     // Skip deep equality check
-    skipNullRemoval: true,    // Skip null value pruning
 });
 ```
 
 **Options:**
 - `skipCacheCheck`: Skips the deep equality comparison with the cached value. By default, Onyx compares new values against cached ones to avoid unnecessary updates. For large objects, this comparison can be expensive.
-- `skipNullRemoval`: Skips the removal of `null` values from nested objects. By default, Onyx removes `null` values before storage. Use this when `null` values are meaningful in your data structure.
 
 #### When to Use SetOptions
 - **Use `skipCacheCheck: true`** for:
   - Large objects where deep equality checking is expensive
   - Values that you know have changed
 
-- **Use `skipNullRemoval: true`** for:
-  - Computed values where `null` represents a legitimate result
-  - Data structures where `null` has semantic meaning
-  - Values that should preserve their exact structure
-
-**Note**: These options are recommended only for large objects where performance is critical. Most use cases should use the standard `Onyx.set(key, value)` syntax.
+**Note**: These option is recommended only for large objects where performance is critical. Most use cases should use the standard `Onyx.set(key, value)` syntax.
 
 ## Merging data
 
@@ -196,16 +189,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 +205,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/Onyx.js

@@ -186,7 +186,7 @@ function set(key, value, options) {
         OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.SET, key);
         return Promise.resolve();
     }
-    const valueWithoutNestedNullValues = ((options === null || options === void 0 ? void 0 : options.skipNullRemoval) ? Object.assign({}, value) : utils_1.default.removeNestedNullValues(value));
+    const valueWithoutNestedNullValues = utils_1.default.removeNestedNullValues(value);
     const hasChanged = (options === null || options === void 0 ? void 0 : options.skipCacheCheck) ? true : OnyxCache_1.default.hasValueChanged(key, valueWithoutNestedNullValues);
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.SET, key, value, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.

package/dist/types.d.ts

@@ -374,8 +374,6 @@ type OnyxUpdate = {
 type SetOptions = {
     /** Skip the deep equality check against the cached value. Improves performance for large objects. */
     skipCacheCheck?: boolean;
-    /** Skip pruning null values from the object. Improves performance for large objects. */
-    skipNullRemoval?: boolean;
 };
 /**
  * Represents the options used in `Onyx.init()` method.

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.126",
+  "version": "2.0.128",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",