react-native-onyx 3.0.91 → 3.0.93

package/dist/memoizedShallowEqual.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Identity-pair-memoized shallowEqual: same (a, b) references → cached verdict, no walk.
+ */
+declare function memoizedShallowEqual(a: unknown, b: unknown): boolean;
+export default memoizedShallowEqual;

package/dist/memoizedShallowEqual.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fast_equals_1 = require("fast-equals");
+/**
+ * Memoizes shallowEqual verdicts by the identity of the compared objects. Onyx values are
+ * treated as immutable (merge/set replace objects, never mutate), so a (prev, next) reference
+ * pair always yields the same verdict. In the hot case — N no-selector hooks on the same big
+ * key — every hook compares the exact same two cache-owned objects, so the first hook pays for
+ * the O(keys) walk and the rest resolve in O(1). WeakMap keys make stale entries impossible to
+ * read (lookup requires holding both exact objects) and let GC reclaim them.
+ */
+const shallowEqualVerdicts = new WeakMap();
+/**
+ * Identity-pair-memoized shallowEqual: same (a, b) references → cached verdict, no walk.
+ */
+function memoizedShallowEqual(a, b) {
+    // Only object pairs are memoizable (WeakMap keys) — anything else is O(1) to compare anyway.
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+        return (0, fast_equals_1.shallowEqual)(a, b);
+    }
+    let verdictsForA = shallowEqualVerdicts.get(a);
+    if (!verdictsForA) {
+        verdictsForA = new WeakMap();
+        shallowEqualVerdicts.set(a, verdictsForA);
+    }
+    const cachedVerdict = verdictsForA.get(b);
+    if (cachedVerdict !== undefined) {
+        return cachedVerdict;
+    }
+    const verdict = (0, fast_equals_1.shallowEqual)(a, b);
+    verdictsForA.set(b, verdict);
+    return verdict;
+}
+exports.default = memoizedShallowEqual;

package/dist/storage/providers/SQLiteProvider.js

@@ -8,6 +8,34 @@ const react_native_device_info_1 = require("react-native-device-info");
 const utils_1 = __importDefault(require("../../utils"));
 const classifySQLiteError_1 = __importDefault(require("./classifySQLiteError"));
 const DB_NAME = 'OnyxDB';
