react-easy-wall 2.0.14 → 3.0.0

package/dist/esm/node_modules/@apollo/client/cache/inmemory/inMemoryCache.js

@@ -1,508 +0,0 @@
-import { equal } from '../../../../@wry/equality/lib/index.js';
-import { wrap } from '../../../../optimism/lib/index.js';
-import { DocumentTransform } from '../../utilities/graphql/DocumentTransform.js';
-import { print } from '../../utilities/graphql/print.js';
-import { isReference } from '../../utilities/graphql/storeUtils.js';
-import { addTypenameToDocument } from '../../utilities/graphql/transform.js';
-import '../../utilities/invariant/index.js';
-import { ApolloCache } from '../core/cache.js';
-import { EntityStore, supportsResultCaching } from './entityStore.js';
-import { normalizeConfig, hasOwn } from './helpers.js';
-import { Policies } from './policies.js';
-import { makeVar, recallCache, forgetCache } from './reactiveVars.js';
-import { StoreReader } from './readFromStore.js';
-import { StoreWriter } from './writeToStore.js';
-import { cacheSizes } from '../../utilities/caching/sizes.js';
-import { canonicalStringify } from '../../utilities/internal/canonicalStringify.js';
-
-class InMemoryCache extends ApolloCache {
-    data;
-    optimisticData;
-    config;
-    watches = new Set();
-    storeReader;
-    storeWriter;
-    addTypenameTransform = new DocumentTransform(addTypenameToDocument);
-    maybeBroadcastWatch;
-    // Override the default value, since InMemoryCache result objects are frozen
-    // in development and expected to remain logically immutable in production.
-    assumeImmutableResults = true;
-    // Dynamically imported code can augment existing typePolicies or
-    // possibleTypes by calling cache.policies.addTypePolicies or
-    // cache.policies.addPossibletypes.
-    policies;
-    makeVar = makeVar;
-    constructor(config = {}) {
-        super();
-        this.config = normalizeConfig(config);
-        this.policies = new Policies({
-            cache: this,
-            dataIdFromObject: this.config.dataIdFromObject,
-            possibleTypes: this.config.possibleTypes,
-            typePolicies: this.config.typePolicies,
-        });
-        this.init();
-    }
-    init() {
-        // Passing { resultCaching: false } in the InMemoryCache constructor options
-        // will completely disable dependency tracking, which will improve memory
-        // usage but worsen the performance of repeated reads.
-        const rootStore = (this.data = new EntityStore.Root({
-            policies: this.policies,
-            resultCaching: this.config.resultCaching,
-        }));
-        // When no optimistic writes are currently active, cache.optimisticData ===
-        // cache.data, so there are no additional layers on top of the actual data.
-        // When an optimistic update happens, this.optimisticData will become a
-        // linked list of EntityStore Layer objects that terminates with the
-        // original this.data cache object.
-        this.optimisticData = rootStore.stump;
-        this.resetResultCache();
-    }
-    resetResultCache() {
-        const { fragments } = this.config;
-        this.addTypenameTransform.resetCache();
-        fragments?.resetCaches();
-        // The StoreWriter is mostly stateless and so doesn't really need to be
-        // reset, but it does need to have its writer.storeReader reference updated,
-        // so it's simpler to update this.storeWriter as well.
-        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({ cache: this, fragments })), fragments);
-        this.maybeBroadcastWatch = wrap((c, options) => {
-            return this.broadcastWatch(c, options);
-        }, {
-            max: cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
-                5000 /* defaultCacheSizes["inMemoryCache.maybeBroadcastWatch"] */,
-            makeCacheKey: (c) => {
-                // Return a cache key (thus enabling result caching) only if we're
-                // currently using a data store that can track cache dependencies.
-                const store = c.optimistic ? this.optimisticData : this.data;
-                if (supportsResultCaching(store)) {
-                    const { optimistic, id, variables } = c;
-                    return store.makeCacheKey(c.query, 
-                    // Different watches can have the same query, optimistic
-                    // status, rootId, and variables, but if their callbacks are
-                    // different, the (identical) result needs to be delivered to
-                    // each distinct callback. The easiest way to achieve that
-                    // separation is to include c.callback in the cache key for
-                    // maybeBroadcastWatch calls. See issue #5733.
-                    c.callback, canonicalStringify({ optimistic, id, variables }));
-                }
-            },
-        });
-        // Since we have thrown away all the cached functions that depend on the
-        // CacheGroup dependencies maintained by EntityStore, we should also reset
-        // all CacheGroup dependency information.
-        new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());
-    }
-    restore(data) {
-        this.init();
-        // Since calling this.init() discards/replaces the entire StoreReader, along
-        // with the result caches it maintains, this.data.replace(data) won't have
-        // to bother deleting the old data.
-        if (data)
-            this.data.replace(data);
-        return this;
-    }
-    extract(optimistic = false) {
-        return (optimistic ? this.optimisticData : this.data).extract();
-    }
-    read(options) {
-        const { 
-        // Since read returns data or null, without any additional metadata
-        // about whether/where there might have been missing fields, the
-        // default behavior cannot be returnPartialData = true (like it is
-        // for the diff method), since defaulting to true would violate the
-        // integrity of the T in the return type. However, partial data may
-        // be useful in some cases, so returnPartialData:true may be
-        // specified explicitly.
-        returnPartialData = false, } = options;
-        return this.storeReader.diffQueryAgainstStore({
-            ...options,
-            store: options.optimistic ? this.optimisticData : this.data,
-            config: this.config,
-            returnPartialData,
-        }).result;
-    }
-    write(options) {
-        try {
-            ++this.txCount;
-            return this.storeWriter.writeToStore(this.data, options);
-        }
-        finally {
-            if (!--this.txCount && options.broadcast !== false) {
-                this.broadcastWatches();
-            }
-        }
-    }
-    modify(options) {
-        if (hasOwn.call(options, "id") && !options.id) {
-            // To my knowledge, TypeScript does not currently provide a way to
-            // enforce that an optional property?:type must *not* be undefined
-            // when present. That ability would be useful here, because we want
-            // options.id to default to ROOT_QUERY only when no options.id was
-            // provided. If the caller attempts to pass options.id with a
-            // falsy/undefined value (perhaps because cache.identify failed), we
-            // should not assume the goal was to modify the ROOT_QUERY object.
-            // We could throw, but it seems natural to return false to indicate
-            // that nothing was modified.
-            return false;
-        }
-        const store = ((options.optimistic) // Defaults to false.
-        ) ?
-            this.optimisticData
-            : this.data;
-        try {
-            ++this.txCount;
-            return store.modify(options.id || "ROOT_QUERY", options.fields, false);
-        }
-        finally {
-            if (!--this.txCount && options.broadcast !== false) {
-                this.broadcastWatches();
-            }
-        }
-    }
-    diff(options) {
-        return this.storeReader.diffQueryAgainstStore({
-            ...options,
-            store: options.optimistic ? this.optimisticData : this.data,
-            rootId: options.id || "ROOT_QUERY",
-            config: this.config,
-        });
-    }
-    watch(watch) {
-        if (!this.watches.size) {
-            // In case we previously called forgetCache(this) because
-            // this.watches became empty (see below), reattach this cache to any
-            // reactive variables on which it previously depended. It might seem
-            // paradoxical that we're able to recall something we supposedly
-            // forgot, but the point of calling forgetCache(this) is to silence
-            // useless broadcasts while this.watches is empty, and to allow the
-            // cache to be garbage collected. If, however, we manage to call
-            // recallCache(this) here, this cache object must not have been
-            // garbage collected yet, and should resume receiving updates from
-            // reactive variables, now that it has a watcher to notify.
-            recallCache(this);
-        }
-        this.watches.add(watch);
-        if (watch.immediate) {
-            this.maybeBroadcastWatch(watch);
-        }
-        return () => {
-            // Once we remove the last watch from this.watches, cache.broadcastWatches
-            // no longer does anything, so we preemptively tell the reactive variable
-            // system to exclude this cache from future broadcasts.
-            if (this.watches.delete(watch) && !this.watches.size) {
-                forgetCache(this);
-            }
-            // Remove this watch from the LRU cache managed by the
-            // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory
-            // leaks involving the closure of watch.callback.
-            this.maybeBroadcastWatch.forget(watch);
-        };
-    }
-    gc(options) {
-        canonicalStringify.reset();
-        print.reset();
-        const ids = this.optimisticData.gc();
-        if (options && !this.txCount && options.resetResultCache) {
-            this.resetResultCache();
-        }
-        return ids;
-    }
-    // Call this method to ensure the given root ID remains in the cache after
-    // garbage collection, along with its transitive child entities. Note that
-    // the cache automatically retains all directly written entities. By default,
-    // the retainment persists after optimistic updates are removed. Pass true
-    // for the optimistic argument if you would prefer for the retainment to be
-    // discarded when the top-most optimistic layer is removed. Returns the
-    // resulting (non-negative) retainment count.
-    retain(rootId, optimistic) {
-        return (optimistic ? this.optimisticData : this.data).retain(rootId);
-    }
-    // Call this method to undo the effect of the retain method, above. Once the
-    // retainment count falls to zero, the given ID will no longer be preserved
-    // during garbage collection, though it may still be preserved by other safe
-    // entities that refer to it. Returns the resulting (non-negative) retainment
-    // count, in case that's useful.
-    release(rootId, optimistic) {
-        return (optimistic ? this.optimisticData : this.data).release(rootId);
-    }
-    // Returns the canonical ID for a given StoreObject, obeying typePolicies
-    // and keyFields (and dataIdFromObject, if you still use that). At minimum,
-    // the object must contain a __typename and any primary key fields required
-    // to identify entities of that type. If you pass a query result object, be
-    // sure that none of the primary key fields have been renamed by aliasing.
-    // If you pass a Reference object, its __ref ID string will be returned.
-    identify(object) {
-        if (isReference(object))
-            return object.__ref;
-        try {
-            return this.policies.identify(object)[0];
-        }
-        catch (e) {
-        }
-    }
-    evict(options) {
-        if (!options.id) {
-            if (hasOwn.call(options, "id")) {
-                // See comment in modify method about why we return false when
-                // options.id exists but is falsy/undefined.
-                return false;
-            }
-            options = { ...options, id: "ROOT_QUERY" };
-        }
-        try {
-            // It's unlikely that the eviction will end up invoking any other
-            // cache update operations while it's running, but {in,de}crementing
-            // this.txCount still seems like a good idea, for uniformity with
-            // the other update methods.
-            ++this.txCount;
-            // Pass this.data as a limit on the depth of the eviction, so evictions
-            // during optimistic updates (when this.data is temporarily set equal to
-            // this.optimisticData) do not escape their optimistic Layer.
-            return this.optimisticData.evict(options, this.data);
-        }
-        finally {
-            if (!--this.txCount && options.broadcast !== false) {
-                this.broadcastWatches();
-            }
-        }
-    }
-    reset(options) {
-        this.init();
-        canonicalStringify.reset();
-        if (options && options.discardWatches) {
-            // Similar to what happens in the unsubscribe function returned by
-            // cache.watch, applied to all current watches.
-            this.watches.forEach((watch) => this.maybeBroadcastWatch.forget(watch));
-            this.watches.clear();
-            forgetCache(this);
-        }
-        else {
-            // Calling this.init() above unblocks all maybeBroadcastWatch caching, so
-            // this.broadcastWatches() triggers a broadcast to every current watcher
-            // (letting them know their data is now missing). This default behavior is
-            // convenient because it means the watches do not have to be manually
-            // reestablished after resetting the cache. To prevent this broadcast and
-            // cancel all watches, pass true for options.discardWatches.
-            this.broadcastWatches();
-        }
-        return Promise.resolve();
-    }
-    removeOptimistic(idToRemove) {
-        const newOptimisticData = this.optimisticData.removeLayer(idToRemove);
-        if (newOptimisticData !== this.optimisticData) {
-            this.optimisticData = newOptimisticData;
-            this.broadcastWatches();
-        }
-    }
-    txCount = 0;
-    /**
-    * Executes multiple cache operations as a single batch, ensuring that
-    * watchers are only notified once after all operations complete. This is
-    * useful for improving performance when making multiple cache updates, as it
-    * prevents unnecessary re-renders or query refetches between individual
-    * operations.
-    * 
-    * The `batch` method supports both optimistic and non-optimistic updates, and
-    * provides fine-grained control over which cache layer receives the updates
-    * and when watchers are notified.
-    * 
-    * For usage instructions, see [Interacting with cached data: `cache.batch`](https://www.apollographql.com/docs/react/caching/cache-interaction#using-cachebatch).
-    * 
-    * @example
-    * 
-    * ```js
-    * cache.batch({
-    *   update(cache) {
-    *     cache.writeQuery({
-    *       query: GET_TODOS,
-    *       data: { todos: updatedTodos },
-    *     });
-    *     cache.evict({ id: "Todo:123" });
-    *   },
-    * });
-    * ```
-    * 
-    * @example
-    * 
-    * ```js
-    * // Optimistic update with a custom layer ID
-    * cache.batch({
-    *   optimistic: "add-todo-optimistic",
-    *   update(cache) {
-    *     cache.modify({
-    *       fields: {
-    *         todos(existing = []) {
-    *           return [...existing, newTodoRef];
-    *         },
-    *       },
-    *     });
-    *   },
-    * });
-    * ```
-    * 
-    * @returns The return value of the `update` function.
-    */
-    batch(options) {
-        const { update, optimistic = true, removeOptimistic, onWatchUpdated, } = options;
-        let updateResult;
-        const perform = (layer) => {
-            const { data, optimisticData } = this;
-            ++this.txCount;
-            if (layer) {
-                this.data = this.optimisticData = layer;
-            }
-            try {
-                return (updateResult = update(this));
-            }
-            finally {
-                --this.txCount;
-                this.data = data;
-                this.optimisticData = optimisticData;
-            }
-        };
-        const alreadyDirty = new Set();
-        if (onWatchUpdated && !this.txCount) {
-            // If an options.onWatchUpdated callback is provided, we want to call it
-            // with only the Cache.WatchOptions objects affected by options.update,
-            // but there might be dirty watchers already waiting to be broadcast that
-            // have nothing to do with the update. To prevent including those watchers
-            // in the post-update broadcast, we perform this initial broadcast to
-            // collect the dirty watchers, so we can re-dirty them later, after the
-            // post-update broadcast, allowing them to receive their pending
-            // broadcasts the next time broadcastWatches is called, just as they would
-            // if we never called cache.batch.
-            this.broadcastWatches({
-                ...options,
-                onWatchUpdated(watch) {
-                    alreadyDirty.add(watch);
-                    return false;
-                },
-            });
-        }
-        if (typeof optimistic === "string") {
-            // Note that there can be multiple layers with the same optimistic ID.
-            // When removeOptimistic(id) is called for that id, all matching layers
-            // will be removed, and the remaining layers will be reapplied.
-            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);
-        }
-        else if (optimistic === false) {
-            // Ensure both this.data and this.optimisticData refer to the root
-            // (non-optimistic) layer of the cache during the update. Note that
-            // this.data could be a Layer if we are currently executing an optimistic
-            // update function, but otherwise will always be an EntityStore.Root
-            // instance.
-            perform(this.data);
-        }
-        else {
-            // Otherwise, leave this.data and this.optimisticData unchanged and run
-            // the update with broadcast batching.
-            perform();
-        }
-        if (typeof removeOptimistic === "string") {
-            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);
-        }
-        // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code
-        // takes the else branch and calls this.broadcastWatches(options), which
-        // does nothing when this.txCount > 0.
-        if (onWatchUpdated && alreadyDirty.size) {
-            this.broadcastWatches({
-                ...options,
-                onWatchUpdated(watch, diff) {
-                    const result = onWatchUpdated.call(this, watch, diff);
-                    if (result !== false) {
-                        // Since onWatchUpdated did not return false, this diff is
-                        // about to be broadcast to watch.callback, so we don't need
-                        // to re-dirty it with the other alreadyDirty watches below.
-                        alreadyDirty.delete(watch);
-                    }
-                    return result;
-                },
-            });
-            // Silently re-dirty any watches that were already dirty before the update
-            // was performed, and were not broadcast just now.
-            if (alreadyDirty.size) {
-                alreadyDirty.forEach((watch) => this.maybeBroadcastWatch.dirty(watch));
-            }
-        }
-        else {
-            // If alreadyDirty is empty or we don't have an onWatchUpdated
-            // function, we don't need to go to the trouble of wrapping
-            // options.onWatchUpdated.
-            this.broadcastWatches(options);
-        }
-        return updateResult;
-    }
-    performTransaction(update, optimisticId) {
-        return this.batch({
-            update,
-            optimistic: optimisticId || optimisticId !== null,
-        });
-    }
-    transformDocument(document) {
-        return this.addTypenameTransform.transformDocument(this.addFragmentsToDocument(document));
-    }
-    fragmentMatches(fragment, typename) {
-        return this.policies.fragmentMatches(fragment, typename);
-    }
-    lookupFragment(fragmentName) {
-        return this.config.fragments?.lookup(fragmentName) || null;
-    }
-    resolvesClientField(typename, fieldName) {
-        return !!this.policies.getReadFunction(typename, fieldName);
-    }
-    broadcastWatches(options) {
-        if (!this.txCount) {
-            const prevOnAfter = this.onAfterBroadcast;
-            const callbacks = new Set();
-            this.onAfterBroadcast = (cb) => {
-                callbacks.add(cb);
-            };
-            try {
-                this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));
-                callbacks.forEach((cb) => cb());
-            }
-            finally {
-                this.onAfterBroadcast = prevOnAfter;
-            }
-        }
-    }
-    addFragmentsToDocument(document) {
-        const { fragments } = this.config;
-        return fragments ? fragments.transform(document) : document;
-    }
-    // This method is wrapped by maybeBroadcastWatch, which is called by
-    // broadcastWatches, so that we compute and broadcast results only when
-    // the data that would be broadcast might have changed. It would be
-    // simpler to check for changes after recomputing a result but before
-    // broadcasting it, but this wrapping approach allows us to skip both
-    // the recomputation and the broadcast, in most cases.
-    broadcastWatch(c, options) {
-        const { lastDiff } = c;
-        // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions
-        // currently requires no additional properties, so we can use c (a
-        // WatchOptions object) as DiffOptions, without having to allocate a new
-        // object, and without having to enumerate the relevant properties (query,
-        // variables, etc.) explicitly. There will be some additional properties
-        // (lastDiff, callback, etc.), but cache.diff ignores them.
-        const diff = this.diff(c);
-        if (options) {
-            if (c.optimistic && typeof options.optimistic === "string") {
-                diff.fromOptimisticTransaction = true;
-            }
-            if (options.onWatchUpdated &&
-                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {
-                // Returning false from the onWatchUpdated callback will prevent
-                // calling c.callback(diff) for this watcher.
-                return;
-            }
-        }
-        if (!lastDiff || !equal(lastDiff.result, diff.result)) {
-            c.callback((c.lastDiff = diff), lastDiff);
-        }
-    }
-}
-
-export { InMemoryCache };
-//# sourceMappingURL=inMemoryCache.js.map

