react-native-onyx 3.0.116 → 3.0.118

package/dist/OnyxConnectionManager.js

@@ -1,189 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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 });
-const lodash_bindall_1 = __importDefault(require("lodash.bindall"));
-const Logger = __importStar(require("./Logger"));
-const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
-const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
-const Str = __importStar(require("./Str"));
-const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
-/**
- * Manages Onyx connections of `Onyx.connect()` and `useOnyx()` subscribers.
- */
-class OnyxConnectionManager {
-    constructor() {
-        this.connectionsMap = new Map();
-        this.lastCallbackID = 0;
-        this.sessionID = Str.guid();
-        // Binds all public methods to prevent problems with `this`.
-        (0, lodash_bindall_1.default)(this, 'generateConnectionID', 'fireCallbacks', 'connect', 'disconnect', 'disconnectAll', 'refreshSessionID');
-    }
-    /**
-     * Generates a connection ID based on the `connectOptions` object passed to the function.
-     *
-     * The properties used to generate the ID are handpicked for performance reasons and
-     * according to their purpose and effect they produce in the Onyx connection.
-     */
-    generateConnectionID(connectOptions) {
-        const { key, reuseConnection } = connectOptions;
-        // The current session ID is appended to the connection ID so we can have different connections
-        // after an `Onyx.clear()` operation.
-        let suffix = `,sessionID=${this.sessionID}`;
-        // We will generate a unique ID when `reuseConnection` is `false`, which means the subscriber
-        // explicitly wants the connection to not be reused. Collection-root subscriptions are now always
-        // snapshot mode, so they can be reused like any other connection.
-        if (reuseConnection === false) {
-            suffix += `,uniqueID=${Str.guid()}`;
-        }
-        return `onyxKey=${key}${suffix}`;
-    }
-    /**
-     * Fires all the subscribers callbacks associated with that connection ID.
-     */
-    fireCallbacks(connectionID) {
-        const connection = this.connectionsMap.get(connectionID);
-        if (!connection) {
-            return;
-        }
-        for (const callback of connection.callbacks.values()) {
-            try {
-                if (OnyxKeys_1.default.isCollectionKey(connection.onyxKey)) {
-                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
-                }
-                else {
-                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
-                }
-            }
-            catch (error) {
-                Logger.logAlert(`[ConnectionManager] Subscriber callback threw an error for key '${connection.onyxKey}': ${String(error)}`);
-            }
-        }
-    }
-    /**
-     * Connects to an Onyx key given the options passed and listens to its changes.
-     *
-     * @param connectOptions The options object that will define the behavior of the connection.
-     * @returns The connection object to use when calling `disconnect()`.
-     */
-    connect(connectOptions) {
-        const connectionID = this.generateConnectionID(connectOptions);
-        let connectionMetadata = this.connectionsMap.get(connectionID);
-        let subscriptionID;
-        const callbackID = String(this.lastCallbackID++);
-        // If there is no connection yet for that connection ID, we create a new one.
-        if (!connectionMetadata) {
-            const callback = (value, key) => {
-                const createdConnection = this.connectionsMap.get(connectionID);
-                if (createdConnection) {
-                    // We signal that the first connection was made and now any new subscribers
-                    // can fire their callbacks immediately with the cached value when connecting.
-                    createdConnection.isConnectionMade = true;
-                    createdConnection.cachedCallbackValue = value;
-                    createdConnection.cachedCallbackKey = key;
-                    this.fireCallbacks(connectionID);
-                }
-            };
-            subscriptionID = OnyxUtils_1.default.subscribeToKey(Object.assign(Object.assign({}, connectOptions), { callback }));
-            connectionMetadata = {
-                subscriptionID,
-                onyxKey: connectOptions.key,
-                isConnectionMade: false,
-                callbacks: new Map(),
-            };
-            this.connectionsMap.set(connectionID, connectionMetadata);
-        }
-        // We add the subscriber's callback to the list of callbacks associated with this connection.
-        if (connectOptions.callback) {
-            connectionMetadata.callbacks.set(callbackID, connectOptions.callback);
-        }
-        // If the first connection is already made we want any new subscribers to receive the cached callback value immediately.
-        if (connectionMetadata.isConnectionMade) {
-            // Defer the callback execution to the next tick of the event loop.
-            // This ensures that the current execution flow completes and the result connection object is available when the callback fires.
-            Promise.resolve().then(() => {
-                var _a;
-                (_a = connectOptions.callback) === null || _a === void 0 ? void 0 : _a.call(connectOptions, connectionMetadata.cachedCallbackValue, connectionMetadata.cachedCallbackKey);
-            });
-        }
-        return { id: connectionID, callbackID };
-    }
-    /**
-     * Disconnects and removes the listener from the Onyx key.
-     *
-     * @param connection Connection object returned by calling `connect()`.
-     */
-    disconnect(connection) {
-        if (!connection) {
-            Logger.logInfo(`[ConnectionManager] Attempted to disconnect passing an undefined connection object.`);
-            return;
-        }
-        const connectionMetadata = this.connectionsMap.get(connection.id);
-        if (!connectionMetadata) {
-            Logger.logInfo(`[ConnectionManager] Attempted to disconnect but no connection was found.`);
-            return;
-        }
-        // Removes the callback from the connection's callbacks map.
-        connectionMetadata.callbacks.delete(connection.callbackID);
-        // If the connection's callbacks map is empty we can safely unsubscribe from the Onyx key.
-        if (connectionMetadata.callbacks.size === 0) {
-            OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
-            this.connectionsMap.delete(connection.id);
-        }
-    }
-    /**
-     * Disconnect all subscribers from Onyx.
-     */
-    disconnectAll() {
-        for (const connectionMetadata of this.connectionsMap.values()) {
-            OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
-        }
-        this.connectionsMap.clear();
-        // Clear snapshot cache when all connections are disconnected
-        OnyxSnapshotCache_1.default.clear();
-    }
-    /**
-     * Refreshes the connection manager's session ID.
-     */
-    refreshSessionID() {
-        this.sessionID = Str.guid();
-        // Clear snapshot cache when session refreshes to avoid stale cache issues
-        OnyxSnapshotCache_1.default.clear();
-    }
-}
-const connectionManager = new OnyxConnectionManager();
-exports.default = connectionManager;

