react-native-onyx 2.0.43 → 2.0.44

package/dist/Onyx.d.ts

@@ -1,5 +1,5 @@
 import * as Logger from './Logger';
-import type { Collection, CollectionKeyBase, ConnectOptions, InitOptions, KeyValueMapping, Mapping, NonUndefined, NullableKeyValueMapping, NullishDeep, OnyxEntry, OnyxKey, OnyxUpdate } from './types';
+import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate } from './types';
 /** Initialize the store with actions and listening for storage events */
 declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, }: InitOptions): void;
 /**
@@ -45,7 +45,7 @@ declare function disconnect(connectionID: number, keyToRemoveFromEvictionBlockli
  * @param key ONYXKEY to set
  * @param value value to store
  */
-declare function set<TKey extends OnyxKey>(key: TKey, value: NonUndefined<OnyxEntry<KeyValueMapping[TKey]>>): Promise<void>;
+declare function set<TKey extends OnyxKey>(key: TKey, value: OnyxSetInput<TKey>): Promise<void>;
 /**
  * Sets multiple keys and values
  *
@@ -53,7 +53,7 @@ declare function set<TKey extends OnyxKey>(key: TKey, value: NonUndefined<OnyxEn
  *
  * @param data object keyed by ONYXKEYS and the values to set
  */
-declare function multiSet(data: Partial<NullableKeyValueMapping>): Promise<void>;
+declare function multiSet(data: OnyxMultiSetInput): Promise<void>;
 /**
  * Merge a new value into an existing value at a key.
  *
@@ -70,7 +70,7 @@ declare function multiSet(data: Partial<NullableKeyValueMapping>): Promise<void>
  * Onyx.merge(ONYXKEYS.POLICY, {id: 1}); // -> {id: 1}
  * Onyx.merge(ONYXKEYS.POLICY, {name: 'My Workspace'}); // -> {id: 1, name: 'My Workspace'}
  */
-declare function merge<TKey extends OnyxKey>(key: TKey, changes: NonUndefined<OnyxEntry<NullishDeep<KeyValueMapping[TKey]>>>): Promise<void>;
+declare function merge<TKey extends OnyxKey>(key: TKey, changes: OnyxMergeInput<TKey>): Promise<void>;
 /**
  * Merges a collection based on their keys
  *
@@ -84,7 +84,7 @@ declare function merge<TKey extends OnyxKey>(key: TKey, changes: NonUndefined<On
  * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
  * @param collection Object collection keyed by individual collection member keys and values
  */
-declare function mergeCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: Collection<TKey, TMap, NullishDeep<KeyValueMapping[TKey]>>): Promise<void>;
+declare function mergeCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): Promise<void>;
 /**
  * Clear out all the data in the store
  *

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,6 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, Mapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, WithOnyxConnectOptions } from './types';
+import type { CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, Mapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, WithOnyxConnectOptions } from './types';
 declare const METHOD: {
     readonly SET: "set";
     readonly MERGE: "merge";
@@ -32,7 +32,7 @@ declare function getDefaultKeyStates(): Record<OnyxKey, OnyxValue<OnyxKey>>;
  * @param initialKeyStates - initial data to set when `init()` and `clear()` are called
  * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
-declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<NullableKeyValueMapping>, safeEvictionKeys: OnyxKey[]): void;
+declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<KeyValueMapping>, safeEvictionKeys: OnyxKey[]): void;
 /**
  * Sends an action to DevTools extension
  *

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import type { ConnectOptions, OnyxUpdate } from './Onyx';
 import Onyx from './Onyx';
-import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from './types';
+import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxValue, Selector, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput } 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 { useOnyx, withOnyx };
-export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, };
+export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, };

package/dist/types.d.ts

@@ -121,7 +121,7 @@ type KeyValueMapping = {
  * It's very similar to `KeyValueMapping` but this type accepts using `null` as well.
  */
 type NullableKeyValueMapping = {
-    [TKey in OnyxKey]: OnyxValue<TKey>;
+    [TKey in OnyxKey]: NonUndefined<OnyxValue<TKey>> | null;
 };
 /**
  * Represents a selector function type which operates based on the provided `TKey` and `ReturnType`.
@@ -162,6 +162,12 @@ type Selector<TKey extends OnyxKey, TOnyxProps, TReturnType> = (value: OnyxEntry
  * ```
  */
 type OnyxEntry<TOnyxValue> = TOnyxValue | undefined;
+/**
+ * Represents an input value that can be passed to Onyx methods, that can be either `TOnyxValue` or `null`.
+ * Setting a key to `null` will remove the key from the store.
+ * `undefined` is not allowed for setting values, because it will have no effect on the data.
+ */
+type OnyxInput<TOnyxValue> = TOnyxValue | null;
 /**
  * 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.
  *
@@ -229,7 +235,7 @@ type NullishObjectDeep<ObjectType extends object> = {
  * Also, the `TMap` type is inferred automatically in `mergeCollection()` method and represents
  * the object of collection keys/values specified in the second parameter of the method.
  */