package/dist/esm/node_modules/@apollo/client/cache/inmemory/inMemoryCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inMemoryCache.js","sources":["../../../../../../../node_modules/@apollo/client/cache/inmemory/inMemoryCache.js"],"sourcesContent":["import { equal } from \"@wry/equality\";\nimport { wrap } from \"optimism\";\nimport { addTypenameToDocument, cacheSizes, canonicalStringify, DocumentTransform, isReference, print, } from \"@apollo/client/utilities\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { getInMemoryCacheMemoryInternals } from \"@apollo/client/utilities/internal\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { ApolloCache } from \"../core/cache.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { hasOwn, normalizeConfig } from \"./helpers.js\";\nimport { Policies } from \"./policies.js\";\nimport { forgetCache, makeVar, recallCache } from \"./reactiveVars.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nexport class InMemoryCache extends ApolloCache {\n    data;\n    optimisticData;\n    config;\n    watches = new Set();\n    storeReader;\n    storeWriter;\n    addTypenameTransform = new DocumentTransform(addTypenameToDocument);\n    maybeBroadcastWatch;\n    // Override the default value, since InMemoryCache result objects are frozen\n    // in development and expected to remain logically immutable in production.\n    assumeImmutableResults = true;\n    // Dynamically imported code can augment existing typePolicies or\n    // possibleTypes by calling cache.policies.addTypePolicies or\n    // cache.policies.addPossibletypes.\n    policies;\n    makeVar = makeVar;\n    constructor(config = {}) {\n        super();\n        this.config = normalizeConfig(config);\n        this.policies = new Policies({\n            cache: this,\n            dataIdFromObject: this.config.dataIdFromObject,\n            possibleTypes: this.config.possibleTypes,\n            typePolicies: this.config.typePolicies,\n        });\n        this.init();\n    }\n    init() {\n        // Passing { resultCaching: false } in the InMemoryCache constructor options\n        // will completely disable dependency tracking, which will improve memory\n        // usage but worsen the performance of repeated reads.\n        const rootStore = (this.data = new EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        }));\n        // When no optimistic writes are currently active, cache.optimisticData ===\n        // cache.data, so there are no additional layers on top of the actual data.\n        // When an optimistic update happens, this.optimisticData will become a\n        // linked list of EntityStore Layer objects that terminates with the\n        // original this.data cache object.\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    }\n    resetResultCache() {\n        const { fragments } = this.config;\n        this.addTypenameTransform.resetCache();\n        fragments?.resetCaches();\n        // The StoreWriter is mostly stateless and so doesn't really need to be\n        // reset, but it does need to have its writer.storeReader reference updated,\n        // so it's simpler to update this.storeWriter as well.\n        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({ cache: this, fragments })), fragments);\n        this.maybeBroadcastWatch = wrap((c, options) => {\n            return this.broadcastWatch(c, options);\n        }, {\n            max: cacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] ||\n                5000 /* defaultCacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] */,\n            makeCacheKey: (c) => {\n                // Return a cache key (thus enabling result caching) only if we're\n                // currently using a data store that can track cache dependencies.\n                const store = c.optimistic ? this.optimisticData : this.data;\n                if (supportsResultCaching(store)) {\n                    const { optimistic, id, variables } = c;\n                    return store.makeCacheKey(c.query, \n                    // Different watches can have the same query, optimistic\n                    // status, rootId, and variables, but if their callbacks are\n                    // different, the (identical) result needs to be delivered to\n                    // each distinct callback. The easiest way to achieve that\n                    // separation is to include c.callback in the cache key for\n                    // maybeBroadcastWatch calls. See issue #5733.\n                    c.callback, canonicalStringify({ optimistic, id, variables }));\n                }\n            },\n        });\n        // Since we have thrown away all the cached functions that depend on the\n        // CacheGroup dependencies maintained by EntityStore, we should also reset\n        // all CacheGroup dependency information.\n        new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());\n    }\n    restore(data) {\n        this.init();\n        // Since calling this.init() discards/replaces the entire StoreReader, along\n        // with the result caches it maintains, this.data.replace(data) won't have\n        // to bother deleting the old data.\n        if (data)\n            this.data.replace(data);\n        return this;\n    }\n    extract(optimistic = false) {\n        return (optimistic ? this.optimisticData : this.data).extract();\n    }\n    read(options) {\n        const { \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        returnPartialData = false, } = options;\n        return this.storeReader.diffQueryAgainstStore({\n            ...options,\n            store: options.optimistic ? this.optimisticData : this.data,\n            config: this.config,\n            returnPartialData,\n        }).result;\n    }\n    write(options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    }\n    modify(options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            // To my knowledge, TypeScript does not currently provide a way to\n            // enforce that an optional property?:type must *not* be undefined\n            // when present. That ability would be useful here, because we want\n            // options.id to default to ROOT_QUERY only when no options.id was\n            // provided. If the caller attempts to pass options.id with a\n            // falsy/undefined value (perhaps because cache.identify failed), we\n            // should not assume the goal was to modify the ROOT_QUERY object.\n            // We could throw, but it seems natural to return false to indicate\n            // that nothing was modified.\n            return false;\n        }\n        const store = ((options.optimistic) // Defaults to false.\n        ) ?\n            this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields, false);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    }\n    diff(options) {\n        return this.storeReader.diffQueryAgainstStore({\n            ...options,\n            store: options.optimistic ? this.optimisticData : this.data,\n            rootId: options.id || \"ROOT_QUERY\",\n            config: this.config,\n        });\n    }\n    watch(watch) {\n        if (!this.watches.size) {\n            // In case we previously called forgetCache(this) because\n            // this.watches became empty (see below), reattach this cache to any\n            // reactive variables on which it previously depended. It might seem\n            // paradoxical that we're able to recall something we supposedly\n            // forgot, but the point of calling forgetCache(this) is to silence\n            // useless broadcasts while this.watches is empty, and to allow the\n            // cache to be garbage collected. If, however, we manage to call\n            // recallCache(this) here, this cache object must not have been\n            // garbage collected yet, and should resume receiving updates from\n            // reactive variables, now that it has a watcher to notify.\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return () => {\n            // Once we remove the last watch from this.watches, cache.broadcastWatches\n            // no longer does anything, so we preemptively tell the reactive variable\n            // system to exclude this cache from future broadcasts.\n            if (this.watches.delete(watch) && !this.watches.size) {\n                forgetCache(this);\n            }\n            // Remove this watch from the LRU cache managed by the\n            // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory\n            // leaks involving the closure of watch.callback.\n            this.maybeBroadcastWatch.forget(watch);\n        };\n    }\n    gc(options) {\n        canonicalStringify.reset();\n        print.reset();\n        const ids = this.optimisticData.gc();\n        if (options && !this.txCount && options.resetResultCache) {\n            this.resetResultCache();\n        }\n        return ids;\n    }\n    // Call this method to ensure the given root ID remains in the cache after\n    // garbage collection, along with its transitive child entities. Note that\n    // the cache automatically retains all directly written entities. By default,\n    // the retainment persists after optimistic updates are removed. Pass true\n    // for the optimistic argument if you would prefer for the retainment to be\n    // discarded when the top-most optimistic layer is removed. Returns the\n    // resulting (non-negative) retainment count.\n    retain(rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    }\n    // Call this method to undo the effect of the retain method, above. Once the\n    // retainment count falls to zero, the given ID will no longer be preserved\n    // during garbage collection, though it may still be preserved by other safe\n    // entities that refer to it. Returns the resulting (non-negative) retainment\n    // count, in case that's useful.\n    release(rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    }\n    // Returns the canonical ID for a given StoreObject, obeying typePolicies\n    // and keyFields (and dataIdFromObject, if you still use that). At minimum,\n    // the object must contain a __typename and any primary key fields required\n    // to identify entities of that type. If you pass a query result object, be\n    // sure that none of the primary key fields have been renamed by aliasing.\n    // If you pass a Reference object, its __ref ID string will be returned.\n    identify(object) {\n        if (isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            __DEV__ && invariant.warn(e);\n        }\n    }\n    evict(options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                // See comment in modify method about why we return false when\n                // options.id exists but is falsy/undefined.\n                return false;\n            }\n            options = { ...options, id: \"ROOT_QUERY\" };\n        }\n        try {\n            // It's unlikely that the eviction will end up invoking any other\n            // cache update operations while it's running, but {in,de}crementing\n            // this.txCount still seems like a good idea, for uniformity with\n            // the other update methods.\n            ++this.txCount;\n            // Pass this.data as a limit on the depth of the eviction, so evictions\n            // during optimistic updates (when this.data is temporarily set equal to\n            // this.optimisticData) do not escape their optimistic Layer.\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    }\n    reset(options) {\n        this.init();\n        canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            // Similar to what happens in the unsubscribe function returned by\n            // cache.watch, applied to all current watches.\n            this.watches.forEach((watch) => this.maybeBroadcastWatch.forget(watch));\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            // Calling this.init() above unblocks all maybeBroadcastWatch caching, so\n            // this.broadcastWatches() triggers a broadcast to every current watcher\n            // (letting them know their data is now missing). This default behavior is\n            // convenient because it means the watches do not have to be manually\n            // reestablished after resetting the cache. To prevent this broadcast and\n            // cancel all watches, pass true for options.discardWatches.\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    }\n    removeOptimistic(idToRemove) {\n        const newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    }\n    txCount = 0;\n    /**\n    * Executes multiple cache operations as a single batch, ensuring that\n    * watchers are only notified once after all operations complete. This is\n    * useful for improving performance when making multiple cache updates, as it\n    * prevents unnecessary re-renders or query refetches between individual\n    * operations.\n    * \n    * The `batch` method supports both optimistic and non-optimistic updates, and\n    * provides fine-grained control over which cache layer receives the updates\n    * and when watchers are notified.\n    * \n    * For usage instructions, see [Interacting with cached data: `cache.batch`](https://www.apollographql.com/docs/react/caching/cache-interaction#using-cachebatch).\n    * \n    * @example\n    * \n    * ```js\n    * cache.batch({\n    *   update(cache) {\n    *     cache.writeQuery({\n    *       query: GET_TODOS,\n    *       data: { todos: updatedTodos },\n    *     });\n    *     cache.evict({ id: \"Todo:123\" });\n    *   },\n    * });\n    * ```\n    * \n    * @example\n    * \n    * ```js\n    * // Optimistic update with a custom layer ID\n    * cache.batch({\n    *   optimistic: \"add-todo-optimistic\",\n    *   update(cache) {\n    *     cache.modify({\n    *       fields: {\n    *         todos(existing = []) {\n    *           return [...existing, newTodoRef];\n    *         },\n    *       },\n    *     });\n    *   },\n    * });\n    * ```\n    * \n    * @returns The return value of the `update` function.\n    */\n    batch(options) {\n        const { update, optimistic = true, removeOptimistic, onWatchUpdated, } = options;\n        let updateResult;\n        const perform = (layer) => {\n            const { data, optimisticData } = this;\n            ++this.txCount;\n            if (layer) {\n                this.data = this.optimisticData = layer;\n            }\n            try {\n                return (updateResult = update(this));\n            }\n            finally {\n                --this.txCount;\n                this.data = data;\n                this.optimisticData = optimisticData;\n            }\n        };\n        const alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            // If an options.onWatchUpdated callback is provided, we want to call it\n            // with only the Cache.WatchOptions objects affected by options.update,\n            // but there might be dirty watchers already waiting to be broadcast that\n            // have nothing to do with the update. To prevent including those watchers\n            // in the post-update broadcast, we perform this initial broadcast to\n            // collect the dirty watchers, so we can re-dirty them later, after the\n            // post-update broadcast, allowing them to receive their pending\n            // broadcasts the next time broadcastWatches is called, just as they would\n            // if we never called cache.batch.\n            this.broadcastWatches({\n                ...options,\n                onWatchUpdated(watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                },\n            });\n        }\n        if (typeof optimistic === \"string\") {\n            // Note that there can be multiple layers with the same optimistic ID.\n            // When removeOptimistic(id) is called for that id, all matching layers\n            // will be removed, and the remaining layers will be reapplied.\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            // Ensure both this.data and this.optimisticData refer to the root\n            // (non-optimistic) layer of the cache during the update. Note that\n            // this.data could be a Layer if we are currently executing an optimistic\n            // update function, but otherwise will always be an EntityStore.Root\n            // instance.\n            perform(this.data);\n        }\n        else {\n            // Otherwise, leave this.data and this.optimisticData unchanged and run\n            // the update with broadcast batching.\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code\n        // takes the else branch and calls this.broadcastWatches(options), which\n        // does nothing when this.txCount > 0.\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches({\n                ...options,\n                onWatchUpdated(watch, diff) {\n                    const result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        // Since onWatchUpdated did not return false, this diff is\n                        // about to be broadcast to watch.callback, so we don't need\n                        // to re-dirty it with the other alreadyDirty watches below.\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                },\n            });\n            // Silently re-dirty any watches that were already dirty before the update\n            // was performed, and were not broadcast just now.\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach((watch) => this.maybeBroadcastWatch.dirty(watch));\n            }\n        }\n        else {\n            // If alreadyDirty is empty or we don't have an onWatchUpdated\n            // function, we don't need to go to the trouble of wrapping\n            // options.onWatchUpdated.\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    }\n    performTransaction(update, optimisticId) {\n        return this.batch({\n            update,\n            optimistic: optimisticId || optimisticId !== null,\n        });\n    }\n    transformDocument(document) {\n        return this.addTypenameTransform.transformDocument(this.addFragmentsToDocument(document));\n    }\n    fragmentMatches(fragment, typename) {\n        return this.policies.fragmentMatches(fragment, typename);\n    }\n    lookupFragment(fragmentName) {\n        return this.config.fragments?.lookup(fragmentName) || null;\n    }\n    resolvesClientField(typename, fieldName) {\n        return !!this.policies.getReadFunction(typename, fieldName);\n    }\n    broadcastWatches(options) {\n        if (!this.txCount) {\n            const prevOnAfter = this.onAfterBroadcast;\n            const callbacks = new Set();\n            this.onAfterBroadcast = (cb) => {\n                callbacks.add(cb);\n            };\n            try {\n                this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));\n                callbacks.forEach((cb) => cb());\n            }\n            finally {\n                this.onAfterBroadcast = prevOnAfter;\n            }\n        }\n    }\n    addFragmentsToDocument(document) {\n        const { fragments } = this.config;\n        return fragments ? fragments.transform(document) : document;\n    }\n    // This method is wrapped by maybeBroadcastWatch, which is called by\n    // broadcastWatches, so that we compute and broadcast results only when\n    // the data that would be broadcast might have changed. It would be\n    // simpler to check for changes after recomputing a result but before\n    // broadcasting it, but this wrapping approach allows us to skip both\n    // the recomputation and the broadcast, in most cases.\n    broadcastWatch(c, options) {\n        const { lastDiff } = c;\n        // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions\n        // currently requires no additional properties, so we can use c (a\n        // WatchOptions object) as DiffOptions, without having to allocate a new\n        // object, and without having to enumerate the relevant properties (query,\n        // variables, etc.) explicitly. There will be some additional properties\n        // (lastDiff, callback, etc.), but cache.diff ignores them.\n        const diff = this.diff(c);\n        if (options) {\n            if (c.optimistic && typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                // Returning false from the onWatchUpdated callback will prevent\n                // calling c.callback(diff) for this watcher.\n                return;\n            }\n        }\n        if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n            c.callback((c.lastDiff = diff), lastDiff);\n        }\n    }\n}\nif (__DEV__) {\n    InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;\n}\n//# sourceMappingURL=inMemoryCache.js.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}