react-native-onyx 2.0.41 → 2.0.43

package/dist/OnyxUtils.js

@@ -30,14 +30,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-continue */
 const fast_equals_1 = require("fast-equals");
 const clone_1 = __importDefault(require("lodash/clone"));
+const DevTools_1 = __importDefault(require("./DevTools"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
-const Str = __importStar(require("./Str"));
 const PerformanceUtils = __importStar(require("./PerformanceUtils"));
+const Str = __importStar(require("./Str"));
+const batch_1 = __importDefault(require("./batch"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
-const batch_1 = __importDefault(require("./batch"));
-const DevTools_1 = __importDefault(require("./DevTools"));
 // Method constants
 const METHOD = {
     SET: 'set',
@@ -163,7 +163,7 @@ function reduceCollectionWithSelector(collection, selector, withOnyxInstanceStat
 function get(key) {
     // When we already have the value in cache - resolve right away
     if (OnyxCache_1.default.hasCacheForKey(key)) {
-        return Promise.resolve(OnyxCache_1.default.getValue(key));
+        return Promise.resolve(OnyxCache_1.default.get(key));
     }
     const taskName = `get:${key}`;
     // When a value retrieving task for this key is still running hook to it
@@ -173,6 +173,10 @@ function get(key) {
     // Otherwise retrieve the value from storage and capture a promise to aid concurrent usages
     const promise = storage_1.default.getItem(key)
         .then((val) => {
+        if (val === undefined) {
+            OnyxCache_1.default.addNullishStorageKey(key);
+            return undefined;
+        }
         OnyxCache_1.default.set(key, val);
         return val;
     })
@@ -182,9 +186,9 @@ function get(key) {
 /** Returns current key names stored in persisted storage */
 function getAllKeys() {
     // When we've already read stored keys, resolve right away
-    const storedKeys = OnyxCache_1.default.getAllKeys();
-    if (storedKeys.size > 0) {
-        return Promise.resolve(storedKeys);
+    const cachedKeys = OnyxCache_1.default.getAllKeys();
+    if (cachedKeys.size > 0) {
+        return Promise.resolve(cachedKeys);
     }
     const taskName = 'getAllKeys';
     // When a value retrieving task for all keys is still running hook to it
@@ -237,7 +241,7 @@ function isSafeEvictionKey(testKey) {
  * If the requested key is a collection, it will return an object with all the collection members.
  */
 function tryGetCachedValue(key, mapping) {
-    let val = OnyxCache_1.default.getValue(key);
+    let val = OnyxCache_1.default.get(key);
     if (isCollectionKey(key)) {
         const allCacheKeys = OnyxCache_1.default.getAllKeys();
         // It is possible we haven't loaded all keys yet so we do not know if the
@@ -247,7 +251,7 @@ function tryGetCachedValue(key, mapping) {
         }
         const matchingKeys = Array.from(allCacheKeys).filter((k) => k.startsWith(key));
         const values = matchingKeys.reduce((finalObject, matchedKey) => {
-            const cachedValue = OnyxCache_1.default.getValue(matchedKey);
+            const cachedValue = OnyxCache_1.default.get(matchedKey);
             if (cachedValue) {
                 // This is permissible because we're in the process of constructing the final object in a reduce function.
                 // eslint-disable-next-line no-param-reassign
@@ -334,23 +338,22 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
         if (!collectionMemberKeys && !isCollectionMemberKey(collectionKey, key)) {
             return;
         }
-        collection[key] = OnyxCache_1.default.getValue(key);
+        collection[key] = OnyxCache_1.default.get(key);
     });
     return collection;
 }
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-function keysChanged(collectionKey, partialCollection, previousPartialCollection, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
-    const previousCollectionWithoutNestedNulls = previousPartialCollection === undefined ? {} : utils_1.default.removeNestedNullValues(previousPartialCollection);
+function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
     // We prepare the "cached collection" which is the entire collection + the new partial data that
     // was merged in via mergeCollection().
     const cachedCollection = getCachedCollection(collectionKey);
-    const cachedCollectionWithoutNestedNulls = utils_1.default.removeNestedNullValues(cachedCollection);
     // If the previous collection equals the new collection then we do not need to notify any subscribers.
-    if (previousPartialCollection !== undefined && (0, fast_equals_1.deepEqual)(cachedCollectionWithoutNestedNulls, previousCollectionWithoutNestedNulls)) {
+    if (partialPreviousCollection !== undefined && (0, fast_equals_1.deepEqual)(cachedCollection, partialPreviousCollection)) {
         return;
     }
+    const previousCollection = partialPreviousCollection !== null && partialPreviousCollection !== void 0 ? partialPreviousCollection : {};
     // We are iterating over all subscribers similar to keyChanged(). However, we are looking for subscribers who are subscribing to either a collection key or
     // individual collection key member for the collection that is being updated. It is important to note that the collection parameter cane be a PARTIAL collection
     // and does not represent all of the combined keys and values for a collection key. It is just the "new" data that was merged in via mergeCollection().
@@ -381,7 +384,7 @@ function keysChanged(collectionKey, partialCollection, previousPartialCollection
             // send the whole cached collection.
             if (isSubscribedToCollectionKey) {
                 if (subscriber.waitForCollectionCallback) {
-                    subscriber.callback(cachedCollectionWithoutNestedNulls);
+                    subscriber.callback(cachedCollection);
                     continue;
                 }
                 // If they are not using waitForCollectionCallback then we notify the subscriber with
@@ -389,21 +392,21 @@ function keysChanged(collectionKey, partialCollection, previousPartialCollection
                 const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
                 for (let j = 0; j < dataKeys.length; j++) {
                     const dataKey = dataKeys[j];
-                    if ((0, fast_equals_1.deepEqual)(cachedCollectionWithoutNestedNulls[dataKey], previousCollectionWithoutNestedNulls[dataKey])) {
+                    if ((0, fast_equals_1.deepEqual)(cachedCollection[dataKey], previousCollection[dataKey])) {
                         continue;
                     }
-                    subscriber.callback(cachedCollectionWithoutNestedNulls[dataKey], dataKey);
+                    subscriber.callback(cachedCollection[dataKey], dataKey);
                 }
                 continue;
             }
             // And if the subscriber is specifically only tracking a particular collection member key then we will
             // notify them with the cached data for that key only.
             if (isSubscribedToCollectionMemberKey) {
-                if ((0, fast_equals_1.deepEqual)(cachedCollectionWithoutNestedNulls[subscriber.key], previousCollectionWithoutNestedNulls[subscriber.key])) {
+                if ((0, fast_equals_1.deepEqual)(cachedCollection[subscriber.key], previousCollection[subscriber.key])) {
                     continue;
                 }
                 const subscriberCallback = subscriber.callback;
-                subscriberCallback(cachedCollectionWithoutNestedNulls[subscriber.key], subscriber.key);
+                subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
                 continue;
             }
             continue;
@@ -449,7 +452,7 @@ function keysChanged(collectionKey, partialCollection, previousPartialCollection
             }
             // If a React component is only interested in a single key then we can set the cached value directly to the state name.
             if (isSubscribedToCollectionMemberKey) {
-                if ((0, fast_equals_1.deepEqual)(cachedCollectionWithoutNestedNulls[subscriber.key], previousCollectionWithoutNestedNulls[subscriber.key])) {
+                if ((0, fast_equals_1.deepEqual)(cachedCollection[subscriber.key], previousCollection[subscriber.key])) {
                     continue;
                 }
                 // However, we only want to update this subscriber if the partial data contains a change.
@@ -525,14 +528,12 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
             }
             if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
                 const cachedCollection = getCachedCollection(subscriber.key);
-                const cachedCollectionWithoutNestedNulls = utils_1.default.removeNestedNullValues(cachedCollection);
-                cachedCollectionWithoutNestedNulls[key] = value;
-                subscriber.callback(cachedCollectionWithoutNestedNulls);
+                cachedCollection[key] = value;
+                subscriber.callback(cachedCollection);
                 continue;
             }
-            const valueWithoutNestedNulls = utils_1.default.removeNestedNullValues(value);
             const subscriberCallback = subscriber.callback;
-            subscriberCallback(valueWithoutNestedNulls, key);
+            subscriberCallback(value, key);
             continue;
         }
         // Subscriber connected via withOnyx() HOC
@@ -612,7 +613,7 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
  *     - sets state on the withOnyxInstances
  *     - triggers the callback function
  */
-function sendDataToConnection(mapping, val, matchedKey, isBatched) {
+function sendDataToConnection(mapping, value, matchedKey, isBatched) {
     var _a, _b;
     // If the mapping no longer exists then we should not send any data.
     // This means our subscriber disconnected or withOnyx wrapped component unmounted.
@@ -620,15 +621,15 @@ function sendDataToConnection(mapping, val, matchedKey, isBatched) {
         return;
     }
     if ('withOnyxInstance' in mapping && mapping.withOnyxInstance) {
-        let newData = val;
+        let newData = value;
         // If the mapping has a selector, then the component's state must only be updated with the data
         // returned by the selector.
         if (mapping.selector) {
             if (isCollectionKey(mapping.key)) {
-                newData = reduceCollectionWithSelector(val, mapping.selector, mapping.withOnyxInstance.state);
+                newData = reduceCollectionWithSelector(value, mapping.selector, mapping.withOnyxInstance.state);
             }
             else {
-                newData = mapping.selector(val, mapping.withOnyxInstance.state);
+                newData = mapping.selector(value, mapping.withOnyxInstance.state);
             }
         }
         PerformanceUtils.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
@@ -640,8 +641,13 @@ function sendDataToConnection(mapping, val, matchedKey, isBatched) {
         }
         return;
     }
-    const valuesWithoutNestedNulls = utils_1.default.removeNestedNullValues(val);
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, valuesWithoutNestedNulls, matchedKey);
+    // When there are no matching keys in "Onyx.connect", we pass null to "sendDataToConnection" explicitly,
+    // to allow the withOnyx instance to set the value in the state initially and therefore stop the loading state once all
+    // required keys have been set.
+    // If we would pass undefined to setWithOnyxInstance instead, withOnyx would not set the value in the state.
+    // withOnyx will internally replace null values with undefined and never pass null values to wrapped components.
+    // For regular callbacks, we never want to pass null values, but always just undefined if a value is not set in cache or storage.
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value === null ? undefined : value, matchedKey);
 }
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
@@ -682,7 +688,7 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
      * These missingKeys will be later to use to multiGet the data from the storage.
      */
     matchingKeys.forEach((key) => {
-        const cacheValue = OnyxCache_1.default.getValue(key);
+        const cacheValue = OnyxCache_1.default.get(key);
         if (cacheValue) {
             data[key] = cacheValue;
             return;
@@ -755,7 +761,7 @@ function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
  * Remove a key from Onyx and update the subscribers
  */
 function remove(key) {
-    const prevValue = OnyxCache_1.default.getValue(key, false);
+    const prevValue = OnyxCache_1.default.get(key, false);
     OnyxCache_1.default.drop(key);
     scheduleSubscriberUpdate(key, null, prevValue);
     return storage_1.default.removeItem(key).then(() => undefined);
@@ -798,11 +804,11 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
 /**
  * Notifies subscribers and writes current value to cache
  */
-function broadcastUpdate(key, value, hasChanged, wasRemoved = false) {
-    const prevValue = OnyxCache_1.default.getValue(key, false);
+function broadcastUpdate(key, value, hasChanged) {
+    const prevValue = OnyxCache_1.default.get(key, false);
     // 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 && !wasRemoved) {
+    if (hasChanged) {
         OnyxCache_1.default.set(key, value);
     }
     else {
@@ -823,7 +829,7 @@ function hasPendingMergeForKey(key) {
 function removeNullValues(key, value, shouldRemoveNestedNulls = true) {
     if (value === null) {
         remove(key);
-        return { value, wasRemoved: true };
+        return { value: null, wasRemoved: true };
     }
     // We can remove all null values in an object by merging it with itself
     // utils.fastMerge recursively goes through the object and removes all null values

package/dist/index.d.ts

@@ -1,9 +1,10 @@
+import type { ConnectOptions, OnyxUpdate } from './Onyx';
 import Onyx from './Onyx';
-import type { OnyxUpdate, ConnectOptions } from './Onyx';
-import type { CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState, OnyxValue } from './types';
-import type { UseOnyxResult, FetchStatus, ResultMetadata } from './useOnyx';
+import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from './types';
+import type { FetchStatus, ResultMetadata, UseOnyxResult } from './useOnyx';
 import useOnyx from './useOnyx';
 import withOnyx from './withOnyx';
+import type { WithOnyxState } from './withOnyx/types';
 export default Onyx;
-export { withOnyx, useOnyx };
-export type { CustomTypeOptions, OnyxCollection, OnyxEntry, OnyxUpdate, ConnectOptions, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState, UseOnyxResult, OnyxValue, FetchStatus, ResultMetadata, };
+export { useOnyx, withOnyx };
+export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, };

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useOnyx = exports.withOnyx = void 0;
+exports.withOnyx = exports.useOnyx = void 0;
 const Onyx_1 = __importDefault(require("./Onyx"));
 const useOnyx_1 = __importDefault(require("./useOnyx"));
 exports.useOnyx = useOnyx_1.default;

package/dist/storage/providers/IDBKeyValProvider.js

@@ -22,14 +22,26 @@ const provider = {
             throw Error('IDBKeyVal store could not be created');
         idbKeyValStore = newIdbKeyValStore;
     },
-    setItem: (key, value) => (0, idb_keyval_1.set)(key, value, idbKeyValStore),
+    setItem: (key, value) => {
+        if (value === null) {
+            provider.removeItem(key);
+        }
+        return (0, idb_keyval_1.set)(key, value, idbKeyValStore);
+    },
     multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, idbKeyValStore).then((values) => values.map((value, index) => [keysParam[index], value])),
     multiMerge: (pairs) => idbKeyValStore('readwrite', (store) => {
         // Note: we are using the manual store transaction here, to fit the read and update
         // of the items in one transaction to achieve best performance.
         const getValues = Promise.all(pairs.map(([key]) => (0, idb_keyval_1.promisifyRequest)(store.get(key))));
         return getValues.then((values) => {
-            const upsertMany = pairs.map(([key, value], index) => {
+            const pairsWithoutNull = pairs.filter(([key, value]) => {
+                if (value === null) {
+                    provider.removeItem(key);
+                    return false;
+                }
+                return true;
+            });
+            const upsertMany = pairsWithoutNull.map(([key, value], index) => {
                 const prev = values[index];
                 const newValue = utils_1.default.fastMerge(prev, value);
                 return (0, idb_keyval_1.promisifyRequest)(store.put(newValue, key));
@@ -41,7 +53,16 @@ const provider = {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
         return provider.setItem(key, preMergedValue);
     },
-    multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, idbKeyValStore),
+    multiSet: (pairs) => {
+        const pairsWithoutNull = pairs.filter(([key, value]) => {
+            if (value === null) {
+                provider.removeItem(key);
+                return false;
+            }
+            return true;
+        });
+        return (0, idb_keyval_1.setMany)(pairsWithoutNull, idbKeyValStore);
+    },
     clear: () => (0, idb_keyval_1.clear)(idbKeyValStore),
     getAllKeys: () => (0, idb_keyval_1.keys)(idbKeyValStore),
     getItem: (key) => (0, idb_keyval_1.get)(key, idbKeyValStore)

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import type { Component } from 'react';
 import type { Merge } from 'type-fest';
 import type { BuiltIns } from 'type-fest/source/internal';
 import type OnyxUtils from './OnyxUtils';
+import type { WithOnyxInstance, WithOnyxState } from './withOnyx/types';
 /**
  * Utility type that excludes `null` from the type `TValue`.
  */
@@ -132,7 +132,7 @@ type NullableKeyValueMapping = {
  * The type `TKey` extends `OnyxKey` and it is the key used to access a value in `KeyValueMapping`.
  * `TReturnType` is the type of the returned value from the selector function.
  */
-type Selector<TKey extends OnyxKey, TOnyxProps, TReturnType> = (value: OnyxEntry<KeyValueMapping[TKey]>, state: WithOnyxInstanceState<TOnyxProps>) => TReturnType;
+type Selector<TKey extends OnyxKey, TOnyxProps, TReturnType> = (value: OnyxEntry<KeyValueMapping[TKey]>, state?: WithOnyxState<TOnyxProps>) => TReturnType;
 /**
  * Represents a single Onyx entry, that can be either `TOnyxValue` or `null` / `undefined` if it doesn't exist.
  *
@@ -161,7 +161,7 @@ type Selector<TKey extends OnyxKey, TOnyxProps, TReturnType> = (value: OnyxEntry
  * })(Component);
  * ```
  */
-type OnyxEntry<TOnyxValue> = TOnyxValue | null | undefined;
+type OnyxEntry<TOnyxValue> = TOnyxValue | undefined;
 /**
  * Represents an Onyx collection of entries, that can be either a record of `TOnyxValue`s or `null` / `undefined` if it is empty or doesn't exist.
  *
@@ -190,7 +190,7 @@ type OnyxEntry<TOnyxValue> = TOnyxValue | null | undefined;
  * })(Component);
  * ```
  */
-type OnyxCollection<TOnyxValue> = OnyxEntry<Record<string, TOnyxValue | null | undefined>>;
+type OnyxCollection<TOnyxValue> = OnyxEntry<Record<string, TOnyxValue | undefined>>;
 /** Utility type to extract `TOnyxValue` from `OnyxCollection<TOnyxValue>` */
 type ExtractOnyxCollectionValue<TOnyxCollection> = TOnyxCollection extends NonNullable<OnyxCollection<infer U>> ? U : never;
 type NonTransformableTypes = BuiltIns | ((...args: any[]) => unknown) | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | unknown[] | readonly unknown[];
@@ -220,12 +220,6 @@ type NullishDeep<T> = T extends NonTransformableTypes ? T : T extends object ? N
 type NullishObjectDeep<ObjectType extends object> = {
     [KeyType in keyof ObjectType]?: NullishDeep<ObjectType[KeyType]> | null;
 };
-/**
- * Represents withOnyx's internal state, containing the Onyx props and a `loading` flag.
- */
-type WithOnyxInstanceState<TOnyxProps> = (TOnyxProps & {
-    loading: boolean;
-}) | undefined;
 /**
  * Represents a mapping between Onyx collection keys and their respective values.
  *
@@ -238,10 +232,6 @@ type WithOnyxInstanceState<TOnyxProps> = (TOnyxProps & {
 type Collection<TKey extends CollectionKeyBase, TMap, TValue> = {
     [MapK in keyof TMap]: MapK extends `${TKey}${string}` ? MapK extends `${TKey}` ? never : TValue : never;
 };
-type WithOnyxInstance = Component<unknown, WithOnyxInstanceState<NullableKeyValueMapping>> & {
-    setStateProxy: (cb: (state: Record<string, OnyxCollection<KeyValueMapping[OnyxKey]>>) => OnyxValue<OnyxKey>) => void;
-    setWithOnyxState: (statePropertyName: OnyxKey, value: OnyxValue<OnyxKey>) => void;
-};
 /** Represents the base options used in `Onyx.connect()` method. */
 type BaseConnectOptions = {
     initWithStoredValues?: boolean;
@@ -342,4 +332,5 @@ type InitOptions = {
     /** Enables debugging setState() calls to connected components */
     debugSetState?: boolean;
 };
-export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, InitOptions, Key, KeyValueMapping, Mapping, NonNull, NonUndefined, NullableKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxUpdate, OnyxValue, Selector, WithOnyxConnectOptions, WithOnyxInstance, WithOnyxInstanceState, };
+type GenericFunction = (...args: any[]) => any;
+export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, Mapping, NonNull, NonUndefined, NullableKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxUpdate, OnyxValue, Selector, WithOnyxConnectOptions, };

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { OnyxKey } from './types';
+import type { OnyxKey, OnyxValue } from './types';
 type EmptyObject = Record<string, never>;
 type EmptyValue = EmptyObject | null | undefined;
 /** Checks whether the given object is an object and not null/undefined. */
@@ -12,7 +12,7 @@ declare function isEmptyObject<T>(obj: T | EmptyValue): obj is EmptyValue;
  */
 declare function fastMerge<TObject extends Record<string, unknown>>(target: TObject | null, source: TObject | null, shouldRemoveNestedNulls?: boolean): TObject | null;
 /** Deep removes the nested null values from the given value. */
-declare function removeNestedNullValues<TObject extends Record<string, unknown>>(value: unknown | unknown[] | TObject): Record<string, unknown> | unknown[] | null;
+declare function removeNestedNullValues<TValue extends OnyxValue<OnyxKey> | unknown | unknown[]>(value: TValue | null): TValue | null;
 /** Formats the action name by uppercasing and adding the key if provided. */
 declare function formatActionName(method: string, key?: OnyxKey): string;
 /** validate that the update and the existing value are compatible */
@@ -21,11 +21,29 @@ declare function checkCompatibilityWithExistingValue(value: unknown, existingVal
     existingValueType?: string;
     newValueType?: string;
 };
+/**
+ * Picks entries from an object based on a condition.
+ *
+ * @param obj - The object to pick entries from.
+ * @param condition - The condition to determine which entries to pick.
+ * @returns The object containing only the picked entries.
+ */
+declare function pick<TValue>(obj: Record<string, TValue>, condition: string | string[] | ((entry: [string, TValue]) => boolean)): Record<string, TValue>;
+/**
+ * Omits entries from an object based on a condition.
+ *
+ * @param obj - The object to omit entries from.
+ * @param condition - The condition to determine which entries to omit.
+ * @returns The object containing only the remaining entries after omission.
+ */
+declare function omit<TValue>(obj: Record<string, TValue>, condition: string | string[] | ((entry: [string, TValue]) => boolean)): Record<string, TValue>;
 declare const _default: {
     isEmptyObject: typeof isEmptyObject;
     fastMerge: typeof fastMerge;
     formatActionName: typeof formatActionName;
     removeNestedNullValues: typeof removeNestedNullValues;
     checkCompatibilityWithExistingValue: typeof checkCompatibilityWithExistingValue;
+    pick: typeof pick;
+    omit: typeof omit;
 };
 export default _default;

package/dist/utils.js

@@ -90,7 +90,8 @@ function fastMerge(target, source, shouldRemoveNestedNulls = true) {
 /** Deep removes the nested null values from the given value. */
 function removeNestedNullValues(value) {
     if (typeof value === 'object' && !Array.isArray(value)) {
-        return fastMerge(value, value);
+        const objectValue = value;
+        return fastMerge(objectValue, objectValue);
     }
     return value;
 }
@@ -118,4 +119,53 @@ function checkCompatibilityWithExistingValue(value, existingValue) {
         isCompatible: true,
     };
 }
-exports.default = { isEmptyObject, fastMerge, formatActionName, removeNestedNullValues, checkCompatibilityWithExistingValue };
+/**
+ * Filters an object based on a condition and an inclusion flag.
+ *
+ * @param obj - The object to filter.
+ * @param condition - The condition to apply.
+ * @param include - If true, include entries that match the condition; otherwise, exclude them.
+ * @returns The filtered object.
+ */
+function filterObject(obj, condition, include) {
+    const result = {};
+    const entries = Object.entries(obj);
+    for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        let shouldInclude;
+        if (Array.isArray(condition)) {
+            shouldInclude = condition.includes(key);
+        }
+        else if (typeof condition === 'string') {
+            shouldInclude = key === condition;
+        }
+        else {
+            shouldInclude = condition(entries[i]);
+        }
+        if (include ? shouldInclude : !shouldInclude) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Picks entries from an object based on a condition.
+ *
+ * @param obj - The object to pick entries from.
+ * @param condition - The condition to determine which entries to pick.
+ * @returns The object containing only the picked entries.
+ */
+function pick(obj, condition) {
+    return filterObject(obj, condition, true);
+}
+/**
+ * Omits entries from an object based on a condition.
+ *
+ * @param obj - The object to omit entries from.
+ * @param condition - The condition to determine which entries to omit.
+ * @returns The object containing only the remaining entries after omission.
+ */
+function omit(obj, condition) {
+    return filterObject(obj, condition, false);
+}
+exports.default = { isEmptyObject, fastMerge, formatActionName, removeNestedNullValues, checkCompatibilityWithExistingValue, pick, omit };

package/dist/withOnyx/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This is a higher order component that provides the ability to map a state property directly to
+ * something in Onyx (a key/value store). That way, as soon as data in Onyx changes, the state will be set and the view
+ * will automatically change to reflect the new data.
+ */
+import React from 'react';
+import type { MapOnyxToState } from './types';
+/**
+ * @deprecated Use `useOnyx` instead of `withOnyx` whenever possible.
+ *
+ * This is a higher order component that provides the ability to map a state property directly to
+ * something in Onyx (a key/value store). That way, as soon as data in Onyx changes, the state will be set and the view
+ * will automatically change to reflect the new data.
+ */
+export default function <TComponentProps, TOnyxProps>(mapOnyxToState: MapOnyxToState<TComponentProps, TOnyxProps>, shouldDelayUpdates?: boolean): (component: React.ComponentType<TComponentProps>) => React.ComponentType<Omit<TComponentProps, keyof TOnyxProps>>;