react-native-onyx 2.0.21 → 2.0.23

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMockStore = exports.mockSet = exports.mockStore = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+const utils_1 = __importDefault(require("../../utils"));
+// eslint-disable-next-line import/no-mutable-exports
+let store = {};
+exports.mockStore = store;
+const setInternal = (key, value) => {
+    store[key] = value;
+    return Promise.resolve(value);
+};
+const isJestRunning = typeof jest !== 'undefined';
+const set = isJestRunning ? jest.fn(setInternal) : setInternal;
+exports.mockSet = set;
+const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'MemoryOnlyProvider',
+    /**
+     * Initializes the storage provider
+     */
+    init() {
+        // do nothing
+    },
+    /**
+     * Get the value of a given key or return `null` if it's not available in memory
+     */
+    getItem(key) {
+        const value = store[key];
+        return Promise.resolve(value === undefined ? null : value);
+    },
+    /**
+     * Get multiple key-value pairs for the give array of keys in a batch.
+     */
+    multiGet(keys) {
+        const getPromises = underscore_1.default.map(keys, (key) => new Promise((resolve) => {
+            this.getItem(key).then((value) => resolve([key, value]));
+        }));
+        return Promise.all(getPromises);
+    },
+    /**
+     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
+     */
+    setItem(key, value) {
+        set(key, value);
+        return Promise.resolve();
+    },
+    /**
+     * Stores multiple key-value pairs in a batch
+     */
+    multiSet(pairs) {
+        const setPromises = underscore_1.default.map(pairs, ([key, value]) => this.setItem(key, value));
+        return new Promise((resolve) => {
+            Promise.all(setPromises).then(() => {
+                resolve(undefined);
+            });
+        });
+    },
+    /**
+     * Merging an existing value with a new one
+     */
+    mergeItem(key, _changes, modifiedData) {
+        // Since Onyx already merged the existing value with the changes, we can just set the value directly
+        return this.setItem(key, modifiedData);
+    },
+    /**
+     * Multiple merging of existing and new values in a batch
+     * This function also removes all nested null values from an object.
+     */
+    multiMerge(pairs) {
+        underscore_1.default.forEach(pairs, ([key, value]) => {
+            const existingValue = store[key];
+            const newValue = utils_1.default.fastMerge(existingValue, value);
+            set(key, newValue);
+        });
+        return Promise.resolve([]);
+    },
+    /**
+     * Remove given key and it's value from memory
+     */
+    removeItem(key) {
+        delete store[key];
+        return Promise.resolve();
+    },
+    /**
+     * Remove given keys and their values from memory
+     */
+    removeItems(keys) {
+        underscore_1.default.each(keys, (key) => {
+            delete store[key];
+        });
+        return Promise.resolve();
+    },
+    /**
+     * Clear everything from memory
+     */
+    clear() {
+        exports.mockStore = store = {};
+        return Promise.resolve();
+    },
+    /**
+     * Returns all keys available in memory
+     */
+    getAllKeys() {
+        return Promise.resolve(underscore_1.default.keys(store));
+    },
+    /**
+     * Gets the total bytes of the store.
+     * `bytesRemaining` will always be `Number.POSITIVE_INFINITY` since we don't have a hard limit on memory.
+     */
+    getDatabaseSize() {
+        return Promise.resolve({ bytesRemaining: Number.POSITIVE_INFINITY, bytesUsed: 0 });
+    },
+};
+const setMockStore = (data) => {
+    exports.mockStore = store = data;
+};
+exports.setMockStore = setMockStore;
+exports.default = provider;

