react-native-onyx 2.0.141 → 3.0.1

package/dist/OnyxUtils.js

@@ -39,13 +39,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearOnyxUtilsInternals = clearOnyxUtilsInternals;
 /* 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 underscore_1 = __importDefault(require("underscore"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
-const PerformanceUtils = __importStar(require("./PerformanceUtils"));
 const Str = __importStar(require("./Str"));
 const batch_1 = __importDefault(require("./batch"));
 const storage_1 = __importDefault(require("./storage"));
@@ -192,10 +190,10 @@ function batchUpdates(updates) {
  * 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.
  */
-function reduceCollectionWithSelector(collection, selector, withOnyxInstanceState) {
+function reduceCollectionWithSelector(collection, selector) {
     return Object.entries(collection !== null && collection !== void 0 ? collection : {}).reduce((finalCollection, [key, item]) => {
         // eslint-disable-next-line no-param-reassign
-        finalCollection[key] = selector(item, withOnyxInstanceState);
+        finalCollection[key] = selector(item);
         return finalCollection;
     }, {});
 }
@@ -436,7 +434,7 @@ function getCollectionKey(key) {
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.
  */
-function tryGetCachedValue(key, mapping) {
+function tryGetCachedValue(key) {
     let val = OnyxCache_1.default.get(key);
     if (isCollectionKey(key)) {
         const collectionData = OnyxCache_1.default.getCollectionData(key);
@@ -452,13 +450,6 @@ function tryGetCachedValue(key, mapping) {
             val = {};
         }
     }
-    if (mapping === null || mapping === void 0 ? void 0 : mapping.selector) {
-        const state = mapping.withOnyxInstance ? mapping.withOnyxInstance.state : undefined;
-        if (isCollectionKey(key)) {
-            return reduceCollectionWithSelector(val, mapping.selector, state);
-        }
-        return mapping.selector(val, state);
-    }
     return val;
 }
 function getCachedCollection(collectionKey, collectionMemberKeys) {
@@ -503,7 +494,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, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true) {
+function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyConnectSubscribers = 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);
@@ -565,94 +556,6 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
             }
             continue;
         }
-        // React component subscriber found.
-        if (utils_1.default.hasWithOnyxInstance(subscriber)) {
-            if (!notifyWithOnyxSubscribers) {
-                continue;
-            }
-            // We are subscribed to a collection key so we must update the data in state with the new
-            // collection member key values from the partial update.
-            if (isSubscribedToCollectionKey) {
-                // If the subscriber has a selector, then the component's state must only be updated with the data
-                // returned by the selector.
-                const collectionSelector = subscriber.selector;
-                if (collectionSelector) {
-                    subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                        const previousData = prevState[subscriber.statePropertyName];
-                        const newData = reduceCollectionWithSelector(cachedCollection, collectionSelector, subscriber.withOnyxInstance.state);
-                        if ((0, fast_equals_1.deepEqual)(previousData, newData)) {
-                            return null;
-                        }
-                        return {
-                            [subscriber.statePropertyName]: newData,
-                        };
-                    });
-                    continue;
-                }
-                subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                    var _a;
-                    const prevCollection = (_a = prevState === null || prevState === void 0 ? void 0 : prevState[subscriber.statePropertyName]) !== null && _a !== void 0 ? _a : {};
-                    const finalCollection = (0, clone_1.default)(prevCollection);
-                    const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
-                    for (const dataKey of dataKeys) {
-                        finalCollection[dataKey] = cachedCollection[dataKey];
-                    }
-                    if ((0, fast_equals_1.deepEqual)(prevCollection, finalCollection)) {
-                        return null;
-                    }
-                    PerformanceUtils.logSetStateCall(subscriber, prevState === null || prevState === void 0 ? void 0 : prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
-                    return {
-                        [subscriber.statePropertyName]: finalCollection,
-                    };
-                });
-                continue;
-            }
-            // 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)(cachedCollection[subscriber.key], previousCollection[subscriber.key])) {
-                    continue;
-                }
-                // However, we only want to update this subscriber if the partial data contains a change.
-                // Otherwise, we would update them with a value they already have and trigger an unnecessary re-render.
-                const dataFromCollection = partialCollection === null || partialCollection === void 0 ? void 0 : partialCollection[subscriber.key];
-                if (dataFromCollection === undefined) {
-                    continue;
-                }
-                // If the subscriber has a selector, then the component's state must only be updated with the data
-                // returned by the selector and the state should only change when the subset of data changes from what
-                // it was previously.
-                const selector = subscriber.selector;
-                if (selector) {
-                    subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                        const prevData = prevState[subscriber.statePropertyName];
-                        const newData = selector(cachedCollection[subscriber.key], subscriber.withOnyxInstance.state);
-                        if ((0, fast_equals_1.deepEqual)(prevData, newData)) {
-                            return null;
-                        }
-                        PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
-                        return {
-                            [subscriber.statePropertyName]: newData,
-                        };
-                    });
-                    continue;
-                }
-                subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                    const prevData = prevState[subscriber.statePropertyName];
-                    const newData = cachedCollection[subscriber.key];
-                    // Avoids triggering unnecessary re-renders when feeding empty objects
-                    if (utils_1.default.isEmptyObject(newData) && utils_1.default.isEmptyObject(prevData)) {
-                        return null;
-                    }
-                    if ((0, fast_equals_1.deepEqual)(prevData, newData)) {
-                        return null;
-                    }
-                    PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
-                    return {
-                        [subscriber.statePropertyName]: newData,
-                    };
-                });
-            }
-        }
     }
 }
 /**
@@ -661,7 +564,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true) {
+function keyChanged(key, value, canUpdateSubscriber = () => true, notifyConnectSubscribers = true) {
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
@@ -671,8 +574,7 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
         OnyxCache_1.default.removeLastAccessedKey(key);
     }
     // We get the subscribers interested in the key that has just changed. If the subscriber's  key is a collection key then we will
-    // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match. Depending on whether the subscriber
-    // was connected via withOnyx we will call setState() directly on the withOnyx instance. If it is a regular connection we will pass the data to the provided callback.
+    // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match.
     // Given the amount of times this function is called we need to make sure we are not iterating over all subscribers every time. On the other hand, we don't need to
     // do the same in keysChanged, because we only call that function when a collection key changes, and it doesn't happen that often.
     // For performance reason, we look for the given key and later if don't find it we look for the collection key, instead of checking if it is a collection key first.
@@ -721,119 +623,19 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
             lastConnectionCallbackData.set(subscriber.subscriptionID, value);
             continue;
         }
-        // Subscriber connected via withOnyx() HOC
-        if (utils_1.default.hasWithOnyxInstance(subscriber)) {
-            if (!notifyWithOnyxSubscribers) {
-                continue;
-            }
-            const selector = subscriber.selector;
-            // Check if we are subscribing to a collection key and overwrite the collection member key value in state
-            if (isCollectionKey(subscriber.key)) {
-                // If the subscriber has a selector, then the consumer of this data must only be given the data
-                // returned by the selector and only when the selected data has changed.
-                if (selector) {
-                    subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                        const prevWithOnyxData = prevState[subscriber.statePropertyName];
-                        const newWithOnyxData = {
-                            [key]: selector(value, subscriber.withOnyxInstance.state),
-                        };
-                        const prevDataWithNewData = Object.assign(Object.assign({}, prevWithOnyxData), newWithOnyxData);
-                        if ((0, fast_equals_1.deepEqual)(prevWithOnyxData, prevDataWithNewData)) {
-                            return null;
-                        }
-                        PerformanceUtils.logSetStateCall(subscriber, prevWithOnyxData, newWithOnyxData, 'keyChanged', key);
-                        return {
-                            [subscriber.statePropertyName]: prevDataWithNewData,
-                        };
-                    });
-                    continue;
-                }
-                subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                    const prevCollection = prevState[subscriber.statePropertyName] || {};
-                    const newCollection = Object.assign(Object.assign({}, prevCollection), { [key]: value });
-                    if ((0, fast_equals_1.deepEqual)(prevCollection, newCollection)) {
-                        return null;
-                    }
-                    PerformanceUtils.logSetStateCall(subscriber, prevCollection, newCollection, 'keyChanged', key);
-                    return {
-                        [subscriber.statePropertyName]: newCollection,
-                    };
-                });
-                continue;
-            }
-            // If the subscriber has a selector, then the component's state must only be updated with the data
-            // returned by the selector and only if the selected data has changed.
-            if (selector) {
-                subscriber.withOnyxInstance.setStateProxy(() => {
-                    const prevValue = selector(previousValue, subscriber.withOnyxInstance.state);
-                    const newValue = selector(value, subscriber.withOnyxInstance.state);
-                    if ((0, fast_equals_1.deepEqual)(prevValue, newValue)) {
-                        return null;
-                    }
-                    return {
-                        [subscriber.statePropertyName]: newValue,
-                    };
-                });
-                continue;
-            }
-            // If we did not match on a collection key then we just set the new data to the state property
-            subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                const prevWithOnyxValue = prevState[subscriber.statePropertyName];
-                // Avoids triggering unnecessary re-renders when feeding empty objects
-                if (utils_1.default.isEmptyObject(value) && utils_1.default.isEmptyObject(prevWithOnyxValue)) {
-                    return null;
-                }
-                if (prevWithOnyxValue === value) {
-                    return null;
-                }
-                PerformanceUtils.logSetStateCall(subscriber, previousValue, value, 'keyChanged', key);
-                return {
-                    [subscriber.statePropertyName]: value,
-                };
-            });
-            continue;
-        }
-        console.error('Warning: Found a matching subscriber to a key that changed, but no callback or withOnyxInstance could be found.');
+        console.error('Warning: Found a matching subscriber to a key that changed, but no callback could be found.');
     }
 }
 /**
- * Sends the data obtained from the keys to the connection. It either:
- *     - sets state on the withOnyxInstances
- *     - triggers the callback function
+ * Sends the data obtained from the keys to the connection.
  */
