react-native-onyx 2.0.26 → 2.0.28

package/dist/PerformanceUtils.js

@@ -48,6 +48,6 @@ function logSetStateCall(mapping, previousValue, newValue, caller, keyThatChange
         logParams.previousValue = previousValue;
         logParams.newValue = newValue;
     }
-    console.debug(`[Onyx-Debug] ${mapping.displayName} setState() called. Subscribed to key '${mapping.key}' (${caller})`, logParams);
+    console.debug(`[Onyx-Debug] ${'displayName' in mapping && mapping.displayName} setState() called. Subscribed to key '${mapping.key}' (${caller})`, logParams);
 }
 exports.logSetStateCall = logSetStateCall;

package/dist/storage/__mocks__/index.d.ts

@@ -5,7 +5,7 @@ declare const StorageMock: {
     multiGet: jest.Mock<Promise<import("../providers/types").KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
     setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: any, value: unknown]>;
     multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: import("../providers/types").KeyValuePairList]>;
-    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: any, changes: unknown, modifiedData: unknown]>;
+    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: any, deltaChanges: unknown, preMergedValue: unknown, shouldSetValue?: boolean | undefined]>;
     multiMerge: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: import("../providers/types").KeyValuePairList]>;
     removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
     removeItems: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [keys: import("../providers/types").KeyList]>;

package/dist/storage/index.js

@@ -118,8 +118,8 @@ const Storage = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, changes, modifiedData) => tryOrDegradePerformance(() => {
-        const promise = provider.mergeItem(key, changes, modifiedData);
+    mergeItem: (key, deltaChanges, preMergedValue, shouldSetValue = false) => tryOrDegradePerformance(() => {
+        const promise = provider.mergeItem(key, deltaChanges, preMergedValue, shouldSetValue);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.mergeItem(key));
         }

package/dist/storage/providers/IDBKeyValProvider.js

@@ -37,9 +37,9 @@ const provider = {
             return Promise.all(upsertMany);
         });
     }),
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
-        return provider.setItem(key, modifiedData);
+        return provider.setItem(key, preMergedValue);
     },
     multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, idbKeyValStore),
     clear: () => (0, idb_keyval_1.clear)(idbKeyValStore),

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -64,9 +64,9 @@ const provider = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx already merged the existing value with the changes, we can just set the value directly
-        return this.setItem(key, modifiedData);
+        return this.setItem(key, preMergedValue);
     },
     /**
      * Multiple merging of existing and new values in a batch

package/dist/storage/providers/NoopProvider.js

@@ -13,10 +13,8 @@ const provider = {
     },
     /**
      * Get the value of a given key or return `null` if it's not available in memory
-     * @param {String} key
-     * @return {Promise<*>}
      */
-    getItem() {
+    getItem(key) {
         return Promise.resolve(null);
     },
     /**

package/dist/storage/providers/SQLiteProvider.js

@@ -68,8 +68,11 @@ const provider = {
         });
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    mergeItem(key, changes) {
-        return this.multiMerge([[key, changes]]);
+    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue) {
+        if (shouldSetValue) {
+            return this.setItem(key, preMergedValue);
+        }
+        return this.multiMerge([[key, deltaChanges]]);
     },
     getAllKeys: () => db.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({ rows }) => {
         // eslint-disable-next-line no-underscore-dangle

package/dist/storage/providers/types.d.ts

@@ -3,7 +3,7 @@ import type { OnyxKey, OnyxValue } from '../../types';
 type KeyValuePair = [OnyxKey, OnyxValue<OnyxKey>];
 type KeyList = OnyxKey[];
 type KeyValuePairList = KeyValuePair[];
-type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey> | null) => void;
+type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => void;
 type StorageProvider = {
     /**
      * The name of the provider that can be printed to the logs
@@ -16,7 +16,7 @@ type StorageProvider = {
     /**
      * Gets the value of a given key or return `null` if it's not available in storage
      */
-    getItem: <TKey extends OnyxKey>(key: TKey) => Promise<OnyxValue<TKey> | null>;
+    getItem: <TKey extends OnyxKey>(key: TKey) => Promise<OnyxValue<TKey>>;
     /**
      * Get multiple key-value pairs for the given array of keys in a batch
      */
@@ -35,10 +35,11 @@ type StorageProvider = {
     multiMerge: (pairs: KeyValuePairList) => Promise<BatchQueryResult | IDBValidKey[] | void>;
     /**
      * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param changes - the delta for a specific key
-     * @param modifiedData - the pre-merged data from `Onyx.applyMerge`
+     * @param deltaChanges - the delta for a specific key
+     * @param preMergedValue - the pre-merged data from `Onyx.applyMerge`
+     * @param shouldSetValue - whether the data should be set instead of merged
      */
-    mergeItem: <TKey extends OnyxKey>(key: TKey, changes: OnyxValue<TKey>, modifiedData: OnyxValue<TKey>) => Promise<BatchQueryResult | void>;
+    mergeItem: <TKey extends OnyxKey>(key: TKey, deltaChanges: OnyxValue<TKey>, preMergedValue: OnyxValue<TKey>, shouldSetValue?: boolean) => Promise<BatchQueryResult | void>;
     /**
      * Returns all keys available in storage
      */

package/dist/types.d.ts

@@ -231,40 +231,52 @@ 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: NullableKeyValueMapping) => OnyxValue<OnyxKey>) => void;
+    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 = {
-    statePropertyName?: string;
-    withOnyxInstance?: Component;
     initWithStoredValues?: boolean;
 };
