react-native-onyx 1.0.131 → 2.0.2

package/{lib → dist}/withOnyx.js

@@ -1,19 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * 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 PropTypes from 'prop-types';
-import React from 'react';
-import _ from 'underscore';
-import Onyx from './Onyx';
-import * as Str from './Str';
-import utils from './utils';
-
+const prop_types_1 = __importDefault(require("prop-types"));
+const react_1 = __importDefault(require("react"));
+const underscore_1 = __importDefault(require("underscore"));
+const Onyx_1 = __importDefault(require("./Onyx"));
+const Str = __importStar(require("./Str"));
+const utils_1 = __importDefault(require("./utils"));
 // This is a list of keys that can exist on a `mapping`, but are not directly related to loading data from Onyx. When the keys of a mapping are looped over to check
 // if a key has changed, it's a good idea to skip looking at these properties since they would have unexpected results.
 const mappingPropertiesToIgnoreChangesTo = ['initialValue', 'allowStaleData'];
-
 /**
  * Returns the display name of a component
  *
@@ -23,7 +49,6 @@ const mappingPropertiesToIgnoreChangesTo = ['initialValue', 'allowStaleData'];
 function getDisplayName(component) {
     return component.displayName || component.name || 'Component';
 }
-
 /**
  * Removes all the keys from state that are unrelated to the onyx data being mapped to the component.
  *
@@ -31,82 +56,66 @@ function getDisplayName(component) {
  * @param {Object} onyxToStateMapping the object holding all of the mapping configuration for the component
  * @returns {Object}
  */