-function sendDataToConnection(mapping, value, matchedKey, isBatched) {
+function sendDataToConnection(mapping, value, matchedKey) {
     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.
+    // This means our subscriber was disconnected.
     if (!callbackToStateMapping[mapping.subscriptionID]) {
         return;
     }
-    if (utils_1.default.hasWithOnyxInstance(mapping)) {
-        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(value, mapping.selector, mapping.withOnyxInstance.state);
-            }
-            else {
-                newData = mapping.selector(value, mapping.withOnyxInstance.state);
-            }
-        }
-        PerformanceUtils.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
-        if (isBatched) {
-            batchUpdates(() => mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData));
-        }
-        else {
-            mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData);
-        }
-        return;
-    }
-    // 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.
     const valueToPass = value === null ? undefined : value;
     const lastValue = lastConnectionCallbackData.get(mapping.subscriptionID);
@@ -848,21 +650,14 @@ function sendDataToConnection(mapping, value, matchedKey, isBatched) {
  * 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.
  */
-function addKeyToRecentlyAccessedIfNeeded(mapping) {
-    if (!OnyxCache_1.default.isEvictableKey(mapping.key)) {
+function addKeyToRecentlyAccessedIfNeeded(key) {
+    if (!OnyxCache_1.default.isEvictableKey(key)) {
         return;
     }
     // Add the key to recentKeys first (this makes it the most recent key)
-    OnyxCache_1.default.addToAccessedKeys(mapping.key);
+    OnyxCache_1.default.addToAccessedKeys(key);
     // Try to free some cache whenever we connect to a safe eviction key
     OnyxCache_1.default.removeLeastRecentlyUsedKeys();
-    if (utils_1.default.hasWithOnyxInstance(mapping) && !isCollectionKey(mapping.key)) {
-        // All React components subscribing to a key flagged as a safe eviction key must implement the canEvict property.
-        if (mapping.canEvict === undefined) {
-            throw new Error(`Cannot subscribe to safe eviction key '${mapping.key}' without providing a canEvict value.`);
-        }
-        OnyxCache_1.default.addLastAccessedKey(mapping.key, isCollectionKey(mapping.key));
-    }
 }
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
@@ -870,7 +665,7 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
     multiGet(matchingKeys).then((dataMap) => {
         const data = Object.fromEntries(dataMap.entries());
-        sendDataToConnection(mapping, data, undefined, true);
+        sendDataToConnection(mapping, data, undefined);
     });
 }
 /**
@@ -879,9 +674,9 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function scheduleSubscriberUpdate(key, value, previousValue, canUpdateSubscriber = () => true) {
-    const promise = Promise.resolve().then(() => keyChanged(key, value, previousValue, canUpdateSubscriber, true, false));
-    batchUpdates(() => keyChanged(key, value, previousValue, canUpdateSubscriber, false, true));
+function scheduleSubscriberUpdate(key, value, canUpdateSubscriber = () => true) {
+    const promise = Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber, true));
+    batchUpdates(() => keyChanged(key, value, canUpdateSubscriber, false));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -890,17 +685,16 @@ function scheduleSubscriberUpdate(key, value, previousValue, canUpdateSubscriber
  * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
  */
 function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
-    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true, false));
-    batchUpdates(() => keysChanged(key, value, previousValue, false, true));
+    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true));
+    batchUpdates(() => keysChanged(key, value, previousValue, false));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
  * Remove a key from Onyx and update the subscribers
  */
 function remove(key) {
-    const prevValue = OnyxCache_1.default.get(key, false);
     OnyxCache_1.default.drop(key);
-    scheduleSubscriberUpdate(key, undefined, prevValue);
+    scheduleSubscriberUpdate(key, undefined);
     return storage_1.default.removeItem(key).then(() => undefined);
 }
 function reportStorageQuota() {
@@ -942,7 +736,6 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
  * Notifies subscribers and writes current value to cache
  */
 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) {
@@ -951,7 +744,7 @@ function broadcastUpdate(key, value, hasChanged) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
+    return scheduleSubscriberUpdate(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -1036,7 +829,7 @@ function initializeWithDefaultKeyStates() {
             shouldRemoveNestedNulls: true,
         }).result;
         OnyxCache_1.default.merge(merged !== null && merged !== void 0 ? merged : {});
-        Object.entries(merged !== null && merged !== void 0 ? merged : {}).forEach(([key, value]) => keyChanged(key, value, existingDataAsObject));
+        Object.entries(merged !== null && merged !== void 0 ? merged : {}).forEach(([key, value]) => keyChanged(key, value));
     });
 }
 /**
@@ -1082,7 +875,7 @@ function subscribeToKey(connectOptions) {
     }
     // Commit connection only after init passes
     deferredInitTask.promise
-        .then(() => addKeyToRecentlyAccessedIfNeeded(mapping))
+        .then(() => addKeyToRecentlyAccessedIfNeeded(mapping.key))
         .then(() => {
         // Performance improvement
         // If the mapping is connected to an onyx key that is not a collection
@@ -1114,15 +907,14 @@ function subscribeToKey(connectOptions) {
         }
         // If the key being connected to does not exist we initialize the value with null. For subscribers that connected
         // directly via connect() they will simply get a null value sent to them without any information about which key matched
-        // since there are none matched. In withOnyx() we wait for all connected keys to return a value before rendering the child
-        // component. This null value will be filtered out so that the connected component can utilize defaultProps.
+        // since there are none matched.
         if (matchingKeys.length === 0) {
             if (mapping.key) {
                 OnyxCache_1.default.addNullishStorageKey(mapping.key);
             }
             // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
-            sendDataToConnection(mapping, null, undefined, false);
+            sendDataToConnection(mapping, null, undefined);
             return;
         }
         // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
@@ -1137,27 +929,16 @@ function subscribeToKey(connectOptions) {
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
                 multiGet(matchingKeys).then((values) => {
                     values.forEach((val, key) => {
-                        sendDataToConnection(mapping, val, key, true);
+                        sendDataToConnection(mapping, val, key);
                     });
                 });
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
-            get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key, true));
-            return;
-        }
-        // If we have a withOnyxInstance that means a React component has subscribed via the withOnyx() HOC and we need to
-        // group collection key member data into an object.
-        if (utils_1.default.hasWithOnyxInstance(mapping)) {
-            if (isCollectionKey(mapping.key)) {
-                getCollectionDataAndSendAsObject(matchingKeys, mapping);
-                return;
-            }
-            // If the subscriber is not using a collection key then we just send a single value back to the subscriber
-            get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key, true));
+            get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key));
             return;
         }
-        console.error('Warning: Onyx.connect() was found without a callback or withOnyxInstance');
+        console.error('Warning: Onyx.connect() was found without a callback');
     });
     // The subscriptionID is returned back to the caller so that it can be used to clean up the connection when it's no longer needed
     // by calling OnyxUtils.unsubscribeFromKey(subscriptionID).

package/dist/index.d.ts

@@ -4,9 +4,7 @@ import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, O
 import type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions } from './useOnyx';
 import type { Connection } from './OnyxConnectionManager';
 import useOnyx from './useOnyx';
-import withOnyx from './withOnyx';
-import type { WithOnyxState } from './withOnyx/types';
 import type { OnyxSQLiteKeyValuePair } from './storage/providers/SQLiteProvider';
 export default Onyx;
-export { useOnyx, withOnyx };
-export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, Connection, UseOnyxOptions, OnyxSQLiteKeyValuePair, };
+export { useOnyx };
+export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, Connection, UseOnyxOptions, OnyxSQLiteKeyValuePair, };

package/dist/index.js

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

package/dist/types.d.ts

@@ -1,7 +1,6 @@
 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';
 import type { OnyxMethod } from './OnyxUtils';
 import type { FastMergeReplaceNullPatch } from './utils';
 /**
@@ -104,69 +103,21 @@ type OnyxKey = Key | CollectionKey;
 /**
  * Represents a selector function type which operates based on the provided `TKey` and `ReturnType`.
  *
- * A `Selector` is a function that accepts a value, the withOnyx's internal state and returns a processed value.
+ * A `Selector` is a function that accepts a value and returns a processed value.
  * This type accepts two type parameters: `TKey` and `TReturnType`.
  *
  * 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?: WithOnyxState<TOnyxProps>) => TReturnType;
+type Selector<TKey extends OnyxKey, TReturnType> = (value: OnyxEntry<KeyValueMapping[TKey]>) => TReturnType;
 /**
  * Represents a single Onyx entry, that can be either `TOnyxValue` or `undefined` if it doesn't exist.
- *
- * It can be used to specify data retrieved from Onyx e.g. `withOnyx` HOC mappings.
- *
- * @example
- * ```ts
- * import Onyx, {OnyxEntry, withOnyx} from 'react-native-onyx';
- *
- * type OnyxProps = {
- *     userAccount: OnyxEntry<Account>;
- * };
- *
- * type Props = OnyxProps & {
- *     prop1: string;
- * };
- *
- * function Component({prop1, userAccount}: Props) {
- *     // ...
- * }
- *
- * export default withOnyx<Props, OnyxProps>({
- *     userAccount: {
- *         key: ONYXKEYS.ACCOUNT,
- *     },
- * })(Component);
- * ```
+ * It can be used to specify data retrieved from Onyx.
  */
 type OnyxEntry<TOnyxValue> = TOnyxValue | undefined;
 /**
  * Represents an Onyx collection of entries, that can be either a record of `TOnyxValue`s or `undefined` if it is empty or doesn't exist.
- *
- * It can be used to specify collection data retrieved from Onyx e.g. `withOnyx` HOC mappings.
- *
- * @example
- * ```ts
- * import Onyx, {OnyxCollection, withOnyx} from 'react-native-onyx';
- *
- * type OnyxProps = {
- *     reports: OnyxCollection<Report>;
- * };
- *
- * type Props = OnyxProps & {
- *     prop1: string;
- * };
- *
- * function Component({prop1, reports}: Props) {
- *     // ...
- * }
- *
- * export default withOnyx<Props, OnyxProps>({
- *     reports: {
- *         key: ONYXKEYS.COLLECTION.REPORT,
- *     },
- * })(Component);
- * ```
+ * It can be used to specify collection data retrieved from Onyx.
  */
 type OnyxCollection<TOnyxValue> = OnyxEntry<Record<string, TOnyxValue | undefined>>;
 /**
@@ -270,25 +221,7 @@ type CollectionConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & {
  * and will pass `value` as an `OnyxEntry`.
  */
 type ConnectOptions<TKey extends OnyxKey> = DefaultConnectOptions<TKey> | CollectionConnectOptions<TKey>;