package/dist/storage/providers/NoopProvider.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'NoopProvider',
+    /**
+     * Initializes the storage provider
+     */
+    init() {
+        // do nothing
+    },
+    /**
+     * Get the value of a given key or return `null` if it's not available in memory
+     * @param {String} key
+     * @return {Promise<*>}
+     */
+    getItem() {
+        return Promise.resolve(null);
+    },
+    /**
+     * Get multiple key-value pairs for the give array of keys in a batch.
+     */
+    multiGet() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
+     */
+    setItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Stores multiple key-value pairs in a batch
+     */
+    multiSet() {
+        return Promise.resolve();
+    },
+    /**
+     * Merging an existing value with a new one
+     */
+    mergeItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Multiple merging of existing and new values in a batch
+     * This function also removes all nested null values from an object.
+     */
+    multiMerge() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Remove given key and it's value from memory
+     */
+    removeItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Remove given keys and their values from memory
+     */
+    removeItems() {
+        return Promise.resolve();
+    },
+    /**
+     * Clear everything from memory
+     */
+    clear() {
+        return Promise.resolve();
+    },
+    /**
+     * Returns all keys available in memory
+     */
+    getAllKeys() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Gets the total bytes of the store.
+     * `bytesRemaining` will always be `Number.POSITIVE_INFINITY` since we don't have a hard limit on memory.
+     */
+    getDatabaseSize() {
+        return Promise.resolve({ bytesRemaining: Number.POSITIVE_INFINITY, bytesUsed: 0 });
+    },
+};
+exports.default = provider;

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

@@ -0,0 +1,3 @@
+import type StorageProvider from './types';
+declare const provider: StorageProvider;
+export default provider;

package/dist/storage/providers/{SQLiteStorage.js → SQLiteProvider.js}

@@ -7,14 +7,24 @@ const react_native_quick_sqlite_1 = require("react-native-quick-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
 const utils_1 = __importDefault(require("../../utils"));
 const DB_NAME = 'OnyxDB';
-const db = (0, react_native_quick_sqlite_1.open)({ name: DB_NAME });
-db.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
-// All of the 3 pragmas below were suggested by SQLite team.
-// You can find more info about them here: https://www.sqlite.org/pragma.html
-db.execute('PRAGMA CACHE_SIZE=-20000;');
-db.execute('PRAGMA synchronous=NORMAL;');
-db.execute('PRAGMA journal_mode=WAL;');
+let db;
 const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'SQLiteProvider',
+    /**
+     * Initializes the storage provider
+     */
+    init() {
+        db = (0, react_native_quick_sqlite_1.open)({ name: DB_NAME });
+        db.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
+        // All of the 3 pragmas below were suggested by SQLite team.
+        // You can find more info about them here: https://www.sqlite.org/pragma.html
+        db.execute('PRAGMA CACHE_SIZE=-20000;');
+        db.execute('PRAGMA synchronous=NORMAL;');
+        db.execute('PRAGMA journal_mode=WAL;');
+    },
     getItem(key) {
         return db.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
             if (!rows || (rows === null || rows === void 0 ? void 0 : rows.length) === 0) {
@@ -84,9 +94,5 @@ const provider = {
             };
         });
     },
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setMemoryOnlyKeys: () => { },
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    keepInstancesSync: () => { },
 };
 exports.default = provider;

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

@@ -1,15 +1,22 @@
 import type { BatchQueryResult, QueryResult } from 'react-native-quick-sqlite';
-type Key = string;
-type Value = IDBValidKey;
-type KeyValuePair = [Key, Value];
-type KeyList = Key[];
+import type { OnyxKey, OnyxValue } from '../../types';
+type KeyValuePair = [OnyxKey, OnyxValue<OnyxKey>];
+type KeyList = OnyxKey[];
 type KeyValuePairList = KeyValuePair[];
-type OnStorageKeyChanged = (key: Key, value: Value | null) => void;
+type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey> | null) => void;
 type StorageProvider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: string;
+    /**
+     * Initializes the storage provider
+     */
+    init: () => void;
     /**
      * Gets the value of a given key or return `null` if it's not available in storage
      */
-    getItem: (key: Key) => Promise<Value | null>;
+    getItem: <TKey extends OnyxKey>(key: TKey) => Promise<OnyxValue<TKey> | null>;
     /**
      * Get multiple key-value pairs for the given array of keys in a batch
      */