-const getOnyxDataFromState = (state, onyxToStateMapping) => _.pick(state, _.keys(onyxToStateMapping));
-
-export default function (mapOnyxToState, shouldDelayUpdates = false) {
+const getOnyxDataFromState = (state, onyxToStateMapping) => underscore_1.default.pick(state, underscore_1.default.keys(onyxToStateMapping));
+function default_1(mapOnyxToState, shouldDelayUpdates = false) {
     // A list of keys that must be present in tempState before we can render the WrappedComponent
-    const requiredKeysForInit = _.chain(mapOnyxToState)
+    const requiredKeysForInit = underscore_1.default.chain(mapOnyxToState)
         .omit((config) => config.initWithStoredValues === false)
         .keys()
         .value();
     return (WrappedComponent) => {
         const displayName = getDisplayName(WrappedComponent);
-        class withOnyx extends React.Component {
-            pendingSetStates = [];
-
+        class withOnyx extends react_1.default.Component {
             constructor(props) {
                 super(props);
+                this.pendingSetStates = [];
                 this.shouldDelayUpdates = shouldDelayUpdates;
                 this.setWithOnyxState = this.setWithOnyxState.bind(this);
                 this.flushPendingSetStates = this.flushPendingSetStates.bind(this);
-
                 // This stores all the Onyx connection IDs to be used when the component unmounts so everything can be
                 // disconnected. It is a key value store with the format {[mapping.key]: connectionID}.
                 this.activeConnectionIDs = {};
-
-                const cachedState = _.reduce(
-                    mapOnyxToState,
-                    (resultObj, mapping, propertyName) => {
-                        const key = Str.result(mapping.key, props);
-                        let value = Onyx.tryGetCachedValue(key, mapping);
-                        if (!value && mapping.initialValue) {
-                            value = mapping.initialValue;
-                        }
-
-                        /**
-                         * If we have a pending merge for a key it could mean that data is being set via Onyx.merge() and someone expects a component to have this data immediately.
-                         *
-                         * @example
-                         *
-                         * Onyx.merge('report_123', value);
-                         * Navigation.navigate(route); // Where "route" expects the "value" to be available immediately once rendered.
-                         *
-                         * In reality, Onyx.merge() will only update the subscriber after all merges have been batched and the previous value is retrieved via a get() (returns a promise).
-                         * So, we won't use the cache optimization here as it will lead us to arbitrarily defer various actions in the application code.
-                         */
-                        if ((value !== undefined && !Onyx.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
-                            // eslint-disable-next-line no-param-reassign
-                            resultObj[propertyName] = value;
-                        }
-
-                        return resultObj;
-                    },
-                    {},
-                );
-
+                const cachedState = underscore_1.default.reduce(mapOnyxToState, (resultObj, mapping, propertyName) => {
+                    const key = Str.result(mapping.key, props);
+                    let value = Onyx_1.default.tryGetCachedValue(key, mapping);
+                    if (!value && mapping.initialValue) {
+                        value = mapping.initialValue;
+                    }
+                    /**
+                     * If we have a pending merge for a key it could mean that data is being set via Onyx.merge() and someone expects a component to have this data immediately.
+                     *
+                     * @example
+                     *
+                     * Onyx.merge('report_123', value);
+                     * Navigation.navigate(route); // Where "route" expects the "value" to be available immediately once rendered.
+                     *
+                     * In reality, Onyx.merge() will only update the subscriber after all merges have been batched and the previous value is retrieved via a get() (returns a promise).
+                     * So, we won't use the cache optimization here as it will lead us to arbitrarily defer various actions in the application code.
+                     */
+                    if ((value !== undefined && !Onyx_1.default.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
+                        // eslint-disable-next-line no-param-reassign
+                        resultObj[propertyName] = value;
+                    }
+                    return resultObj;
+                }, {});
                 // If we have all the data we need, then we can render the component immediately
-                cachedState.loading = _.size(cachedState) < requiredKeysForInit.length;
-
+                cachedState.loading = underscore_1.default.size(cachedState) < requiredKeysForInit.length;
                 // Object holding the temporary initial state for the component while we load the various Onyx keys
                 this.tempState = cachedState;
-
                 this.state = cachedState;
             }
-
             componentDidMount() {
                 const onyxDataFromState = getOnyxDataFromState(this.state, mapOnyxToState);
-
                 // Subscribe each of the state properties to the proper Onyx key
-                _.each(mapOnyxToState, (mapping, propertyName) => {
-                    if (_.includes(mappingPropertiesToIgnoreChangesTo, propertyName)) {
+                underscore_1.default.each(mapOnyxToState, (mapping, propertyName) => {
+                    if (underscore_1.default.includes(mappingPropertiesToIgnoreChangesTo, propertyName)) {
                         return;
                     }
-                    const key = Str.result(mapping.key, {...this.props, ...onyxDataFromState});
+                    const key = Str.result(mapping.key, Object.assign(Object.assign({}, this.props), onyxDataFromState));
                     this.connectMappingToOnyx(mapping, propertyName, key);
                 });
                 this.checkEvictableKeys();
             }
-
             componentDidUpdate(prevProps, prevState) {
                 // The whole purpose of this method is to check to see if a key that is subscribed to Onyx has changed, and then Onyx needs to be disconnected from the old
                 // key and connected to the new key.
@@ -114,13 +123,11 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                 const isFirstTimeUpdatingAfterLoading = prevState.loading && !this.state.loading;
                 const onyxDataFromState = getOnyxDataFromState(this.state, mapOnyxToState);
                 const prevOnyxDataFromState = getOnyxDataFromState(prevState, mapOnyxToState);
-
-                _.each(mapOnyxToState, (mapping, propName) => {
+                underscore_1.default.each(mapOnyxToState, (mapping, propName) => {
                     // Some properties can be ignored because they aren't related to onyx keys and they will never change
-                    if (_.includes(mappingPropertiesToIgnoreChangesTo, propName)) {
+                    if (underscore_1.default.includes(mappingPropertiesToIgnoreChangesTo, propName)) {
                         return;
                     }
-
                     // The previous key comes from either:
                     // 1) The initial key that was connected to (ie. set from `componentDidMount()`)
                     // 2) The updated props which caused `componentDidUpdate()` to run
@@ -128,33 +135,31 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                     // (eg. if a user switches chats really quickly). In this case, it's much more stable to always look at the changes to prevProp and prevState to derive the key.
                     // The second case cannot be used all the time because the onyx data doesn't change the first time that `componentDidUpdate()` runs after loading. In this case,
                     // the `mapping.previousKey` must be used for the comparison or else this logic never detects that onyx data could have changed during the loading process.
-                    const previousKey = isFirstTimeUpdatingAfterLoading ? mapping.previousKey : Str.result(mapping.key, {...prevProps, ...prevOnyxDataFromState});
-                    const newKey = Str.result(mapping.key, {...this.props, ...onyxDataFromState});
+                    const previousKey = isFirstTimeUpdatingAfterLoading ? mapping.previousKey : Str.result(mapping.key, Object.assign(Object.assign({}, prevProps), prevOnyxDataFromState));
+                    const newKey = Str.result(mapping.key, Object.assign(Object.assign({}, this.props), onyxDataFromState));
                     if (previousKey !== newKey) {
-                        Onyx.disconnect(this.activeConnectionIDs[previousKey], previousKey);
+                        Onyx_1.default.disconnect(this.activeConnectionIDs[previousKey], previousKey);
                         delete this.activeConnectionIDs[previousKey];
                         this.connectMappingToOnyx(mapping, propName, newKey);
                     }
                 });
                 this.checkEvictableKeys();
             }
-
             componentWillUnmount() {
                 // Disconnect everything from Onyx
-                _.each(mapOnyxToState, (mapping) => {
-                    const key = Str.result(mapping.key, {...this.props, ...getOnyxDataFromState(this.state, mapOnyxToState)});
-                    Onyx.disconnect(this.activeConnectionIDs[key], key);
+                underscore_1.default.each(mapOnyxToState, (mapping) => {
+                    const key = Str.result(mapping.key, Object.assign(Object.assign({}, this.props), getOnyxDataFromState(this.state, mapOnyxToState)));
+                    Onyx_1.default.disconnect(this.activeConnectionIDs[key], key);
                 });
             }
-
             setStateProxy(modifier) {
                 if (this.shouldDelayUpdates) {
                     this.pendingSetStates.push(modifier);
-                } else {
+                }
+                else {
                     this.setState(modifier);
                 }
             }
-
             /**
              * This method is used by the internal raw Onyx `sendDataToConnection`, it is designed to prevent unnecessary renders while a component
              * still in a "loading" (read "mounting") state. The temporary initial state is saved to the HOC instance and setState()
@@ -175,7 +180,6 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
              */
             setWithOnyxState(statePropertyName, val) {
                 const prevValue = this.state[statePropertyName];
-
                 // If the component is not loading (read "mounting"), then we can just update the state
                 // There is a small race condition.
                 // When calling setWithOnyxState we delete the tempState object that is used to hold temporary state updates while the HOC is gathering data.
@@ -185,60 +189,48 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                 // This simply bypasses the loading check if the tempState is gone and the update can be safely queued with a normal setStateProxy.
                 if (!this.state.loading || !this.tempState) {
                     // Performance optimization, do not trigger update with same values
-                    if (prevValue === val || utils.areObjectsEmpty(prevValue, val)) {
+                    if (prevValue === val || utils_1.default.areObjectsEmpty(prevValue, val)) {
                         return;
                     }
-
-                    this.setStateProxy({[statePropertyName]: val});
+                    this.setStateProxy({ [statePropertyName]: val });
                     return;
                 }
-
                 this.tempState[statePropertyName] = val;
-
                 // If some key does not have a value yet, do not update the state yet
-                const tempStateIsMissingKey = _.some(requiredKeysForInit, (key) => _.isUndefined(this.tempState[key]));
+                const tempStateIsMissingKey = underscore_1.default.some(requiredKeysForInit, (key) => underscore_1.default.isUndefined(this.tempState[key]));
                 if (tempStateIsMissingKey) {
                     return;
                 }
-
-                const stateUpdate = {...this.tempState};
+                const stateUpdate = Object.assign({}, this.tempState);
                 delete this.tempState;
-
                 // Full of hacky workarounds to prevent the race condition described above.
                 this.setState((prevState) => {
-                    const finalState = _.reduce(
-                        stateUpdate,
-                        (result, value, key) => {
-                            if (key === 'loading') {
-                                return result;
-                            }
-
-                            const initialValue = mapOnyxToState[key].initialValue;
-
-                            // If initialValue is there and the state contains something different it means
-                            // an update has already been received and we can discard the value we are trying to hydrate
-                            if (!_.isUndefined(initialValue) && !_.isUndefined(prevState[key]) && prevState[key] !== initialValue) {
-                                // eslint-disable-next-line no-param-reassign
-                                result[key] = prevState[key];
-
-                                // if value is already there (without initial value) then we can discard the value we are trying to hydrate
-                            } else if (!_.isUndefined(prevState[key])) {
-                                // eslint-disable-next-line no-param-reassign
-                                result[key] = prevState[key];
-                            } else {
-                                // eslint-disable-next-line no-param-reassign
-                                result[key] = value;
-                            }
+                    const finalState = underscore_1.default.reduce(stateUpdate, (result, value, key) => {
+                        if (key === 'loading') {
                             return result;
-                        },
-                        {},
-                    );
-
+                        }
+                        const initialValue = mapOnyxToState[key].initialValue;
+                        // If initialValue is there and the state contains something different it means
+                        // an update has already been received and we can discard the value we are trying to hydrate
+                        if (!underscore_1.default.isUndefined(initialValue) && !underscore_1.default.isUndefined(prevState[key]) && prevState[key] !== initialValue) {
+                            // eslint-disable-next-line no-param-reassign
+                            result[key] = prevState[key];
+                            // if value is already there (without initial value) then we can discard the value we are trying to hydrate
+                        }
+                        else if (!underscore_1.default.isUndefined(prevState[key])) {
+                            // eslint-disable-next-line no-param-reassign
+                            result[key] = prevState[key];
+                        }
+                        else {
+                            // eslint-disable-next-line no-param-reassign
+                            result[key] = value;
+                        }
+                        return result;
+                    }, {});
                     finalState.loading = false;
                     return finalState;
                 });
             }
-
             /**
              * Makes sure each Onyx key we requested has been set to state with a value of some kind.
              * We are doing this so that the wrapped component will only render when all the data
@@ -248,26 +240,23 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                 // We will add this key to our list of recently accessed keys
                 // if the canEvict function returns true. This is necessary criteria
                 // we MUST use to specify if a key can be removed or not.
-                _.each(mapOnyxToState, (mapping) => {
-                    if (_.isUndefined(mapping.canEvict)) {
+                underscore_1.default.each(mapOnyxToState, (mapping) => {
+                    if (underscore_1.default.isUndefined(mapping.canEvict)) {
                         return;
                     }
-
                     const canEvict = Str.result(mapping.canEvict, this.props);
                     const key = Str.result(mapping.key, this.props);
-
-                    if (!Onyx.isSafeEvictionKey(key)) {
+                    if (!Onyx_1.default.isSafeEvictionKey(key)) {
                         throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).`);
                     }
-
                     if (canEvict) {
-                        Onyx.removeFromEvictionBlockList(key, mapping.connectionID);
-                    } else {
-                        Onyx.addToEvictionBlockList(key, mapping.connectionID);
+                        Onyx_1.default.removeFromEvictionBlockList(key, mapping.connectionID);
+                    }
+                    else {
+                        Onyx_1.default.addToEvictionBlockList(key, mapping.connectionID);
                     }
                 });
             }
-
             /**
              * Takes a single mapping and binds the state of the component to the store
              *
@@ -284,77 +273,51 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                 // dependent keys to finish loading their data.
                 // eslint-disable-next-line no-param-reassign
                 mapOnyxToState[statePropertyName].previousKey = key;
-
                 // eslint-disable-next-line rulesdir/prefer-onyx-connect-in-libs
-                this.activeConnectionIDs[key] = Onyx.connect({
-                    ...mapping,
-                    key,
-                    statePropertyName,
-                    withOnyxInstance: this,
-                    displayName,
-                });
+                this.activeConnectionIDs[key] = Onyx_1.default.connect(Object.assign(Object.assign({}, mapping), { key,
+                    statePropertyName, withOnyxInstance: this, displayName }));
             }
-
             flushPendingSetStates() {
                 if (!this.shouldDelayUpdates) {
                     return;
                 }
-
                 this.shouldDelayUpdates = false;
-
                 this.pendingSetStates.forEach((modifier) => {
                     this.setState(modifier);
                 });
                 this.pendingSetStates = [];
             }
-
             render() {
                 // Remove any null values so that React replaces them with default props
-                const propsToPass = _.omit(this.props, _.isNull);
-
+                const propsToPass = underscore_1.default.omit(this.props, underscore_1.default.isNull);
                 if (this.state.loading) {
                     return null;
                 }
-
                 // Remove any internal state properties used by withOnyx
                 // that should not be passed to a wrapped component
-                let stateToPass = _.omit(this.state, 'loading');
-                stateToPass = _.omit(stateToPass, _.isNull);
-
+                let stateToPass = underscore_1.default.omit(this.state, 'loading');
+                stateToPass = underscore_1.default.omit(stateToPass, underscore_1.default.isNull);
                 // Spreading props and state is necessary in an HOC where the data cannot be predicted
-                return (
-                    <WrappedComponent
-                        markReadyForHydration={this.flushPendingSetStates}
-                        // eslint-disable-next-line react/jsx-props-no-spreading
-                        {...propsToPass}
-                        // eslint-disable-next-line react/jsx-props-no-spreading
-                        {...stateToPass}
-                        ref={this.props.forwardedRef}
-                    />
-                );
+                return (react_1.default.createElement(WrappedComponent, Object.assign({ markReadyForHydration: this.flushPendingSetStates }, propsToPass, stateToPass, { ref: this.props.forwardedRef })));
             }
         }
-
         withOnyx.propTypes = {
-            forwardedRef: PropTypes.oneOfType([
-                PropTypes.func,
+            forwardedRef: prop_types_1.default.oneOfType([
+                prop_types_1.default.func,
                 // eslint-disable-next-line react/forbid-prop-types
-                PropTypes.shape({current: PropTypes.object}),
+                prop_types_1.default.shape({ current: prop_types_1.default.object }),
             ]),
         };
         withOnyx.defaultProps = {
             forwardedRef: undefined,
         };
         withOnyx.displayName = `withOnyx(${displayName})`;
-        return React.forwardRef((props, ref) => {
+        return react_1.default.forwardRef((props, ref) => {
             const Component = withOnyx;
-            return (
-                <Component
-                    // eslint-disable-next-line react/jsx-props-no-spreading
-                    {...props}
-                    forwardedRef={ref}
-                />
-            );
+            return (react_1.default.createElement(Component
+            // eslint-disable-next-line react/jsx-props-no-spreading
+            , Object.assign({}, props, { forwardedRef: ref })));
         });
     };
 }
+exports.default = default_1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "1.0.131",
+  "version": "2.0.2",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -9,7 +9,7 @@
   "keywords": [
     "React Native",
     "React",
-    "Persistant storage",
+    "Persistent storage",
     "Pub/Sub"
   ],
   "repository": {
@@ -21,24 +21,20 @@
   },
   "files": [
     "dist/**/*",
-    "lib/**/*",
-    "native.js",
-    "web.js",
     "API.md",
     "README.md",
     "LICENSE.md"
   ],
-  "react-native": "native.js",
-  "main": "native.js",
-  "browser": "web.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "webpack --config webpack.config.js",
-    "build:docs": "node buildDocs.js",
     "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "build": "tsc -p tsconfig.build.json && cp ./lib/*.d.ts ./dist",
+    "build:docs": "node buildDocs.js",
     "lint-tests": "eslint tests/**",
-    "prettier": "prettier --write .",
-    "test": "jest"
+    "prettier": "prettier --write ."
   },
   "dependencies": {
     "ascii-table": "0.0.9",
@@ -46,27 +42,29 @@
     "underscore": "^1.13.6"
   },
   "devDependencies": {
-    "@babel/core": "7.20.12",
-    "@babel/preset-env": "^7.20.2",
-    "@babel/preset-react": "^7.18.6",
-    "@react-native-community/eslint-config": "^2.0.0",
+    "@lwc/eslint-plugin-lwc": "^1.7.2",
+    "@react-native-community/eslint-config": "^3.2.0",
+    "@react-native/polyfills": "^2.0.0",
     "@testing-library/jest-native": "^3.4.2",
     "@testing-library/react-native": "^7.0.2",
+    "@types/jest": "^28.1.8",
     "@types/node": "^20.11.5",
     "@types/react": "^18.2.14",
-    "babel-eslint": "^10.1.0",
-    "babel-jest": "^26.2.2",
-    "babel-loader": "^8.2.5",
-    "eslint": "^7.6.0",
-    "eslint-config-expensify": "^2.0.42",
+    "@types/react-dom": "^18.2.18",
+    "@types/react-native": "^0.70.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "eslint": "^8.56.0",
+    "eslint-config-expensify": "^2.0.43",
     "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-jsx-a11y": "^6.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsx-a11y": "^6.8.0",
     "eslint-plugin-react": "^7.31.10",
     "idb-keyval": "^6.2.1",
     "jest": "^26.5.2",
     "jest-cli": "^26.5.2",
     "jsdoc-to-markdown": "^7.1.0",
-    "metro-react-native-babel-preset": "^0.72.3",
+    "metro-react-native-babel-preset": "^0.77.0",
     "prettier": "^2.8.8",
     "prop-types": "^15.7.2",
     "react": "18.2.0",
@@ -77,9 +75,7 @@
     "react-native-quick-sqlite": "^8.0.6",
     "react-test-renderer": "18.1.0",
     "type-fest": "^3.12.0",
-    "webpack": "^5.72.1",
-    "webpack-cli": "^4.9.2",
-    "webpack-merge": "^5.8.0"
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "idb-keyval": "^6.2.1",
@@ -107,32 +103,5 @@
     "node": ">=20.10.0",
     "npm": ">=10.2.3"
   },
-  "jest": {
-    "preset": "react-native",
-    "transform": {
-      "^.+\\.jsx?$": "babel-jest"
-    },
-    "transformIgnorePatterns": [
-      "node_modules/(?!react-native)/"
-    ],
-    "testPathIgnorePatterns": [
-      "<rootDir>/node_modules/",
-      "<rootDir>/tests/unit/mocks/"
-    ],
-    "testMatch": [
-      "**/tests/unit/**/*.[jt]s?(x)",
-      "**/?(*.)+(spec|test).[jt]s?(x)"
-    ],
-    "globals": {
-      "__DEV__": true,
-      "WebSocket": {}
-    },
-    "timers": "fake",
-    "testEnvironment": "jsdom",
-    "setupFilesAfterEnv": [
-      "@testing-library/jest-native/extend-expect",
-      "./jestSetup.js"
-    ]
-  },
   "sideEffects": false
 }