react-native-onyx 2.0.99 → 2.0.101

package/dist/Onyx.js

@@ -28,7 +28,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-continue */
 const underscore_1 = __importDefault(require("underscore"));
-const pick_1 = __importDefault(require("lodash/pick"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const PerformanceUtils = __importStar(require("./PerformanceUtils"));
@@ -540,51 +539,6 @@ function clear(keysToPreserve = []) {
         .then(() => undefined);
     return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.CLEAR, promise);
 }
-function updateSnapshots(data) {
-    const snapshotCollectionKey = OnyxUtils_1.default.getSnapshotKey();
-    if (!snapshotCollectionKey)
-        return [];
-    const promises = [];
-    const snapshotCollection = OnyxUtils_1.default.getCachedCollection(snapshotCollectionKey);
-    const snapshotCollectionKeyLength = snapshotCollectionKey.length;
-    Object.entries(snapshotCollection).forEach(([snapshotKey, snapshotValue]) => {
-        // Snapshots may not be present in cache. We don't know how to update them so we skip.
-        if (!snapshotValue) {
-            return;
-        }
-        let updatedData = {};
-        data.forEach(({ key, value }) => {
-            // snapshots are normal keys so we want to skip update if they are written to Onyx
-            if (OnyxUtils_1.default.isCollectionMemberKey(snapshotCollectionKey, key, snapshotCollectionKeyLength)) {
-                return;
-            }
-            if (typeof snapshotValue !== 'object' || !('data' in snapshotValue)) {
-                return;
-            }
-            const snapshotData = snapshotValue.data;
-            if (!snapshotData || !snapshotData[key]) {
-                return;
-            }
-            if (Array.isArray(value) || Array.isArray(snapshotData[key])) {
-                updatedData[key] = value || [];
-                return;
-            }
-            if (value === null) {
-                updatedData[key] = value;
-                return;
-            }
-            const oldValue = updatedData[key] || {};
-            const newValue = (0, pick_1.default)(value, Object.keys(snapshotData[key]));
-            updatedData = Object.assign(Object.assign({}, updatedData), { [key]: Object.assign(oldValue, newValue) });
-        });
-        // Skip the update if there's no data to be merged
-        if (utils_1.default.isEmptyObject(updatedData)) {
-            return;
-        }
-        promises.push(() => merge(snapshotKey, { data: updatedData }));
-    });
-    return promises;
-}
 /**
  * Insert API responses and lifecycle data into Onyx
  *
@@ -699,7 +653,7 @@ function update(data) {
             promises.push(() => merge(key, batchedChanges));
         }
     });
-    const snapshotPromises = updateSnapshots(data);
+    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
     // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
     const finalPromises = snapshotPromises.concat(promises);
     return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,7 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, Mapping, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxValue } from './types';
+import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, Mapping, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector } from './types';
+import type { WithOnyxState } from './withOnyx/types';
 import type { DeferredTask } from './createDeferredTask';
 declare const METHOD: {
     readonly SET: "set";
@@ -66,6 +67,12 @@ declare function sendActionToDevTools(method: Exclude<OnyxMethod, typeof METHOD.
  */
 declare function maybeFlushBatchUpdates(): Promise<void>;
 declare function batchUpdates(updates: () => void): Promise<void>;
+/**
+ * Takes a collection of items (eg. {testKey_1:{a:'a'}, testKey_2:{b:'b'}})
+ * and runs it through a reducer function to return a subset of the data according to a selector.
+ * The resulting collection will only contain items that are returned by the selector.
+ */
+declare function reduceCollectionWithSelector<TKey extends CollectionKeyBase, TMap, TReturn>(collection: OnyxCollection<KeyValueMapping[TKey]>, selector: Selector<TKey, TMap, TReturn>, withOnyxInstanceState: WithOnyxState<TMap> | undefined): Record<string, TReturn>;
 /** Get some data from the store */
 declare function get<TKey extends OnyxKey, TValue extends OnyxValue<TKey>>(key: TKey): Promise<TValue>;
 declare function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<OnyxKey, OnyxValue<TKey>>>;
@@ -78,6 +85,19 @@ declare function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Prom
 declare function tupleGet<Keys extends readonly OnyxKey[]>(keys: Keys): Promise<{
     [Index in keyof Keys]: OnyxValue<Keys[Index]>;
 }>;
+/**
+ * Stores a subscription ID associated with a given key.
+ *
+ * @param subscriptionID - A subscription ID of the subscriber.
+ * @param key - A key that the subscriber is subscribed to.
+ */
+declare function storeKeyBySubscriptions(key: OnyxKey, subscriptionID: number): void;
+/**
+ * Deletes a subscription ID associated with its corresponding key.
+ *
+ * @param subscriptionID - The subscription ID to be deleted.
+ */
+declare function deleteKeyBySubscriptions(subscriptionID: number): void;
 /** Returns current key names stored in persisted storage */
 declare function getAllKeys(): Promise<Set<OnyxKey>>;
 /**
@@ -144,7 +164,7 @@ declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionK
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyRegularSubscibers?: boolean, notifyWithOnyxSubscibers?: boolean): void;
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
  *
@@ -158,6 +178,11 @@ declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TK
  *     - triggers the callback function
  */
 declare function sendDataToConnection<TKey extends OnyxKey>(mapping: Mapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined, isBatched: boolean): void;
+/**
+ * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
+ * run out of storage the least recently accessed key can be removed.
+ */
+declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(mapping: Mapping<TKey>): void;
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
@@ -242,6 +267,7 @@ declare function subscribeToKey<TKey extends OnyxKey>(connectOptions: ConnectOpt
  * @param subscriptionID Subscription ID returned by calling `OnyxUtils.subscribeToKey()`.
  */
 declare function unsubscribeFromKey(subscriptionID: number): void;
+declare function updateSnapshots(data: OnyxUpdate[], mergeFn: typeof Onyx.merge): Array<() => Promise<void>>;
 declare const OnyxUtils: {
     METHOD: {
         readonly SET: "set";
@@ -298,6 +324,11 @@ declare const OnyxUtils: {
     getEvictionBlocklist: typeof getEvictionBlocklist;
     getSkippableCollectionMemberIDs: typeof getSkippableCollectionMemberIDs;
     setSkippableCollectionMemberIDs: typeof setSkippableCollectionMemberIDs;
+    storeKeyBySubscriptions: typeof storeKeyBySubscriptions;
+    deleteKeyBySubscriptions: typeof deleteKeyBySubscriptions;
+    addKeyToRecentlyAccessedIfNeeded: typeof addKeyToRecentlyAccessedIfNeeded;
+    reduceCollectionWithSelector: typeof reduceCollectionWithSelector;
+    updateSnapshots: typeof updateSnapshots;
 };
 export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -30,6 +30,7 @@ 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 pick_1 = __importDefault(require("lodash/pick"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
@@ -526,7 +527,7 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
+function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = 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);
@@ -555,7 +556,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         const isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key, collectionKeyLength);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
-            if (!notifyRegularSubscibers) {
+            if (!notifyConnectSubscribers) {
                 continue;
             }
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
@@ -591,7 +592,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         }
         // React component subscriber found.
         if (utils_1.default.hasWithOnyxInstance(subscriber)) {
-            if (!notifyWithOnyxSubscibers) {
+            if (!notifyWithOnyxSubscribers) {
                 continue;
             }
             // We are subscribed to a collection key so we must update the data in state with the new
@@ -1171,6 +1172,51 @@ function unsubscribeFromKey(subscriptionID) {
     deleteKeyBySubscriptions(lastSubscriptionID);
     delete callbackToStateMapping[subscriptionID];
 }
+function updateSnapshots(data, mergeFn) {
+    const snapshotCollectionKey = OnyxUtils.getSnapshotKey();
+    if (!snapshotCollectionKey)
+        return [];
+    const promises = [];
+    const snapshotCollection = OnyxUtils.getCachedCollection(snapshotCollectionKey);
+    const snapshotCollectionKeyLength = snapshotCollectionKey.length;
+    Object.entries(snapshotCollection).forEach(([snapshotEntryKey, snapshotEntryValue]) => {
+        // Snapshots may not be present in cache. We don't know how to update them so we skip.
+        if (!snapshotEntryValue) {
+            return;
+        }
+        let updatedData = {};
+        data.forEach(({ key, value }) => {
+            // snapshots are normal keys so we want to skip update if they are written to Onyx
+            if (OnyxUtils.isCollectionMemberKey(snapshotCollectionKey, key, snapshotCollectionKeyLength)) {
+                return;
+            }
+            if (typeof snapshotEntryValue !== 'object' || !('data' in snapshotEntryValue)) {
+                return;
+            }
+            const snapshotData = snapshotEntryValue.data;
+            if (!snapshotData || !snapshotData[key]) {
+                return;
+            }
+            if (Array.isArray(value) || Array.isArray(snapshotData[key])) {
+                updatedData[key] = value || [];
+                return;
+            }
+            if (value === null) {
+                updatedData[key] = value;
+                return;
+            }
+            const oldValue = updatedData[key] || {};
+            const newValue = (0, pick_1.default)(value, Object.keys(snapshotData[key]));
+            updatedData = Object.assign(Object.assign({}, updatedData), { [key]: Object.assign(oldValue, newValue) });
+        });
+        // Skip the update if there's no data to be merged
+        if (utils_1.default.isEmptyObject(updatedData)) {
+            return;
+        }
+        promises.push(() => mergeFn(snapshotEntryKey, { data: updatedData }));
+    });
+    return promises;
+}
 const OnyxUtils = {
     METHOD,
     getMergeQueue,
@@ -1220,6 +1266,11 @@ const OnyxUtils = {
     getEvictionBlocklist,
     getSkippableCollectionMemberIDs,
     setSkippableCollectionMemberIDs,
+    storeKeyBySubscriptions,
+    deleteKeyBySubscriptions,
+    addKeyToRecentlyAccessedIfNeeded,
+    reduceCollectionWithSelector,
+    updateSnapshots,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {

package/dist/useOnyx.d.ts

@@ -49,10 +49,11 @@ type UseOnyxSelectorOption<TKey extends OnyxKey, TReturnValue> = {
 };
 type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & UseOnyxSelectorOption<TKey, TReturnValue>;
 type FetchStatus = 'loading' | 'loaded';
-type ResultMetadata = {
+type ResultMetadata<TValue> = {
     status: FetchStatus;
+    sourceValue?: NonNullable<TValue> | undefined;
 };
-type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
+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>;
 export default useOnyx;

package/dist/useOnyx.js

@@ -87,6 +87,8 @@ function useOnyx(key, options, dependencies = []) {
     const onStoreChangeFnRef = (0, react_1.useRef)(null);
     // Indicates if we should get the newest cached value from Onyx during `getSnapshot()` execution.
     const shouldGetCachedValueRef = (0, react_1.useRef)(true);
+    // Inside useOnyx.ts, we need to track the sourceValue separately
+    const sourceValueRef = (0, react_1.useRef)(undefined);
     (0, react_1.useEffect)(() => {
         // These conditions will ensure we can only handle dynamic collection member keys from the same collection.
         if ((options === null || options === void 0 ? void 0 : options.allowDynamicKey) || previousKey === key) {
@@ -191,7 +193,13 @@ function useOnyx(key, options, dependencies = []) {
             previousValueRef.current = newValueRef.current;
             // If the new value is `null` we default it to `undefined` to ensure the consumer gets a consistent result from the hook.
             const newStatus = newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded';
-            resultRef.current = [(_c = previousValueRef.current) !== null && _c !== void 0 ? _c : undefined, { status: newStatus }];
+            resultRef.current = [
+                (_c = previousValueRef.current) !== null && _c !== void 0 ? _c : undefined,
+                {
+                    status: newStatus,
+                    sourceValue: sourceValueRef.current,
+                },
+            ];
             // If `canBeMissing` is set to `false` and the Onyx value of that key is not defined,
             // we log an alert so it can be acknowledged by the consumer. Additionally, we won't log alerts
             // if there's a `Onyx.clear()` task in progress.
@@ -206,7 +214,7 @@ function useOnyx(key, options, dependencies = []) {
         onStoreChangeFnRef.current = onStoreChange;
         connectionRef.current = OnyxConnectionManager_1.default.connect({
             key,
-            callback: () => {
+            callback: (value, callbackKey, sourceValue) => {
                 isConnectingRef.current = false;
                 onStoreChangeFnRef.current = onStoreChange;
                 // Signals that the first connection was made, so some logics in `getSnapshot()`
@@ -214,6 +222,8 @@ function useOnyx(key, options, dependencies = []) {
                 isFirstConnectionRef.current = false;
                 // Signals that we want to get the newest cached value again in `getSnapshot()`.
                 shouldGetCachedValueRef.current = true;
+                // sourceValue is unknown type, so we need to cast it to the correct type.
+                sourceValueRef.current = sourceValue;
                 // Finally, we signal that the store changed, making `getSnapshot()` be called again.
                 onStoreChange();
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.99",
+  "version": "2.0.101",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -31,12 +31,14 @@
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "test": "jest",
+    "perf-test": "npx reassure",
     "build": "tsc -p tsconfig.build.json",
     "build:watch": "nodemon --watch lib --ext js,json,ts,tsx --exec \"npm run build && npm pack\"",
     "prebuild:docs": "npm run build",
     "build:docs": "ts-node buildDocs.ts",
     "lint-tests": "eslint tests/**",
-    "prettier": "prettier --write ."
+    "prettier": "prettier --write .",
+    "gh-actions-build": "./.github/scripts/buildActions.sh"
   },
   "dependencies": {
     "ascii-table": "0.0.9",
@@ -66,6 +68,8 @@
     "@types/underscore": "^1.11.15",
     "@typescript-eslint/eslint-plugin": "^6.19.0",
     "@typescript-eslint/parser": "^6.19.0",
+    "@vercel/ncc": "0.38.1",
+    "date-fns": "^4.1.0",
     "eslint": "^8.56.0",
     "eslint-config-expensify": "^2.0.44",
     "eslint-config-prettier": "^8.8.0",
@@ -87,7 +91,7 @@
     "react-native-performance": "^2.0.0",
     "react-native-quick-sqlite": "^8.0.6",
     "react-test-renderer": "18.1.0",
-    "reassure": "^0.11.0",
+    "reassure": "1.4.0",
     "ts-node": "^10.9.2",
     "type-fest": "^3.12.0",
     "typescript": "^5.4.5"