react-native-onyx 2.0.81 → 2.0.83

package/dist/GlobalSettings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Stores settings from Onyx.init globally so they can be made accessible by other parts of the library.
+ */
+declare const globalSettings: {
+    enablePerformanceMetrics: boolean;
+};
+type GlobalSettings = typeof globalSettings;
+declare function addGlobalSettingsChangeListener(listener: (settings: GlobalSettings) => unknown): () => void;
+declare function setPerformanceMetricsEnabled(enabled: boolean): void;
+declare function isPerformanceMetricsEnabled(): boolean;
+export { setPerformanceMetricsEnabled, isPerformanceMetricsEnabled, addGlobalSettingsChangeListener };

package/dist/GlobalSettings.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Stores settings from Onyx.init globally so they can be made accessible by other parts of the library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addGlobalSettingsChangeListener = exports.isPerformanceMetricsEnabled = exports.setPerformanceMetricsEnabled = void 0;
+const globalSettings = {
+    enablePerformanceMetrics: false,
+};
+const listeners = new Set();
+function addGlobalSettingsChangeListener(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+exports.addGlobalSettingsChangeListener = addGlobalSettingsChangeListener;
+function notifyListeners() {
+    listeners.forEach((listener) => listener(globalSettings));
+}
+function setPerformanceMetricsEnabled(enabled) {
+    globalSettings.enablePerformanceMetrics = enabled;
+    notifyListeners();
+}
+exports.setPerformanceMetricsEnabled = setPerformanceMetricsEnabled;
+function isPerformanceMetricsEnabled() {
+    return globalSettings.enablePerformanceMetrics;
+}
+exports.isPerformanceMetricsEnabled = isPerformanceMetricsEnabled;

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  *
@@ -134,7 +134,7 @@ declare function update(data: OnyxUpdate[]): Promise<void>;
  */
 declare function setCollection<TKey extends CollectionKeyBase, TMap extends string>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TMap>): Promise<void>;
 declare const Onyx: {
-    readonly METHOD: {
+    METHOD: {
         readonly SET: "set";
         readonly MERGE: "merge";
         readonly MERGE_COLLECTION: "mergecollection";
@@ -142,17 +142,17 @@ declare const Onyx: {
         readonly MULTI_SET: "multiset";
         readonly CLEAR: "clear";
     };
-    readonly connect: typeof connect;
-    readonly disconnect: typeof disconnect;
-    readonly set: typeof set;
-    readonly multiSet: typeof multiSet;
-    readonly merge: typeof merge;
-    readonly mergeCollection: typeof mergeCollection;
-    readonly setCollection: typeof setCollection;
-    readonly update: typeof update;
-    readonly clear: typeof clear;
-    readonly init: typeof init;
-    readonly registerLogger: typeof Logger.registerLogger;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    set: typeof set;
+    multiSet: typeof multiSet;
+    merge: typeof merge;
+    mergeCollection: typeof mergeCollection;
+    setCollection: typeof setCollection;
+    update: typeof update;
+    clear: typeof clear;
+    init: typeof init;
+    registerLogger: typeof Logger.registerLogger;
 };
 export default Onyx;
 export type { OnyxUpdate, Mapping, ConnectOptions };

package/dist/Onyx.js

@@ -38,9 +38,15 @@ const DevTools_1 = __importDefault(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const logMessages_1 = __importDefault(require("./logMessages"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
+const GlobalSettings = __importStar(require("./GlobalSettings"));
+const metrics_1 = __importDefault(require("./metrics"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, }) {
+function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, enablePerformanceMetrics = false, }) {
     var _a;
+    if (enablePerformanceMetrics) {
+        GlobalSettings.setPerformanceMetricsEnabled(true);
+        applyDecorators();
+    }
     storage_1.default.init();
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
@@ -515,7 +521,7 @@ function updateSnapshots(data) {
 function update(data) {
     // First, validate the Onyx object is in the format we expect
     data.forEach(({ onyxMethod, key, value }) => {
-        if (![OnyxUtils_1.default.METHOD.CLEAR, OnyxUtils_1.default.METHOD.SET, OnyxUtils_1.default.METHOD.MERGE, OnyxUtils_1.default.METHOD.MERGE_COLLECTION, OnyxUtils_1.default.METHOD.MULTI_SET].includes(onyxMethod)) {
+        if (!Object.values(OnyxUtils_1.default.METHOD).includes(onyxMethod)) {
             throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
         }
         if (onyxMethod === OnyxUtils_1.default.METHOD.MULTI_SET) {
@@ -552,18 +558,14 @@ function update(data) {
     const promises = [];
     let clearPromise = Promise.resolve();
     data.forEach(({ onyxMethod, key, value }) => {
-        switch (onyxMethod) {
-            case OnyxUtils_1.default.METHOD.SET:
-                enqueueSetOperation(key, value);
-                break;
-            case OnyxUtils_1.default.METHOD.MERGE:
-                enqueueMergeOperation(key, value);
-                break;
-            case OnyxUtils_1.default.METHOD.MERGE_COLLECTION: {
+        const handlers = {
+            [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
+            [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
+            [OnyxUtils_1.default.METHOD.MERGE_COLLECTION]: () => {
                 const collection = value;
                 if (!OnyxUtils_1.default.isValidNonEmptyCollectionForMerge(collection)) {
                     Logger.logInfo('mergeCollection enqueued within update() with invalid or empty value. Skipping this operation.');
-                    break;
+                    return;
                 }
                 // Confirm all the collection keys belong to the same parent
                 const collectionKeys = Object.keys(collection);
@@ -571,17 +573,14 @@ function update(data) {
                     const mergedCollection = collection;
                     collectionKeys.forEach((collectionKey) => enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]));
                 }
-                break;
-            }
-            case OnyxUtils_1.default.METHOD.MULTI_SET:
-                Object.entries(value).forEach(([entryKey, entryValue]) => enqueueSetOperation(entryKey, entryValue));
-                break;
-            case OnyxUtils_1.default.METHOD.CLEAR:
+            },
+            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
+            [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => Object.entries(v).forEach(([entryKey, entryValue]) => enqueueSetOperation(entryKey, entryValue)),
+            [OnyxUtils_1.default.METHOD.CLEAR]: () => {
                 clearPromise = clear();
-                break;
-            default:
-                break;
-        }
+            },
+        };
+        handlers[onyxMethod](key, value);
     });
     // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
     // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
@@ -679,4 +678,23 @@ const Onyx = {
     init,
     registerLogger: Logger.registerLogger,
 };
+function applyDecorators() {
+    // We are reassigning the functions directly so that internal function calls are also decorated
+    /* eslint-disable rulesdir/prefer-actions-set-data */
+    // @ts-expect-error Reassign
+    connect = (0, metrics_1.default)(connect, 'Onyx.connect');
+    // @ts-expect-error Reassign
+    set = (0, metrics_1.default)(set, 'Onyx.set');
+    // @ts-expect-error Reassign
+    multiSet = (0, metrics_1.default)(multiSet, 'Onyx.multiSet');
+    // @ts-expect-error Reassign
+    merge = (0, metrics_1.default)(merge, 'Onyx.merge');
+    // @ts-expect-error Reassign
+    mergeCollection = (0, metrics_1.default)(mergeCollection, 'Onyx.mergeCollection');
+    // @ts-expect-error Reassign
+    update = (0, metrics_1.default)(update, 'Onyx.update');
+    // @ts-expect-error Reassign
+    clear = (0, metrics_1.default)(clear, 'Onyx.clear');
+    /* eslint-enable rulesdir/prefer-actions-set-data */
+}
 exports.default = Onyx;

package/dist/OnyxUtils.d.ts

@@ -278,4 +278,5 @@ declare const OnyxUtils: {
     unsubscribeFromKey: typeof unsubscribeFromKey;
     getEvictionBlocklist: typeof getEvictionBlocklist;
 };
+export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -39,6 +39,8 @@ const batch_1 = __importDefault(require("./batch"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const createDeferredTask_1 = __importDefault(require("./createDeferredTask"));
+const GlobalSettings = __importStar(require("./GlobalSettings"));
+const metrics_1 = __importDefault(require("./metrics"));
 // Method constants
 const METHOD = {
     SET: 'set',
@@ -1161,4 +1163,48 @@ const OnyxUtils = {
     unsubscribeFromKey,
     getEvictionBlocklist,
 };
+GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
+    if (!enablePerformanceMetrics) {
+        return;
+    }
+    // We are reassigning the functions directly so that internal function calls are also decorated
+    // @ts-expect-error Reassign
+    initStoreValues = (0, metrics_1.default)(initStoreValues, 'OnyxUtils.initStoreValues');
+    // @ts-expect-error Reassign
+    maybeFlushBatchUpdates = (0, metrics_1.default)(maybeFlushBatchUpdates, 'OnyxUtils.maybeFlushBatchUpdates');
+    // @ts-expect-error Reassign
+    batchUpdates = (0, metrics_1.default)(batchUpdates, 'OnyxUtils.batchUpdates');
+    // @ts-expect-error Complex type signature
+    get = (0, metrics_1.default)(get, 'OnyxUtils.get');
+    // @ts-expect-error Reassign
+    getAllKeys = (0, metrics_1.default)(getAllKeys, 'OnyxUtils.getAllKeys');
+    // @ts-expect-error Reassign
+    getCollectionKeys = (0, metrics_1.default)(getCollectionKeys, 'OnyxUtils.getCollectionKeys');
+    // @ts-expect-error Reassign
+    addAllSafeEvictionKeysToRecentlyAccessedList = (0, metrics_1.default)(addAllSafeEvictionKeysToRecentlyAccessedList, 'OnyxUtils.addAllSafeEvictionKeysToRecentlyAccessedList');
+    // @ts-expect-error Reassign
+    keysChanged = (0, metrics_1.default)(keysChanged, 'OnyxUtils.keysChanged');
+    // @ts-expect-error Reassign
+    keyChanged = (0, metrics_1.default)(keyChanged, 'OnyxUtils.keyChanged');
+    // @ts-expect-error Reassign
+    sendDataToConnection = (0, metrics_1.default)(sendDataToConnection, 'OnyxUtils.sendDataToConnection');
+    // @ts-expect-error Reassign
+    scheduleSubscriberUpdate = (0, metrics_1.default)(scheduleSubscriberUpdate, 'OnyxUtils.scheduleSubscriberUpdate');
+    // @ts-expect-error Reassign
+    scheduleNotifyCollectionSubscribers = (0, metrics_1.default)(scheduleNotifyCollectionSubscribers, 'OnyxUtils.scheduleNotifyCollectionSubscribers');
+    // @ts-expect-error Reassign
+    remove = (0, metrics_1.default)(remove, 'OnyxUtils.remove');
+    // @ts-expect-error Reassign
+    reportStorageQuota = (0, metrics_1.default)(reportStorageQuota, 'OnyxUtils.reportStorageQuota');
+    // @ts-expect-error Complex type signature
+    evictStorageAndRetry = (0, metrics_1.default)(evictStorageAndRetry, 'OnyxUtils.evictStorageAndRetry');
+    // @ts-expect-error Reassign
+    broadcastUpdate = (0, metrics_1.default)(broadcastUpdate, 'OnyxUtils.broadcastUpdate');
+    // @ts-expect-error Reassign
+    initializeWithDefaultKeyStates = (0, metrics_1.default)(initializeWithDefaultKeyStates, 'OnyxUtils.initializeWithDefaultKeyStates');
+    // @ts-expect-error Complex type signature
+    multiGet = (0, metrics_1.default)(multiGet, 'OnyxUtils.multiGet');
+    // @ts-expect-error Reassign
+    subscribeToKey = (0, metrics_1.default)(subscribeToKey, 'OnyxUtils.subscribeToKey');
+});
 exports.default = OnyxUtils;

package/dist/dependencies/ModuleProxy.d.ts

@@ -0,0 +1,10 @@
+type ImportType = ReturnType<typeof require>;
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+declare const createModuleProxy: <TModule>(getModule: () => ImportType) => TModule;
+declare class OptionalDependencyNotInstalledError extends Error {
+    constructor(name: string);
+}
+export { createModuleProxy, OptionalDependencyNotInstalledError };

package/dist/dependencies/ModuleProxy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalDependencyNotInstalledError = exports.createModuleProxy = void 0;
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+const createModuleProxy = (getModule) => {
+    const holder = { module: undefined };
+    const proxy = new Proxy(holder, {
+        get: (target, property) => {
+            if (property === '$$typeof') {
+                // If inlineRequires is enabled, Metro will look up all imports
+                // with the $$typeof operator. In this case, this will throw the
+                // `OptionalDependencyNotInstalledError` error because we try to access the module
+                // even though we are not using it (Metro does it), so instead we return undefined
+                // to bail out of inlineRequires here.
+                return undefined;
+            }
+            if (target.module == null) {
+                // lazy initialize module via require()
+                // caller needs to make sure the require() call is wrapped in a try/catch
+                // eslint-disable-next-line no-param-reassign
+                target.module = getModule();
+            }
+            return target.module[property];
+        },
+    });
+    return proxy;
+};
+exports.createModuleProxy = createModuleProxy;
+class OptionalDependencyNotInstalledError extends Error {
+    constructor(name) {
+        super(`${name} is not installed!`);
+    }
+}
+exports.OptionalDependencyNotInstalledError = OptionalDependencyNotInstalledError;

package/dist/dependencies/PerformanceProxy/index.d.ts

@@ -0,0 +1 @@
+export default performance;

package/dist/dependencies/PerformanceProxy/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Use the existing performance API on web
+exports.default = performance;

package/dist/dependencies/PerformanceProxy/index.native.d.ts

@@ -0,0 +1,20 @@
+declare const PerformanceProxy: {
+    timeOrigin: number;
+    now: () => number;
+    mark: (markName: string, markOptions?: import("react-native-performance/lib/typescript/performance").MarkOptions | undefined) => import("react-native-performance").PerformanceMark;
+    clearMarks: (name?: string | undefined) => void;
+    measure: (measureName: string, startOrMeasureOptions?: import("react-native-performance/lib/typescript/performance").StartOrMeasureOptions, endMark?: string | number | undefined) => import("react-native-performance").PerformanceMeasure;
+    clearMeasures: (name?: string | undefined) => void;
+    metric: (name: string, valueOrOptions: import("react-native-performance/lib/typescript/performance").ValueOrOptions) => import("react-native-performance").PerformanceMetric;
+    clearMetrics: (name?: string | undefined) => void;
+    getEntries: () => import("react-native-performance").PerformanceEntry[];
+    getEntriesByName: (name: string, type?: import("react-native-performance").EntryType | undefined) => import("react-native-performance").PerformanceEntry[];
+    getEntriesByType: {
+        (type: "measure"): import("react-native-performance").PerformanceMeasure[];
+        (type: "mark"): import("react-native-performance").PerformanceMark[];
+        (type: "resource"): import("react-native-performance").PerformanceResourceTiming[];
+        (type: "metric"): import("react-native-performance").PerformanceMetric[];
+        (type: "react-native-mark"): import("react-native-performance").PerformanceReactNativeMark[];
+    };
+};
+export default PerformanceProxy;

package/dist/dependencies/PerformanceProxy/index.native.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleProxy_1 = require("../ModuleProxy");
+const PerformanceProxy = (0, ModuleProxy_1.createModuleProxy)(() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('react-native-performance').default;
+    }
+    catch (_a) {
+        throw new ModuleProxy_1.OptionalDependencyNotInstalledError('react-native-performance');
+    }
+});
+exports.default = PerformanceProxy;

package/dist/metrics.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a function with metrics capturing logic
+ */
+declare function decorateWithMetrics<Args extends unknown[], ReturnType>(func: (...args: Args) => ReturnType, alias?: string): {
+    (...args: Args): ReturnType;
+    name: string;
+};
+export default decorateWithMetrics;

package/dist/metrics.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PerformanceProxy_1 = __importDefault(require("./dependencies/PerformanceProxy"));
+const decoratedAliases = new Set();
+/**
+ * Capture a measurement between the start mark and now
+ */
+function measureMarkToNow(startMark, detail) {
+    PerformanceProxy_1.default.measure(`${startMark.name} [${startMark.detail.args.toString()}]`, {
+        start: startMark.startTime,
+        end: PerformanceProxy_1.default.now(),
+        detail: Object.assign(Object.assign({}, startMark.detail), detail),
+    });
+}
+function isPromiseLike(value) {
+    return value != null && typeof value === 'object' && 'then' in value;
+}
+/**
+ * Wraps a function with metrics capturing logic
+ */
+function decorateWithMetrics(func, alias = func.name) {
+    if (decoratedAliases.has(alias)) {
+        throw new Error(`"${alias}" is already decorated`);
+    }
+    decoratedAliases.add(alias);
+    function decorated(...args) {
+        const mark = PerformanceProxy_1.default.mark(alias, { detail: { args, alias } });
+        const originalReturnValue = func(...args);
+        if (isPromiseLike(originalReturnValue)) {
+            /*
+             * The handlers added here are not affecting the original promise
+             * They create a separate chain that's not exposed (returned) to the original caller
+             */
+            originalReturnValue
+                .then((result) => {
+                measureMarkToNow(mark, { result });
+            })
+                .catch((error) => {
+                measureMarkToNow(mark, { error });
+            });
+            return originalReturnValue;
+        }
+        measureMarkToNow(mark, { result: originalReturnValue });
+        return originalReturnValue;
+    }
+    decorated.name = `${alias}_DECORATED`;
+    return decorated;
+}
+exports.default = decorateWithMetrics;

package/dist/storage/index.d.ts

@@ -2,5 +2,5 @@ import type StorageProvider from './providers/types';
 type Storage = {
     getStorageProvider: () => StorageProvider;
 } & Omit<StorageProvider, 'name'>;
-declare const Storage: Storage;
-export default Storage;
+declare const storage: Storage;
+export default storage;

package/dist/storage/index.js

@@ -30,6 +30,8 @@ const Logger = __importStar(require("../Logger"));
 const platforms_1 = __importDefault(require("./platforms"));
 const InstanceSync_1 = __importDefault(require("./InstanceSync"));
 const MemoryOnlyProvider_1 = __importDefault(require("./providers/MemoryOnlyProvider"));
+const GlobalSettings = __importStar(require("../GlobalSettings"));
+const metrics_1 = __importDefault(require("../metrics"));
 let provider = platforms_1.default;
 let shouldKeepInstancesSync = false;
 let finishInitalization;
@@ -71,7 +73,7 @@ function tryOrDegradePerformance(fn, waitForInitialization = true) {
         });
     });
 }
-const Storage = {
+const storage = {
     /**
      * Returns the storage provider currently in use
      */
@@ -184,4 +186,20 @@ const Storage = {
         InstanceSync_1.default.init(onStorageKeyChanged, this);
     },
 };
-exports.default = Storage;
+GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
+    if (!enablePerformanceMetrics) {
+        return;
+    }
+    // Apply decorators
+    storage.getItem = (0, metrics_1.default)(storage.getItem, 'Storage.getItem');
+    storage.multiGet = (0, metrics_1.default)(storage.multiGet, 'Storage.multiGet');
+    storage.setItem = (0, metrics_1.default)(storage.setItem, 'Storage.setItem');
+    storage.multiSet = (0, metrics_1.default)(storage.multiSet, 'Storage.multiSet');
+    storage.mergeItem = (0, metrics_1.default)(storage.mergeItem, 'Storage.mergeItem');
+    storage.multiMerge = (0, metrics_1.default)(storage.multiMerge, 'Storage.multiMerge');
+    storage.removeItem = (0, metrics_1.default)(storage.removeItem, 'Storage.removeItem');
+    storage.removeItems = (0, metrics_1.default)(storage.removeItems, 'Storage.removeItems');
+    storage.clear = (0, metrics_1.default)(storage.clear, 'Storage.clear');
+    storage.getAllKeys = (0, metrics_1.default)(storage.getAllKeys, 'Storage.getAllKeys');
+});
+exports.default = storage;

package/dist/types.d.ts

@@ -2,6 +2,7 @@ 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';
 /**
  * Utility type that excludes `null` from the type `TValue`.
  */
@@ -329,35 +330,43 @@ type OnyxMergeInput<TKey extends OnyxKey> = OnyxInput<TKey>;
  * This represents the value that can be passed to `Onyx.merge` and to `Onyx.update` with the method "MERGE"
  */
 type OnyxMergeCollectionInput<TKey extends OnyxKey, TMap = object> = Collection<TKey, NonNullable<OnyxInput<TKey>>, TMap>;
-/**
- * Represents different kinds of updates that can be passed to `Onyx.update()` method. It is a discriminated union of
- * different update methods (`SET`, `MERGE`, `MERGE_COLLECTION`), each with their own key and value structure.
- */
-type OnyxUpdate = {
-    [TKey in OnyxKey]: {
-        onyxMethod: typeof OnyxUtils.METHOD.SET;
-        key: TKey;
-        value: OnyxSetInput<TKey>;
-    } | {
-        onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
-        key: TKey;
+type OnyxMethodMap = typeof OnyxUtils.METHOD;
+type OnyxMethodValueMap = {
+    [OnyxUtils.METHOD.SET]: {
+        key: OnyxKey;
+        value: OnyxSetInput<OnyxKey>;
+    };
+    [OnyxUtils.METHOD.MULTI_SET]: {
+        key: OnyxKey;
         value: OnyxMultiSetInput;
-    } | {
-        onyxMethod: typeof OnyxUtils.METHOD.MERGE;
-        key: TKey;
-        value: OnyxMergeInput<TKey>;
-    } | {
-        onyxMethod: typeof OnyxUtils.METHOD.CLEAR;
-        key: TKey;
+    };
+    [OnyxUtils.METHOD.MERGE]: {
+        key: OnyxKey;
+        value: OnyxMergeInput<OnyxKey>;
+    };
+    [OnyxUtils.METHOD.CLEAR]: {
+        key: OnyxKey;
         value?: undefined;
     };
-}[OnyxKey] | {
-    [TKey in CollectionKeyBase]: {
-        onyxMethod: typeof OnyxUtils.METHOD.MERGE_COLLECTION;
-        key: TKey;
-        value: OnyxMergeCollectionInput<TKey>;
+    [OnyxUtils.METHOD.MERGE_COLLECTION]: {
+        key: CollectionKeyBase;
+        value: OnyxMergeCollectionInput<CollectionKeyBase>;
+    };
+    [OnyxUtils.METHOD.SET_COLLECTION]: {
+        key: CollectionKeyBase;
+        value: OnyxMergeCollectionInput<CollectionKeyBase>;
     };
-}[CollectionKeyBase];
+};
+/**
+ * OnyxUpdate type includes all onyx methods used in OnyxMethodValueMap.
+ * If a new method is added to OnyxUtils.METHOD constant, it must be added to OnyxMethodValueMap type.
+ * Otherwise it will show static type errors.
+ */
+type OnyxUpdate = {
+    [Method in OnyxMethod]: {
+        onyxMethod: Method;
+    } & OnyxMethodValueMap[Method];
+}[OnyxMethod];
 /**
  * Represents the options used in `Onyx.init()` method.
  */
@@ -384,6 +393,11 @@ type InitOptions = {
     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
+     */
+    enablePerformanceMetrics?: boolean;
 };
 type GenericFunction = (...args: any[]) => any;
 /**
@@ -393,4 +407,4 @@ type MixedOperationsQueue = {
     merge: OnyxInputKeyValueMapping;
     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, OnyxUpdate, OnyxValue, Selector, WithOnyxConnectOptions, MixedOperationsQueue, };
+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, WithOnyxConnectOptions, MixedOperationsQueue, };

package/lib/index.ts

@@ -0,0 +1,51 @@
+import type {ConnectOptions, OnyxUpdate} from './Onyx';
+import Onyx from './Onyx';
+import type {
+    CustomTypeOptions,
+    KeyValueMapping,
+    NullishDeep,
+    OnyxCollection,
+    OnyxEntry,
+    OnyxKey,
+    OnyxValue,
+    Selector,
+    OnyxInputValue,
+    OnyxCollectionInputValue,
+    OnyxInput,
+    OnyxSetInput,
+    OnyxMultiSetInput,
+    OnyxMergeInput,
+    OnyxMergeCollectionInput,
+} from './types';
+import type {FetchStatus, ResultMetadata, UseOnyxResult} from './useOnyx';
+import type {Connection} from './OnyxConnectionManager';
+import useOnyx from './useOnyx';
+import withOnyx from './withOnyx';
+import type {WithOnyxState} from './withOnyx/types';
+
+export default Onyx;
+export {useOnyx, withOnyx};
+export type {
+    ConnectOptions,
+    CustomTypeOptions,
+    FetchStatus,
+    KeyValueMapping,
+    NullishDeep,
+    OnyxCollection,
+    OnyxEntry,
+    OnyxKey,
+    OnyxInputValue,
+    OnyxCollectionInputValue,
+    OnyxInput,
+    OnyxSetInput,
+    OnyxMultiSetInput,
+    OnyxMergeInput,
+    OnyxMergeCollectionInput,
+    OnyxUpdate,
+    OnyxValue,
+    ResultMetadata,
+    Selector,
+    UseOnyxResult,
+    WithOnyxState,
+    Connection,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.81",
+  "version": "2.0.83",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -25,8 +25,7 @@
     "README.md",
     "LICENSE.md"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "lib/index.ts",
   "scripts": {
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",