@@ -17,7 +24,7 @@ type StorageProvider = {
     /**
      * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
      */
-    setItem: (key: Key, value: Value) => Promise<QueryResult | void>;
+    setItem: <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => Promise<QueryResult | void>;
     /**
      * Stores multiple key-value pairs in a batch
      */
@@ -31,7 +38,7 @@ type StorageProvider = {
      * @param changes - the delta for a specific key
      * @param modifiedData - the pre-merged data from `Onyx.applyMerge`
      */
-    mergeItem: (key: Key, changes: Value, modifiedData: Value) => Promise<BatchQueryResult | void>;
+    mergeItem: <TKey extends OnyxKey>(key: TKey, changes: OnyxValue<TKey>, modifiedData: OnyxValue<TKey>) => Promise<BatchQueryResult | void>;
     /**
      * Returns all keys available in storage
      */
@@ -39,7 +46,7 @@ type StorageProvider = {
     /**
      * Removes given key and its value from storage
      */
-    removeItem: (key: Key) => Promise<QueryResult | void>;
+    removeItem: (key: OnyxKey) => Promise<QueryResult | void>;
     /**
      * Removes given keys and their values from storage
      */
@@ -48,10 +55,6 @@ type StorageProvider = {
      * Clears absolutely everything from storage
      */
     clear: () => Promise<QueryResult | void>;
-    /**
-     * Sets memory only keys
-     */
-    setMemoryOnlyKeys: () => void;
     /**
      * Gets the total bytes of the database file
      */
@@ -65,4 +68,4 @@ type StorageProvider = {
     keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
 };
 export default StorageProvider;
-export type { Value, Key, KeyList, KeyValuePairList };
+export type { KeyList, KeyValuePair, KeyValuePairList, OnStorageKeyChanged };

package/dist/types.d.ts

@@ -1,6 +1,7 @@
-import {Merge} from 'type-fest';
-import {BuiltIns} from 'type-fest/source/internal';
-
+import type { Component } from 'react';
+import type { Merge } from 'type-fest';
+import type { BuiltIns } from 'type-fest/source/internal';
+import type OnyxUtils from './OnyxUtils';
 /**
  * Represents a deeply nested record. It maps keys to values,
  * and those values can either be of type `TValue` or further nested `DeepRecord` instances.
@@ -8,7 +9,6 @@ import {BuiltIns} from 'type-fest/source/internal';
 type DeepRecord<TKey extends string | number | symbol, TValue> = {
     [key: string]: TValue | DeepRecord<TKey, TValue>;
 };
-
 /**
  * Represents type options to configure all Onyx methods.
  * It's a combination of predefined options with user-provided options (CustomTypeOptions).
@@ -21,15 +21,11 @@ type DeepRecord<TKey extends string | number | symbol, TValue> = {
  * The user-defined options (CustomTypeOptions) are merged into these predefined options.
  * In case of conflicting properties, the ones from CustomTypeOptions are prioritized.
  */
-type TypeOptions = Merge<
-    {
-        keys: string;
-        collectionKeys: string;
-        values: Record<string, unknown>;
-    },
-    CustomTypeOptions
->;
-
+type TypeOptions = Merge<{
+    keys: string;
+    collectionKeys: string;
+    values: Record<string, unknown>;
+}, CustomTypeOptions>;
 /**
  * Represents the user-defined options to configure all Onyx methods.
  *
@@ -76,34 +72,29 @@ type TypeOptions = Merge<
  * }
  * ```
  */
-interface CustomTypeOptions {}
-
+interface CustomTypeOptions {
+}
 /**
  * Represents a string union of all Onyx normal keys.
  */
 type Key = TypeOptions['keys'];
-
 /**
  * Represents a string union of all Onyx collection keys.
  */
 type CollectionKeyBase = TypeOptions['collectionKeys'];
-
 /**
  * Represents a literal string union of all Onyx collection keys.
  * It allows appending a string after each collection key e.g. `report_some-id`.
  */
 type CollectionKey = `${CollectionKeyBase}${string}`;
-
 /**
  * Represents a string union of all Onyx normal and collection keys.
  */
 type OnyxKey = Key | CollectionKey;
-
 /**
  * Represents a Onyx value that can be either a single entry or a collection of entries, depending on the `TKey` provided.
  */
-type OnyxValue<TKey extends OnyxKey> = TKey extends CollectionKeyBase ? OnyxCollection<KeyValueMapping[TKey]> : OnyxEntry<KeyValueMapping[TKey]>;
-
+type OnyxValue<TKey extends OnyxKey> = string extends TKey ? unknown : TKey extends CollectionKeyBase ? OnyxCollection<KeyValueMapping[TKey]> : OnyxEntry<KeyValueMapping[TKey]>;
 /**
  * Represents a mapping of Onyx keys to values, where keys are either normal or collection Onyx keys
  * and values are the corresponding values in Onyx's state.
@@ -116,7 +107,14 @@ type OnyxValue<TKey extends OnyxKey> = TKey extends CollectionKeyBase ? OnyxColl
 type KeyValueMapping = {
     [TKey in keyof TypeOptions['values'] as TKey extends CollectionKeyBase ? `${TKey}${string}` : TKey]: TypeOptions['values'][TKey];
 };
-
+/**
+ * Represents a mapping object where each `OnyxKey` maps to either a value of its corresponding type in `KeyValueMapping` or `null`.
+ *
+ * It's very similar to `KeyValueMapping` but this type accepts using `null` as well.
+ */
+type NullableKeyValueMapping = {
+    [TKey in OnyxKey]: OnyxValue<TKey>;
+};
 /**
  * Represents a selector function type which operates based on the provided `TKey` and `ReturnType`.
  *
@@ -127,7 +125,6 @@ type 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: WithOnyxInstanceState<TOnyxProps>) => TReturnType;
-
 /**
  * Represents a single Onyx entry, that can be either `TOnyxValue` or `null` if it doesn't exist.
  *
@@ -157,7 +154,6 @@ type Selector<TKey extends OnyxKey, TOnyxProps, TReturnType> = (value: OnyxEntry
  * ```
  */
 type OnyxEntry<TOnyxValue> = TOnyxValue | null;
-
 /**
  * Represents an Onyx collection of entries, that can be either a record of `TOnyxValue`s or `null` if it is empty or doesn't exist.
  *
@@ -187,20 +183,9 @@ type OnyxEntry<TOnyxValue> = TOnyxValue | null;
  * ```
  */
 type OnyxCollection<TOnyxValue> = OnyxEntry<Record<string, TOnyxValue | null>>;
-
 /** Utility type to extract `TOnyxValue` from `OnyxCollection<TOnyxValue>` */
 type ExtractOnyxCollectionValue<TOnyxCollection> = TOnyxCollection extends NonNullable<OnyxCollection<infer U>> ? U : never;
-
-type NonTransformableTypes =
-    | BuiltIns
-    | ((...args: any[]) => unknown)
-    | Map<unknown, unknown>
-    | Set<unknown>
-    | ReadonlyMap<unknown, unknown>
-    | ReadonlySet<unknown>
-    | unknown[]
-    | readonly unknown[];
-
+type NonTransformableTypes = BuiltIns | ((...args: any[]) => unknown) | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | unknown[] | readonly unknown[];
 /**
  * Create a type from another type with all keys and nested keys set to optional or null.
  *
@@ -221,32 +206,120 @@ type NonTransformableTypes =
  * settings = applySavedSettings({textEditor: {fontWeight: 500, fontColor: null}});
  */
 type NullishDeep<T> = T extends NonTransformableTypes ? T : T extends object ? NullishObjectDeep<T> : unknown;
-
 /**
  * Same as `NullishDeep`, but accepts only `object`s as inputs. Internal helper for `NullishDeep`.
  */
 type NullishObjectDeep<ObjectType extends object> = {
     [KeyType in keyof ObjectType]?: NullishDeep<ObjectType[KeyType]> | null;
 };
-
 /**
  * Represents withOnyx's internal state, containing the Onyx props and a `loading` flag.
  */
-type WithOnyxInstanceState<TOnyxProps> = (TOnyxProps & {loading: boolean}) | undefined;
-
-export {
-    CollectionKey,
-    CollectionKeyBase,
-    CustomTypeOptions,
-    DeepRecord,
-    Key,
-    KeyValueMapping,
-    OnyxCollection,
-    OnyxEntry,
-    OnyxKey,
-    OnyxValue,
-    Selector,
-    NullishDeep,
-    WithOnyxInstanceState,
-    ExtractOnyxCollectionValue,
+type WithOnyxInstanceState<TOnyxProps> = (TOnyxProps & {
+    loading: boolean;
+}) | undefined;
+/**
+ * Represents a mapping between Onyx collection keys and their respective values.
+ *
+ * It helps to enforce that a Onyx collection key should not be without suffix (e.g. should always be of the form `${TKey}${string}`),
+ * and to map each Onyx collection key with suffix to a value of type `TValue`.
+ *
+ * Also, the `TMap` type is inferred automatically in `mergeCollection()` method and represents
+ * the object of collection keys/values specified in the second parameter of the method.
+ */
+type Collection<TKey extends CollectionKeyBase, TMap, TValue> = {
+    [MapK in keyof TMap]: MapK extends `${TKey}${string}` ? MapK extends `${TKey}` ? never : TValue : never;
+};
+type WithOnyxInstance = Component<unknown, WithOnyxInstanceState<NullableKeyValueMapping>> & {
+    setStateProxy: (cb: (state: NullableKeyValueMapping) => OnyxValue<OnyxKey>) => void;
+    setWithOnyxState: (statePropertyName: OnyxKey, value: OnyxValue<OnyxKey>) => void;
+};
+/** Represents the base options used in `Onyx.connect()` method. */
+type BaseConnectOptions = {
+    statePropertyName?: string;
+    withOnyxInstance?: Component;
+    initWithStoredValues?: boolean;
+};
+/**
+ * Represents the options used in `Onyx.connect()` method.
+ * The type is built from `BaseConnectOptions` and extended to handle key/callback related options.
+ * It includes two different forms, depending on whether we are waiting for a collection callback or not.
+ *
+ * If `waitForCollectionCallback` is `true`, it expects `key` to be a Onyx collection key and `callback` will be triggered with the whole collection
+ * and will pass `value` as an `OnyxCollection`.
+ *
+ *
+ * If `waitForCollectionCallback` is `false` or not specified, the `key` can be any Onyx key and `callback` will be triggered with updates of each collection item
+ * and will pass `value` as an `OnyxEntry`.
+ */
+type ConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & ({
+    key: TKey extends CollectionKeyBase ? TKey : never;
+    callback?: (value: OnyxCollection<KeyValueMapping[TKey]>) => void;
+    waitForCollectionCallback: true;
+} | {
+    key: TKey;
+    callback?: (value: OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;
+    waitForCollectionCallback?: false;
+});
+type Mapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
+    connectionID: number;
+    statePropertyName: string;
+    displayName: string;
+};
+/**
+ * Represents different kinds of updates that can be passed to `Onyx.update()` method. It is a discriminated union of
+ * 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: OnyxEntry<KeyValueMapping[TKey]>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.MERGE;
+        key: TKey;
+        value: OnyxEntry<NullishDeep<KeyValueMapping[TKey]>>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
+        key: TKey;
+        value: Partial<NullableKeyValueMapping>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.CLEAR;
+        key: TKey;
+        value?: undefined;
+    };
+}[OnyxKey] | {
+    [TKey in CollectionKeyBase]: {
+        onyxMethod: typeof OnyxUtils.METHOD.MERGE_COLLECTION;
+        key: TKey;
+        value: Record<`${TKey}${string}`, NullishDeep<KeyValueMapping[TKey]>>;
+    };
+}[CollectionKeyBase];
+/**
+ * Represents the options used in `Onyx.init()` method.
+ */
+type InitOptions = {
+    /** `ONYXKEYS` constants object */
+    keys?: DeepRecord<string, OnyxKey>;
+    /** initial data to set when `init()` and `clear()` is called */
+    initialKeyStates?: Partial<NullableKeyValueMapping>;
+    /**
+     * This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged
+     * as "safe" for removal. Any components subscribing to these keys must also implement a canEvict option. See the README for more info.
+     */
+    safeEvictionKeys?: OnyxKey[];
+    /**
+     * Sets how many recent keys should we try to keep in cache
+     * Setting this to 0 would practically mean no cache
+     * We try to free cache when we connect to a safe eviction key
+     */
+    maxCachedKeysCount?: number;
+    /**
+     * Auto synchronize storage events between multiple instances
+     * 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;
 };
+export type { CollectionKey, CollectionKeyBase, CustomTypeOptions, DeepRecord, Key, KeyValueMapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, NullishDeep, WithOnyxInstanceState, ExtractOnyxCollectionValue, Collection, WithOnyxInstance, BaseConnectOptions, ConnectOptions, Mapping, OnyxUpdate, InitOptions, };

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/useOnyx.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fast_equals_1 = require("fast-equals");
 const react_1 = require("react");
-const Onyx_1 = __importDefault(require("./Onyx"));
+const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 const usePrevious_1 = __importDefault(require("./usePrevious"));
+const Onyx_1 = __importDefault(require("./Onyx"));
 function getCachedValue(key, selector) {
-    return Onyx_1.default.tryGetCachedValue(key, { selector });
+    return OnyxUtils_1.default.tryGetCachedValue(key, { selector });
 }
 function useOnyx(key, options) {
     const connectionIDRef = (0, react_1.useRef)(null);
@@ -37,9 +38,9 @@ function useOnyx(key, options) {
             return;
         }
         try {
-            const previousCollectionKey = Onyx_1.default.splitCollectionMemberKey(previousKey)[0];
-            const collectionKey = Onyx_1.default.splitCollectionMemberKey(key)[0];
-            if (Onyx_1.default.isCollectionMemberKey(previousCollectionKey, previousKey) && Onyx_1.default.isCollectionMemberKey(collectionKey, key) && previousCollectionKey === collectionKey) {
+            const previousCollectionKey = OnyxUtils_1.default.splitCollectionMemberKey(previousKey)[0];
+            const collectionKey = OnyxUtils_1.default.splitCollectionMemberKey(key)[0];
+            if (OnyxUtils_1.default.isCollectionMemberKey(previousCollectionKey, previousKey) && OnyxUtils_1.default.isCollectionMemberKey(collectionKey, key) && previousCollectionKey === collectionKey) {
                 return;
             }
         }
@@ -61,7 +62,7 @@ function useOnyx(key, options) {
         // If we have pending merge operations for the key during the first connection, we set the new value to `undefined`
         // and fetch status to `loading` to simulate that it is still being loaded until we have the most updated data.
         // If `allowStaleData` is `true` this logic will be ignored and cached value will be used, even if it's stale data.
-        if (isFirstConnectionRef.current && Onyx_1.default.hasPendingMergeForKey(key) && !(options === null || options === void 0 ? void 0 : options.allowStaleData)) {
+        if (isFirstConnectionRef.current && OnyxUtils_1.default.hasPendingMergeForKey(key) && !(options === null || options === void 0 ? void 0 : options.allowStaleData)) {
             newValue = undefined;
             newFetchStatus = 'loading';
         }
@@ -90,7 +91,7 @@ function useOnyx(key, options) {
                 onStoreChange();
             },
             initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
-            waitForCollectionCallback: Onyx_1.default.isCollectionKey(key),
+            waitForCollectionCallback: OnyxUtils_1.default.isCollectionKey(key),
         });
         return () => {
             if (!connectionIDRef.current) {
@@ -105,14 +106,14 @@ function useOnyx(key, options) {
         if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionIDRef.current) {
             return;
         }
-        if (!Onyx_1.default.isSafeEvictionKey(key)) {
+        if (!OnyxUtils_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 (options.canEvict) {
-            Onyx_1.default.removeFromEvictionBlockList(key, connectionIDRef.current);
+            OnyxUtils_1.default.removeFromEvictionBlockList(key, connectionIDRef.current);
         }
         else {
-            Onyx_1.default.addToEvictionBlockList(key, connectionIDRef.current);
+            OnyxUtils_1.default.addToEvictionBlockList(key, connectionIDRef.current);
         }
     }, [key, options === null || options === void 0 ? void 0 : options.canEvict]);
     const result = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot);

package/dist/utils.d.ts

@@ -10,9 +10,9 @@ declare function isEmptyObject<T>(obj: T | EmptyValue): obj is EmptyValue;
  * On native, when merging an existing value with new changes, SQLite will use JSON_PATCH, which removes top-level nullish values.
  * To be consistent with the behaviour for merge, we'll also want to remove null values for "set" operations.
  */
-declare function fastMerge<TTarget extends unknown[] | Record<string, unknown>>(target: TTarget, source: TTarget, shouldRemoveNullObjectValues?: boolean): TTarget;
+declare function fastMerge<TObject extends Record<string, unknown>>(target: TObject | null, source: TObject | null, shouldRemoveNullObjectValues?: boolean): TObject | null;
 /** Deep removes the nested null values from the given value. */
-declare function removeNestedNullValues(value: unknown[] | Record<string, unknown>): Record<string, unknown> | unknown[];
+declare function removeNestedNullValues(value: unknown[] | Record<string, unknown>): Record<string, unknown> | unknown[] | null;
 /** Formats the action name by uppercasing and adding the key if provided. */
 declare function formatActionName(method: string, key?: OnyxKey): string;
 declare const _default: {