+/** Represents additional options used inside withOnyx HOC */
+type WithOnyxConnectOptions<TKey extends OnyxKey> = {
+    withOnyxInstance: WithOnyxInstance;
+    statePropertyName: string;
+    displayName: string;
+    initWithStoredValues?: boolean;
+    selector?: Selector<TKey, unknown, unknown>;
+    canEvict?: boolean;
+};
+type DefaultConnectCallback<TKey extends OnyxKey> = (value: OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;
+type CollectionConnectCallback<TKey extends OnyxKey> = (value: OnyxCollection<KeyValueMapping[TKey]>) => void;
+/** Represents the callback function used in `Onyx.connect()` method with a regular key. */
+type DefaultConnectOptions<TKey extends OnyxKey> = {
+    key: TKey;
+    callback?: DefaultConnectCallback<TKey>;
+    waitForCollectionCallback?: false;
+};
+/** Represents the callback function used in `Onyx.connect()` method with a collection key. */
+type CollectionConnectOptions<TKey extends OnyxKey> = {
+    key: TKey extends CollectionKeyBase ? TKey : never;
+    callback?: CollectionConnectCallback<TKey>;
+    waitForCollectionCallback: true;
+};
 /**
  * Represents the options used in `Onyx.connect()` method.
- * The type is built from `BaseConnectOptions` and extended to handle key/callback related options.
+ * The type is built from `DefaultConnectOptions`/`CollectionConnectOptions` depending on the `waitForCollectionCallback` property.
  * It includes two different forms, depending on whether we are waiting for a collection callback or not.
  *
  * If `waitForCollectionCallback` is `true`, it expects `key` to be a Onyx collection key and `callback` will be triggered with the whole collection
  * and will pass `value` as an `OnyxCollection`.
  *
- *
  * If `waitForCollectionCallback` is `false` or not specified, the `key` can be any Onyx key and `callback` will be triggered with updates of each collection item
  * and will pass `value` as an `OnyxEntry`.
+ *
+ * The type is also extended with `BaseConnectOptions` and `WithOnyxConnectOptions` to include additional options, depending on the context where it's used.
  */
-type ConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & ({
-    key: TKey extends CollectionKeyBase ? TKey : never;
-    callback?: (value: OnyxCollection<KeyValueMapping[TKey]>) => void;
-    waitForCollectionCallback: true;
-} | {
-    key: TKey;
-    callback?: (value: OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;
-    waitForCollectionCallback?: false;
-});
+type ConnectOptions<TKey extends OnyxKey> = (CollectionConnectOptions<TKey> | DefaultConnectOptions<TKey>) & (BaseConnectOptions | WithOnyxConnectOptions<TKey>);
 type Mapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
     connectionID: number;
-    statePropertyName: string;
-    displayName: string;
 };
 /**
  * Represents different kinds of updates that can be passed to `Onyx.update()` method. It is a discriminated union of
@@ -322,4 +334,4 @@ type InitOptions = {
     /** Enables debugging setState() calls to connected components */
     debugSetState?: boolean;
 };
-export type { CollectionKey, CollectionKeyBase, CustomTypeOptions, DeepRecord, Key, KeyValueMapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, NullishDeep, WithOnyxInstanceState, ExtractOnyxCollectionValue, Collection, WithOnyxInstance, BaseConnectOptions, ConnectOptions, Mapping, OnyxUpdate, InitOptions, };
+export type { CollectionKey, CollectionKeyBase, CustomTypeOptions, DeepRecord, Key, KeyValueMapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, NullishDeep, WithOnyxInstanceState, ExtractOnyxCollectionValue, Collection, WithOnyxInstance, BaseConnectOptions, WithOnyxConnectOptions, DefaultConnectCallback, CollectionConnectCallback, DefaultConnectOptions, CollectionConnectOptions, ConnectOptions, Mapping, OnyxUpdate, InitOptions, };

package/dist/useOnyx.js

@@ -83,7 +83,7 @@ function useOnyx(key, options) {
     }, [key, selectorRef, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.initialValue]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         connectionIDRef.current = Onyx_1.default.connect({
-            key: key,
+            key,
             callback: () => {
                 // We don't need to update the Onyx cache again here, when `callback` is called the cache is already
                 // expected to be updated, so we just signal that the store changed and `getSnapshot()` can be called again.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.26",
+  "version": "2.0.28",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -33,7 +33,8 @@
     "test": "jest",
     "build": "tsc -p tsconfig.build.json && cp ./lib/*.d.ts ./dist",
     "build:watch": "nodemon --watch lib --ext js,json,ts,tsx --exec \"npm run build && npm pack\"",
-    "build:docs": "node buildDocs.js",
+    "prebuild:docs": "npm run build",
+    "build:docs": "ts-node buildDocs.ts",
     "lint-tests": "eslint tests/**",
     "prettier": "prettier --write ."
   },
@@ -49,6 +50,7 @@
     "@testing-library/jest-native": "^3.4.2",
     "@testing-library/react-native": "^10.0.0",
     "@types/jest": "^28.1.8",
+    "@types/jsdoc-to-markdown": "^7.0.6",
     "@types/lodash": "^4.14.202",
     "@types/node": "^20.11.5",
     "@types/react": "^18.2.14",
@@ -78,6 +80,7 @@
     "react-native-performance": "^2.0.0",
     "react-native-quick-sqlite": "^8.0.6",
     "react-test-renderer": "18.1.0",
+    "ts-node": "^10.9.2",
     "type-fest": "^3.12.0",
     "typescript": "^5.3.3"
   },