-type Collection<TKey extends CollectionKeyBase, TMap, TValue> = {
+type Collection<TKey extends CollectionKeyBase, TValue, TMap = never> = {
     [MapK in keyof TMap]: MapK extends `${TKey}${string}` ? MapK extends `${TKey}` ? never : TValue : never;
 };
 /** Represents the base options used in `Onyx.connect()` method. */
@@ -276,6 +282,22 @@ type ConnectOptions<TKey extends OnyxKey> = (CollectionConnectOptions<TKey> | De
 type Mapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
     connectionID: number;
 };
+/**
+ * This represents the value that can be passed to `Onyx.set` and to `Onyx.update` with the method "SET"
+ */
+type OnyxSetInput<TKey extends OnyxKey> = OnyxInput<KeyValueMapping[TKey]>;
+/**
+ * This represents the value that can be passed to `Onyx.multiSet` and to `Onyx.update` with the method "MULTI_SET"
+ */
+type OnyxMultiSetInput = Partial<NullableKeyValueMapping>;
+/**
+ * This represents the value that can be passed to `Onyx.merge` and to `Onyx.update` with the method "MERGE"
+ */
+type OnyxMergeInput<TKey extends OnyxKey> = OnyxInput<NullishDeep<KeyValueMapping[TKey]>>;
+/**
+ * This represents the value that can be passed to `Onyx.merge` and to `Onyx.update` with the method "MERGE"
+ */
+type OnyxMergeCollectionInput<TKey extends OnyxKey, TMap = object> = Collection<TKey, NullishDeep<KeyValueMapping[TKey]>, TMap>;
 /**
  * Represents different kinds of updates that can be passed to `Onyx.update()` method. It is a discriminated union of
  * different update methods (`SET`, `MERGE`, `MERGE_COLLECTION`), each with their own key and value structure.
@@ -284,15 +306,15 @@ type OnyxUpdate = {
     [TKey in OnyxKey]: {
         onyxMethod: typeof OnyxUtils.METHOD.SET;
         key: TKey;
-        value: NonUndefined<OnyxEntry<KeyValueMapping[TKey]>>;
+        value: OnyxSetInput<TKey>;
     } | {
-        onyxMethod: typeof OnyxUtils.METHOD.MERGE;
+        onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
         key: TKey;
-        value: NonUndefined<OnyxEntry<NullishDeep<KeyValueMapping[TKey]>>>;
+        value: OnyxMultiSetInput;
     } | {
-        onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
+        onyxMethod: typeof OnyxUtils.METHOD.MERGE;
         key: TKey;
-        value: Partial<NullableKeyValueMapping>;
+        value: OnyxMergeInput<TKey>;
     } | {
         onyxMethod: typeof OnyxUtils.METHOD.CLEAR;
         key: TKey;
@@ -302,7 +324,7 @@ type OnyxUpdate = {
     [TKey in CollectionKeyBase]: {
         onyxMethod: typeof OnyxUtils.METHOD.MERGE_COLLECTION;
         key: TKey;
-        value: Record<`${TKey}${string}`, NullishDeep<KeyValueMapping[TKey]>>;
+        value: OnyxMergeCollectionInput<TKey>;
     };
 }[CollectionKeyBase];
 /**
@@ -333,4 +355,4 @@ type InitOptions = {
     debugSetState?: boolean;
 };
 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, };
+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, OnyxInput, OnyxKey, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, WithOnyxConnectOptions, };

package/dist/withOnyx/types.d.ts

@@ -1,6 +1,6 @@
 import type { ForwardedRef } from 'react';
 import type { IsEqual } from 'type-fest';
-import type { CollectionKeyBase, ExtractOnyxCollectionValue, KeyValueMapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from '../types';
+import type { CollectionKeyBase, ExtractOnyxCollectionValue, KeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from '../types';
 /**
  * Represents the base mapping options between an Onyx key and the component's prop.
  */
@@ -134,7 +134,7 @@ type WithOnyxState<TOnyxProps> = TOnyxProps & {
 /**
  * Represents the `withOnyx` internal component instance.
  */
-type WithOnyxInstance = React.Component<unknown, WithOnyxState<NullableKeyValueMapping>> & {
+type WithOnyxInstance = React.Component<unknown, WithOnyxState<KeyValueMapping>> & {
     setStateProxy: (modifier: Record<string, OnyxCollection<KeyValueMapping[OnyxKey]>> | ((state: Record<string, OnyxCollection<KeyValueMapping[OnyxKey]>>) => OnyxValue<OnyxKey>)) => void;
     setWithOnyxState: (statePropertyName: OnyxKey, value: OnyxValue<OnyxKey>) => void;
 };

package/package.json

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