-/** Represents additional `Onyx.connect()` options used inside `withOnyx()` HOC. */
-type WithOnyxConnectOptions<TKey extends OnyxKey> = ConnectOptions<TKey> & {
-    /** The `withOnyx` class instance to be internally passed. */
-    withOnyxInstance: WithOnyxInstance;
-    /** The name of the component's prop that is connected to the Onyx key. */
-    statePropertyName: string;
-    /** The component's display name. */
-    displayName: string;
-    /**
-     * This will be used to subscribe to a subset of an Onyx key's data.
-     * Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render
-     * when the subset of data changes. Otherwise, any change of data on any property would normally
-     * cause the component to re-render (and that can be expensive from a performance standpoint).
-     */
-    selector?: Selector<TKey, unknown, unknown>;
-    /** Determines if this key in this subscription is safe to be evicted. */
-    canEvict?: boolean;
-};
-type Mapping<TKey extends OnyxKey> = WithOnyxConnectOptions<TKey> & {
+type CallbackToStateMapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
     subscriptionID: number;
 };
 /**
@@ -399,8 +332,6 @@ type InitOptions = {
      * of Onyx running in different tabs/windows. Defaults to true for platforms that support local storage (web/desktop)
      */
     shouldSyncMultipleInstances?: boolean;
-    /** Enables debugging setState() calls to connected components */
-    debugSetState?: boolean;
     /**
      * If enabled it will use the performance API to measure the time taken by Onyx operations.
      * @default false
@@ -428,4 +359,4 @@ type MixedOperationsQueue = {
     mergeReplaceNullPatches: MultiMergeReplaceNullPatches;
     set: OnyxInputKeyValueMapping;
 };
-export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, Mapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, WithOnyxConnectOptions, MultiMergeReplaceNullPatches, MixedOperationsQueue, };
+export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, MultiMergeReplaceNullPatches, MixedOperationsQueue, };

package/dist/useOnyx.js

@@ -152,7 +152,6 @@ function useOnyx(key, options, dependencies = []) {
         onStoreChangeFnRef.current();
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [...dependencies]);
-    // Mimics withOnyx's checkEvictableKeys() behavior.
     const checkEvictableKey = (0, react_1.useCallback)(() => {
         if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionRef.current) {
             return;

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectOptions, OnyxInput, OnyxKey } from './types';
+import type { OnyxInput, OnyxKey } from './types';
 type EmptyObject = Record<string, never>;
 type EmptyValue = EmptyObject | null | undefined;
 /**
@@ -63,10 +63,6 @@ declare function pick<TValue>(obj: Record<string, TValue>, condition: string | s
  * @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>;
-/**
- * Whether the connect options has the `withOnyxInstance` property defined, that is, it's used by the `withOnyx()` HOC.
- */
-declare function hasWithOnyxInstance<TKey extends OnyxKey>(mapping: ConnectOptions<TKey>): unknown;
 declare const _default: {
     fastMerge: typeof fastMerge;
     isEmptyObject: typeof isEmptyObject;
@@ -75,7 +71,6 @@ declare const _default: {
     checkCompatibilityWithExistingValue: typeof checkCompatibilityWithExistingValue;
     pick: typeof pick;
     omit: typeof omit;
-    hasWithOnyxInstance: typeof hasWithOnyxInstance;
     ONYX_INTERNALS__REPLACE_OBJECT_MARK: string;
 };
 export default _default;

package/dist/utils.js

@@ -204,12 +204,6 @@ function pick(obj, condition) {
 function omit(obj, condition) {
     return filterObject(obj, condition, false);
 }
-/**
- * Whether the connect options has the `withOnyxInstance` property defined, that is, it's used by the `withOnyx()` HOC.
- */
-function hasWithOnyxInstance(mapping) {
-    return 'withOnyxInstance' in mapping && mapping.withOnyxInstance;
-}
 exports.default = {
     fastMerge,
     isEmptyObject,
@@ -218,6 +212,5 @@ exports.default = {
     checkCompatibilityWithExistingValue,
     pick,
     omit,
-    hasWithOnyxInstance,
     ONYX_INTERNALS__REPLACE_OBJECT_MARK,
 };

package/package.json

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