+const SQLITE_MAX_VARIABLE_NUMBER = 32766;
+const COMPILE_OPTIONS = {
+    MAX_VARIABLE_NUMBER: 'MAX_VARIABLE_NUMBER',
+};
+/** SQLite's maximum number of bound parameters per statement, read once from PRAGMA compile_options in init(). */
+let sqliteMaxVariableNumber = SQLITE_MAX_VARIABLE_NUMBER;
+/**
+ * Returns the value of a compile option from the rows returned by `PRAGMA compile_options`.
+ * For flag-only options (e.g. `ENABLE_FTS3`), returns an empty string when the option is present.
+ */
+function getCompileOptionValue(compileOptionsResult, optionName) {
+    var _a, _b, _c, _d;
+    const optionPrefix = `${optionName}=`;
+    const rowCount = (_b = (_a = compileOptionsResult.rows) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    for (let index = 0; index < rowCount; index++) {
+        const compileOption = (_d = (_c = compileOptionsResult.rows) === null || _c === void 0 ? void 0 : _c.item(index)) === null || _d === void 0 ? void 0 : _d.compile_options;
+        if (!compileOption) {
+            continue;
+        }
+        if (compileOption === optionName) {
+            return '';
+        }
+        if (compileOption.startsWith(optionPrefix)) {
+            return compileOption.slice(optionPrefix.length);
+        }
+    }
+    return undefined;
+}
 /**
  * Prevents the stringifying of the object markers.
  */
@@ -47,6 +75,11 @@ const provider = {
         provider.store.execute('PRAGMA CACHE_SIZE=-20000;');
         provider.store.execute('PRAGMA synchronous=NORMAL;');
         provider.store.execute('PRAGMA journal_mode=WAL;');
+        const compileOptionsResult = provider.store.execute('PRAGMA compile_options;');
+        // Get the value of MAX_VARIABLE_NUMBER from the compile options and
+        // stores it in a global variable, that is going to be used during runtime.
+        const maxVariableNumber = Number(getCompileOptionValue(compileOptionsResult, COMPILE_OPTIONS.MAX_VARIABLE_NUMBER));
+        sqliteMaxVariableNumber = maxVariableNumber > 0 ? maxVariableNumber : SQLITE_MAX_VARIABLE_NUMBER;
     },
     getItem(key) {
         if (!provider.store) {
@@ -67,12 +100,22 @@ const provider = {
         if (!provider.store) {
             throw new Error('Store is not initialized!');
         }
-        const placeholders = keys.map(() => '?').join(',');
-        const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-        return provider.store.executeAsync(command, keys).then(({ rows }) => {
+        if (keys.length === 0) {
+            return Promise.resolve([]);
+        }
+        const keyChunks = utils_1.default.chunkArray(keys, sqliteMaxVariableNumber);
+        return Promise.all(keyChunks.map((keyChunk) => {
+            if (!provider.store) {
+                throw new Error('Store is not initialized!');
+            }
+            const placeholders = keyChunk.map(() => '?').join(',');
+            const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
+            return provider.store.executeAsync(command, keyChunk);
+        })).then((results) => {
+            const result = results.flatMap(({ rows }) => { var _a; 
             // eslint-disable-next-line no-underscore-dangle
-            const result = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => [row.record_key, JSON.parse(row.valueJSON)]);
-            return (result !== null && result !== void 0 ? result : []);
+            return (_a = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => [row.record_key, JSON.parse(row.valueJSON)])) !== null && _a !== void 0 ? _a : []; });
+            return result;
         });
     },
     setItem(key, value) {
@@ -86,7 +129,7 @@ const provider = {
             throw new Error('Store is not initialized!');
         }
         const query = 'REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);';
-        const params = pairs.map((pair) => [pair[0], JSON.stringify(pair[1] === undefined ? null : pair[1])]);
+        const params = pairs.map(([key, value]) => [key, JSON.stringify(value === undefined ? null : value)]);
         if (utils_1.default.isEmptyObject(params)) {
             return Promise.resolve();
         }
@@ -173,9 +216,23 @@ const provider = {
         if (!provider.store) {
             throw new Error('Store is not initialized!');
         }
-        const placeholders = keys.map(() => '?').join(',');
-        const query = `DELETE FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-        return provider.store.executeAsync(query, keys).then(() => undefined);
+        if (keys.length === 0) {
+            return Promise.resolve();
+        }
+        const keyChunks = utils_1.default.chunkArray(keys, sqliteMaxVariableNumber);
+        const buildDeleteQuery = (keyChunk) => {
+            const placeholders = keyChunk.map(() => '?').join(',');
+            return `DELETE FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
+        };
+        if (keyChunks.length === 1) {
+            const keyChunk = keyChunks[0];
+            return provider.store.executeAsync(buildDeleteQuery(keyChunk), keyChunk).then(() => undefined);
+        }
+        const commands = keyChunks.map((keyChunk) => ({
+            query: buildDeleteQuery(keyChunk),
+            params: keyChunk,
+        }));
+        return provider.store.executeBatchAsync(commands).then(() => undefined);
     },
     clear() {
         if (!provider.store) {

package/dist/useOnyx.js

@@ -42,6 +42,7 @@ const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
+const memoizedShallowEqual_1 = __importDefault(require("./memoizedShallowEqual"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 function useOnyx(key, options, dependencies = []) {
     const connectionRef = (0, react_1.useRef)(null);
@@ -170,9 +171,11 @@ function useOnyx(key, options, dependencies = []) {
         }
         // shallowEqual checks === first (O(1) for frozen snapshots and stable selector references),
         // then falls back to comparing top-level properties for individual keys that may have
-        // new references with equivalent content.
+        // new references with equivalent content. The comparison is memoized by object identity
+        // (see `memoizedShallowEqual`) so N hooks comparing the same two cache objects pay for
+        // one walk in total instead of one walk each.
         // Normalize null to undefined to ensure consistent comparison (both represent "no value").
-        const areValuesEqual = (0, fast_equals_1.shallowEqual)((_a = previousValueRef.current) !== null && _a !== void 0 ? _a : undefined, (_b = newValueRef.current) !== null && _b !== void 0 ? _b : undefined);
+        const areValuesEqual = (0, memoizedShallowEqual_1.default)((_a = previousValueRef.current) !== null && _a !== void 0 ? _a : undefined, (_b = newValueRef.current) !== null && _b !== void 0 ? _b : undefined);
         // We update the cached value and the result in the following conditions:
         // We will update the cached value and the result in any of the following situations:
         // - The previously cached value is different from the new value.

package/dist/utils.d.ts

@@ -64,6 +64,10 @@ 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>;
+/**
+ * Splits an array into chunks no larger than maxChunkSize.
+ */
+declare function chunkArray<T>(items: readonly T[], maxChunkSize: number): T[][];
 declare const _default: {
     fastMerge: typeof fastMerge;
     isEmptyObject: typeof isEmptyObject;
@@ -72,6 +76,7 @@ declare const _default: {
     checkCompatibilityWithExistingValue: typeof checkCompatibilityWithExistingValue;
     pick: typeof pick;
     omit: typeof omit;
+    chunkArray: typeof chunkArray;
     ONYX_INTERNALS__REPLACE_OBJECT_MARK: string;
 };
 export default _default;

package/dist/utils.js

@@ -238,6 +238,22 @@ function pick(obj, condition) {
 function omit(obj, condition) {
     return filterObject(obj, condition, false);
 }
+/**
+ * Splits an array into chunks no larger than maxChunkSize.
+ */
+function chunkArray(items, maxChunkSize) {
+    if (items.length === 0) {
+        return [];
+    }
+    if (items.length <= maxChunkSize) {
+        return [items];
+    }
+    const chunks = [];
+    for (let i = 0; i < items.length; i += maxChunkSize) {
+        chunks.push(items.slice(i, i + maxChunkSize));
+    }
+    return chunks;
+}
 exports.default = {
     fastMerge,
     isEmptyObject,
@@ -246,5 +262,6 @@ exports.default = {
     checkCompatibilityWithExistingValue,
     pick,
     omit,
+    chunkArray,
     ONYX_INTERNALS__REPLACE_OBJECT_MARK,
 };

package/package.json

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