package/dist/OnyxSnapshotCache.d.ts

@@ -1,75 +0,0 @@
-import type { OnyxKey, OnyxValue } from './types';
-import type { UseOnyxOptions, UseOnyxResult, UseOnyxSelector } from './useOnyx';
-/**
- * Manages snapshot caching for useOnyx hook performance optimization.
- * Handles selector function tracking and memoized getSnapshot results.
- */
-declare class OnyxSnapshotCache {
-    /**
-     * Snapshot cache is a two-level map. The top-level keys are Onyx keys. The top-level values maps.
-     * The second-level keys are a custom composite string defined by this.registerConsumer. These represent a unique useOnyx config, which is not fully represented by the Onyx key alone.
-     * The reason we have two levels is for performance: not to make cache access faster, but to make cache invalidation faster.
-     * We can invalidate the snapshot cache for a given Onyx key with one map.delete operation on the top-level map, rather than having to loop through a large single-level map and delete any matching keys.
-     */
-    private snapshotCache;
-    /**
-     * Maps selector functions to unique IDs for cache key generation
-     */
-    private selectorIDMap;
-    /**
-     * Counter for generating incremental selector IDs
-     */
-    private selectorIDCounter;
-    /**
-     * Reference counting for cache keys to enable automatic cleanup.
-     * Maps cache key (string) to number of consumers using it.
-     */
-    private cacheKeyRefCounts;
-    constructor();
-    /**
-     * Generate unique ID for selector functions using incrementing numbers
-     */
-    getSelectorID<TKey extends OnyxKey, TReturnValue>(selector: UseOnyxSelector<TKey, TReturnValue>): number;
-    /**
-     * Register a consumer for a cache key and return the cache key.
-     * Generates cache key and increments reference counter.
-     *
-     * The properties used to generate the cache key are handpicked for performance reasons and
-     * according to their purpose and effect they produce in the useOnyx hook behavior:
-     *
-     * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
-     *
-     * Other options like `reuseConnection` don't affect the data transformation
-     * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
-     */
-    registerConsumer<TKey extends OnyxKey, TReturnValue>(key: TKey, options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector'>): string;
-    /**
-     * Deregister a consumer for a cache key.
-     * Decrements reference counter and removes cache entry if no consumers remain.
-     */
-    deregisterConsumer(key: OnyxKey, cacheKey: string): void;
-    /**
-     * Get cached snapshot result for a key and cache key combination
-     */
-    getCachedResult<TResult extends UseOnyxResult<OnyxValue<OnyxKey>>>(key: OnyxKey, cacheKey: string): TResult | undefined;
-    /**
-     * Set cached snapshot result for a key and cache key combination
-     */
-    setCachedResult<TResult extends UseOnyxResult<OnyxValue<OnyxKey>>>(key: OnyxKey, cacheKey: string, result: TResult): void;
-    /**
-     * Selective cache invalidation to prevent data unavailability
-     * Collection members invalidate upward, collections don't cascade downward
-     */
-    invalidateForKey(keyToInvalidate: OnyxKey): void;
-    /**
-     * Clear all snapshot cache
-     */
-    clear(): void;
-    /**
-     * Clear selector ID mappings (useful for testing)
-     */
-    clearSelectorIds(): void;
-}
-declare const onyxSnapshotCache: OnyxSnapshotCache;
-export default onyxSnapshotCache;
-export { OnyxSnapshotCache };

package/dist/OnyxSnapshotCache.js

@@ -1,125 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnyxSnapshotCache = void 0;
-const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
-/**
- * Manages snapshot caching for useOnyx hook performance optimization.
- * Handles selector function tracking and memoized getSnapshot results.
- */
-class OnyxSnapshotCache {
-    constructor() {
-        this.snapshotCache = new Map();
-        this.selectorIDMap = new WeakMap();
-        this.selectorIDCounter = 0;
-        this.cacheKeyRefCounts = new Map();
-    }
-    /**
-     * Generate unique ID for selector functions using incrementing numbers
-     */
-    getSelectorID(selector) {
-        const typedSelector = selector;
-        const existingID = this.selectorIDMap.get(typedSelector);
-        if (existingID !== undefined) {
-            return existingID;
-        }
-        const id = this.selectorIDCounter++;
-        this.selectorIDMap.set(typedSelector, id);
-        return id;
-    }
-    /**
-     * Register a consumer for a cache key and return the cache key.
-     * Generates cache key and increments reference counter.
-     *
-     * The properties used to generate the cache key are handpicked for performance reasons and
-     * according to their purpose and effect they produce in the useOnyx hook behavior:
-     *
-     * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
-     *
-     * Other options like `reuseConnection` don't affect the data transformation
-     * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
-     */
-    registerConsumer(key, options) {
-        var _a;
-        const selectorID = (options === null || options === void 0 ? void 0 : options.selector) ? this.getSelectorID(options.selector) : 'no_selector';
-        const cacheKey = `${key}_${selectorID}`;
-        // Increment reference count for this cache key
-        const currentCount = (_a = this.cacheKeyRefCounts.get(cacheKey)) !== null && _a !== void 0 ? _a : 0;
-        this.cacheKeyRefCounts.set(cacheKey, currentCount + 1);
-        return cacheKey;
-    }
-    /**
-     * Deregister a consumer for a cache key.
-     * Decrements reference counter and removes cache entry if no consumers remain.
-     */
-    deregisterConsumer(key, cacheKey) {
-        var _a;
-        const currentCount = (_a = this.cacheKeyRefCounts.get(cacheKey)) !== null && _a !== void 0 ? _a : 0;
-        if (currentCount <= 1) {
-            // Last consumer - remove from reference counter and cache
-            this.cacheKeyRefCounts.delete(cacheKey);
-            // Remove from snapshot cache
-            const keyCache = this.snapshotCache.get(key);
-            if (keyCache) {
-                keyCache.delete(cacheKey);
-                // If this was the last cache entry for this Onyx key, remove the key entirely
-                if (keyCache.size === 0) {
-                    this.snapshotCache.delete(key);
-                }
-            }
-        }
-        else {
-            // Still has other consumers - just decrement count
-            this.cacheKeyRefCounts.set(cacheKey, currentCount - 1);
-        }
-    }
-    /**
-     * Get cached snapshot result for a key and cache key combination
-     */
-    getCachedResult(key, cacheKey) {
-        const keyCache = this.snapshotCache.get(key);
-        return keyCache === null || keyCache === void 0 ? void 0 : keyCache.get(cacheKey);
-    }
-    /**
-     * Set cached snapshot result for a key and cache key combination
-     */
-    setCachedResult(key, cacheKey, result) {
-        let keyCache = this.snapshotCache.get(key);
-        if (!keyCache) {
-            keyCache = new Map();
-            this.snapshotCache.set(key, keyCache);
-        }
-        keyCache.set(cacheKey, result);
-    }
-    /**
-     * Selective cache invalidation to prevent data unavailability
-     * Collection members invalidate upward, collections don't cascade downward
-     */
-    invalidateForKey(keyToInvalidate) {
-        // Always invalidate the exact key
-        this.snapshotCache.delete(keyToInvalidate);
-        // Check if the key is a collection member and invalidate the collection base key
-        const collectionBaseKey = OnyxKeys_1.default.getCollectionKey(keyToInvalidate);
-        if (collectionBaseKey) {
-            this.snapshotCache.delete(collectionBaseKey);
-        }
-    }
-    /**
-     * Clear all snapshot cache
-     */
-    clear() {
-        this.snapshotCache.clear();
-    }
-    /**
-     * Clear selector ID mappings (useful for testing)
-     */
-    clearSelectorIds() {
-        this.selectorIDCounter = 0;
-    }
-}
-exports.OnyxSnapshotCache = OnyxSnapshotCache;
-// Create and export a singleton instance
-const onyxSnapshotCache = new OnyxSnapshotCache();
-exports.default = onyxSnapshotCache;

package/dist/createMemoizedSelector.d.ts

@@ -1,18 +0,0 @@
-/**
- * Wraps a selector function so that:
- * - Calling the wrapper with the same input reference twice short-circuits to the cached output
- *   (cheap `===` check, no recompute).
- * - Calling with a different input that produces a deep-equal output returns the *previous*
- *   output reference, so downstream `===` comparisons treat it as unchanged.
- *
- * This is the minimum needed for `useSyncExternalStore` to not loop when consumers pass
- * inline selectors that allocate fresh objects on every call (e.g. `(e) => ({id: e?.id})`):
- * without the deep-equal fallback, every `getSnapshot` would return a new reference and React
- * would re-render (or throw "getSnapshot should be cached") indefinitely.
- *
- * Stateful by design — each call to `createMemoizedSelector` produces an independent wrapper
- * with its own `lastInput`/`lastOutput` cache, so a wrapper must not be shared across
- * subscriptions that can see different inputs.
- */
-declare function createMemoizedSelector<TInput, TOutput>(selector: (input: TInput) => TOutput): (input: TInput) => TOutput;
-export default createMemoizedSelector;

package/dist/createMemoizedSelector.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fast_equals_1 = require("fast-equals");
-/**
- * Wraps a selector function so that:
- * - Calling the wrapper with the same input reference twice short-circuits to the cached output
- *   (cheap `===` check, no recompute).
- * - Calling with a different input that produces a deep-equal output returns the *previous*
- *   output reference, so downstream `===` comparisons treat it as unchanged.
- *
- * This is the minimum needed for `useSyncExternalStore` to not loop when consumers pass
- * inline selectors that allocate fresh objects on every call (e.g. `(e) => ({id: e?.id})`):
- * without the deep-equal fallback, every `getSnapshot` would return a new reference and React
- * would re-render (or throw "getSnapshot should be cached") indefinitely.
- *
- * Stateful by design — each call to `createMemoizedSelector` produces an independent wrapper
- * with its own `lastInput`/`lastOutput` cache, so a wrapper must not be shared across
- * subscriptions that can see different inputs.
- */
-function createMemoizedSelector(selector) {
-    let lastInput;
-    let lastOutput;
-    let hasComputed = false;
-    return (input) => {
-        if (hasComputed && lastInput === input) {
-            return lastOutput;
-        }
-        const next = selector(input);
-        lastInput = input;
-        if (!hasComputed || !(0, fast_equals_1.deepEqual)(lastOutput, next)) {
-            lastOutput = next;
-            hasComputed = true;
-        }
-        return lastOutput;
-    };
-}
-exports.default = createMemoizedSelector;

package/dist/memoizedShallowEqual.d.ts

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-"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;