react-easy-wall 2.0.0 → 2.0.3

package/dist/cjs/node_modules/@apollo/client/cache/inmemory/writeToStore.cjs

@@ -0,0 +1,514 @@
+'use strict';
+
+var index$1 = require('../../../../@wry/trie/lib/index.cjs');
+var storeUtils = require('../../utilities/graphql/storeUtils.cjs');
+var index = require('../../utilities/invariant/index.cjs');
+var helpers = require('./helpers.cjs');
+var policies = require('./policies.cjs');
+var kinds = require('../../../../graphql/language/kinds.cjs');
+var getOperationDefinition = require('../../utilities/internal/getOperationDefinition.cjs');
+var getDefaultValues = require('../../utilities/internal/getDefaultValues.cjs');
+var canonicalStringify = require('../../utilities/internal/canonicalStringify.cjs');
+var resultKeyNameFromField = require('../../utilities/internal/resultKeyNameFromField.cjs');
+var hasDirectives = require('../../utilities/internal/hasDirectives.cjs');
+var constants = require('../../utilities/internal/constants.cjs');
+var isArray = require('../../utilities/internal/isArray.cjs');
+var shouldInclude = require('../../utilities/internal/shouldInclude.cjs');
+var isNonEmptyArray = require('../../utilities/internal/isNonEmptyArray.cjs');
+var argumentsObjectFromField = require('../../utilities/internal/argumentsObjectFromField.cjs');
+var isField = require('../../utilities/internal/isField.cjs');
+var getFragmentFromSelection = require('../../utilities/internal/getFragmentFromSelection.cjs');
+var makeReference = require('../../utilities/internal/makeReference.cjs');
+
+// Since there are only four possible combinations of context.clientOnly and
+// context.deferred values, we should need at most four "flavors" of any given
+// WriteContext. To avoid creating multiple copies of the same context, we cache
+// the contexts in the context.flavors Map (shared by all flavors) according to
+// their clientOnly and deferred values (always in that order).
+function getContextFlavor(context, clientOnly, deferred) {
+    const key = `${clientOnly}${deferred}`;
+    let flavored = context.flavors.get(key);
+    if (!flavored) {
+        context.flavors.set(key, (flavored =
+            context.clientOnly === clientOnly && context.deferred === deferred ?
+                context
+                : {
+                    ...context,
+                    clientOnly,
+                    deferred,
+                }));
+    }
+    return flavored;
+}
+class StoreWriter {
+    cache;
+    reader;
+    fragments;
+    constructor(cache, reader, fragments) {
+        this.cache = cache;
+        this.reader = reader;
+        this.fragments = fragments;
+    }
+    writeToStore(store, { query, result, dataId, variables, overwrite, extensions, }) {
+        const operationDefinition = getOperationDefinition.getOperationDefinition(query);
+        const merger = helpers.makeProcessedFieldsMerger();
+        variables = {
+            ...getDefaultValues.getDefaultValues(operationDefinition),
+            ...variables,
+        };
+        const context = {
+            store,
+            written: {},
+            merge(existing, incoming) {
+                return merger.merge(existing, incoming);
+            },
+            variables: variables,
+            varString: canonicalStringify.canonicalStringify(variables),
+            ...helpers.extractFragmentContext(query, this.fragments),
+            overwrite: !!overwrite,
+            incomingById: new Map(),
+            clientOnly: false,
+            deferred: false,
+            flavors: new Map(),
+            extensions,
+        };
+        const ref = this.processSelectionSet({
+            result: result || {},
+            dataId,
+            selectionSet: operationDefinition.selectionSet,
+            mergeTree: { map: new Map() },
+            context,
+            path: [],
+        });
+        if (!storeUtils.isReference(ref)) {
+            throw index.newInvariantError(109, result);
+        }
+        // So far, the store has not been modified, so now it's time to process
+        // context.incomingById and merge those incoming fields into context.store.
+        context.incomingById.forEach(({ storeObject, mergeTree, fieldNodeSet }, dataId) => {
+            const entityRef = makeReference.makeReference(dataId);
+            if (mergeTree && mergeTree.map.size) {
+                const applied = this.applyMerges(mergeTree, entityRef, storeObject, context);
+                if (storeUtils.isReference(applied)) {
+                    // Assume References returned by applyMerges have already been merged
+                    // into the store. See makeMergeObjectsFunction in policies.ts for an
+                    // example of how this can happen.
+                    return;
+                }
+                // Otherwise, applyMerges returned a StoreObject, whose fields we should
+                // merge into the store (see store.merge statement below).
+                storeObject = applied;
+            }
+            store.merge(dataId, storeObject);
+        });
+        // Any IDs written explicitly to the cache will be retained as
+        // reachable root IDs for garbage collection purposes. Although this
+        // logic includes root IDs like ROOT_QUERY and ROOT_MUTATION, their
+        // retainment counts are effectively ignored because cache.gc() always
+        // includes them in its root ID set.
+        store.retain(ref.__ref);
+        return ref;
+    }
+    processSelectionSet({ dataId, result, selectionSet, context, 
+    // This object allows processSelectionSet to report useful information
+    // to its callers without explicitly returning that information.
+    mergeTree, path: currentPath, }) {
+        const { policies: policies$1 } = this.cache;
+        // This variable will be repeatedly updated using context.merge to
+        // accumulate all fields that need to be written into the store.
+        let incoming = {};
+        // If typename was not passed in, infer it. Note that typename is
+        // always passed in for tricky-to-infer cases such as "Query" for
+        // ROOT_QUERY.
+        const typename = (dataId && policies$1.rootTypenamesById[dataId]) ||
+            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
+            (dataId && context.store.get(dataId, "__typename"));
+        if ("string" === typeof typename) {
+            incoming.__typename = typename;
+        }
+        // This readField function will be passed as context.readField in the
+        // KeyFieldsContext object created within policies.identify (called below).
+        // In addition to reading from the existing context.store (thanks to the
+        // policies.readField(options, context) line at the very bottom), this
+        // version of readField can read from Reference objects that are currently
+        // pending in context.incomingById, which is important whenever keyFields
+        // need to be extracted from a child object that processSelectionSet has
+        // turned into a Reference.
+        const readField = (...args) => {
+            const options = policies.normalizeReadFieldOptions(args, incoming, context.variables);
+            if (storeUtils.isReference(options.from)) {
+                const info = context.incomingById.get(options.from.__ref);
+                if (info) {
+                    const result = policies$1.readField({
+                        ...options,
+                        from: info.storeObject,
+                    }, context);
+                    if (result !== void 0) {
+                        return result;
+                    }
+                }
+            }
+            return policies$1.readField(options, context);
+        };
+        const fieldNodeSet = new Set();
+        this.flattenFields(selectionSet, result, 
+        // This WriteContext will be the default context value for fields returned
+        // by the flattenFields method, but some fields may be assigned a modified
+        // context, depending on the presence of @client and other directives.
+        context, typename).forEach((context, field) => {
+            const resultFieldKey = resultKeyNameFromField.resultKeyNameFromField(field);
+            const value = result[resultFieldKey];
+            const path = [...currentPath, field.name.value];
+            fieldNodeSet.add(field);
+            if (value !== void 0) {
+                const storeFieldName = policies$1.getStoreFieldName({
+                    typename,
+                    fieldName: field.name.value,
+                    field,
+                    variables: context.variables,
+                });
+                const childTree = getChildMergeTree(mergeTree, storeFieldName);
+                let incomingValue = this.processFieldValue(value, field, 
+                // Reset context.clientOnly and context.deferred to their default
+                // values before processing nested selection sets.
+                field.selectionSet ?
+                    getContextFlavor(context, false, false)
+                    : context, childTree, path);
+                // To determine if this field holds a child object with a merge function
+                // defined in its type policy (see PR #7070), we need to figure out the
+                // child object's __typename.
+                let childTypename;
+                // The field's value can be an object that has a __typename only if the
+                // field has a selection set. Otherwise incomingValue is scalar.
+                if (field.selectionSet &&
+                    (storeUtils.isReference(incomingValue) || helpers.storeValueIsStoreObject(incomingValue))) {
+                    childTypename = readField("__typename", incomingValue);
+                }
+                const merge = policies$1.getMergeFunction(typename, field.name.value, childTypename);
+                if (merge) {
+                    childTree.info = {
+                        // TODO Check compatibility against any existing childTree.field?
+                        field,
+                        typename,
+                        merge,
+                        path,
+                    };
+                }
+                else if (hasDirectives.hasDirectives(["stream"], field) &&
+                    Array.isArray(incomingValue) &&
+                    context.extensions?.[constants.streamInfoSymbol]) {
+                    childTree.info = {
+                        field,
+                        typename,
+                        merge: policies.defaultStreamFieldMergeFn,
+                        path,
+                    };
+                }
+                else {
+                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);
+                }
+                incoming = context.merge(incoming, {
+                    [storeFieldName]: incomingValue,
+                });
+            }
+        });
+        // Identify the result object, even if dataId was already provided,
+        // since we always need keyObject below.
+        try {
+            const [id, keyObject] = policies$1.identify(result, {
+                typename,
+                selectionSet,
+                fragmentMap: context.fragmentMap,
+                storeObject: incoming,
+                readField,
+            });
+            // If dataId was not provided, fall back to the id just generated by
+            // policies.identify.
+            dataId = dataId || id;
+            // Write any key fields that were used during identification, even if
+            // they were not mentioned in the original query.
+            if (keyObject) {
+                // TODO Reverse the order of the arguments?
+                incoming = context.merge(incoming, keyObject);
+            }
+        }
+        catch (e) {
+            // If dataId was provided, tolerate failure of policies.identify.
+            if (!dataId)
+                throw e;
+        }
+        if ("string" === typeof dataId) {
+            const dataRef = makeReference.makeReference(dataId);
+            // Avoid processing the same entity object using the same selection
+            // set more than once. We use an array instead of a Set since most
+            // entity IDs will be written using only one selection set, so the
+            // size of this array is likely to be very small, meaning indexOf is
+            // likely to be faster than Set.prototype.has.
+            const sets = context.written[dataId] || (context.written[dataId] = []);
+            if (sets.indexOf(selectionSet) >= 0)
+                return dataRef;
+            sets.push(selectionSet);
+            // If we're about to write a result object into the store, but we
+            // happen to know that the exact same (===) result object would be
+            // returned if we were to reread the result with the same inputs,
+            // then we can skip the rest of the processSelectionSet work for
+            // this object, and immediately return a Reference to it.
+            if (this.reader &&
+                this.reader.isFresh(result, dataRef, selectionSet, context)) {
+                return dataRef;
+            }
+            const previous = context.incomingById.get(dataId);
+            if (previous) {
+                previous.storeObject = context.merge(previous.storeObject, incoming);
+                previous.mergeTree = mergeMergeTrees(previous.mergeTree, mergeTree);
+                fieldNodeSet.forEach((field) => previous.fieldNodeSet.add(field));
+            }
+            else {
+                context.incomingById.set(dataId, {
+                    storeObject: incoming,
+                    // Save a reference to mergeTree only if it is not empty, because
+                    // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and
+                    // reused for entirely different parts of the result tree.
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
+                    fieldNodeSet,
+                });
+            }
+            return dataRef;
+        }
+        return incoming;
+    }
+    processFieldValue(value, field, context, mergeTree, path) {
+        if (!field.selectionSet || value === null) {
+            // In development, we need to clone scalar values so that they can be
+            // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,
+            // it's cheaper to store the scalar values directly in the cache.
+            return value;
+        }
+        if (isArray.isArray(value)) {
+            return value.map((item, i) => {
+                const value = this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i), [...path, i]);
+                maybeRecycleChildMergeTree(mergeTree, i);
+                return value;
+            });
+        }
+        return this.processSelectionSet({
+            result: value,
+            selectionSet: field.selectionSet,
+            context,
+            mergeTree,
+            path,
+        });
+    }
+    // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with
+    // some additions for tracking @client and @defer directives.
+    flattenFields(selectionSet, result, context, typename = getTypenameFromResult(result, selectionSet, context.fragmentMap)) {
+        const fieldMap = new Map();
+        const { policies } = this.cache;
+        const limitingTrie = new index$1.Trie(false); // No need for WeakMap, since limitingTrie does not escape.
+        (function flatten(selectionSet, inheritedContext) {
+            const visitedNode = limitingTrie.lookup(selectionSet, 
+            // Because we take inheritedClientOnly and inheritedDeferred into
+            // consideration here (in addition to selectionSet), it's possible for
+            // the same selection set to be flattened more than once, if it appears
+            // in the query with different @client and/or @directive configurations.
+            inheritedContext.clientOnly, inheritedContext.deferred);
+            if (visitedNode.visited)
+                return;
+            visitedNode.visited = true;
+            selectionSet.selections.forEach((selection) => {
+                if (!shouldInclude.shouldInclude(selection, context.variables))
+                    return;
+                let { clientOnly, deferred } = inheritedContext;
+                if (
+                // Since the presence of @client or @defer on this field can only
+                // cause clientOnly or deferred to become true, we can skip the
+                // forEach loop if both clientOnly and deferred are already true.
+                !(clientOnly && deferred) &&
+                    isNonEmptyArray.isNonEmptyArray(selection.directives)) {
+                    selection.directives.forEach((dir) => {
+                        const name = dir.name.value;
+                        if (name === "client")
+                            clientOnly = true;
+                        if (name === "defer") {
+                            const args = argumentsObjectFromField.argumentsObjectFromField(dir, context.variables);
+                            // The @defer directive takes an optional args.if boolean
+                            // argument, similar to @include(if: boolean). Note that
+                            // @defer(if: false) does not make context.deferred false, but
+                            // instead behaves as if there was no @defer directive.
+                            if (!args || args.if !== false) {
+                                deferred = true;
+                            }
+                            // TODO In the future, we may want to record args.label using
+                            // context.deferred, if a label is specified.
+                        }
+                    });
+                }
+                if (isField.isField(selection)) {
+                    const existing = fieldMap.get(selection);
+                    if (existing) {
+                        // If this field has been visited along another recursive path
+                        // before, the final context should have clientOnly or deferred set
+                        // to true only if *all* paths have the directive (hence the &&).
+                        clientOnly = clientOnly && existing.clientOnly;
+                        deferred = deferred && existing.deferred;
+                    }
+                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
+                }
+                else {
+                    const fragment = getFragmentFromSelection.getFragmentFromSelection(selection, context.lookupFragment);
+                    if (!fragment && selection.kind === kinds.Kind.FRAGMENT_SPREAD) {
+                        throw index.newInvariantError(111, selection.name.value);
+                    }
+                    if (fragment &&
+                        policies.fragmentMatches(fragment, typename, result, context.variables)) {
+                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
+                    }
+                }
+            });
+        })(selectionSet, context);
+        return fieldMap;
+    }
+    applyMerges(mergeTree, existing, incoming, context, getStorageArgs) {
+        if (mergeTree.map.size && !storeUtils.isReference(incoming)) {
+            const e = 
+            // Items in the same position in different arrays are not
+            // necessarily related to each other, so when incoming is an array
+            // we process its elements as if there was no existing data.
+            (!isArray.isArray(incoming) &&
+                // Likewise, existing must be either a Reference or a StoreObject
+                // in order for its fields to be safe to merge with the fields of
+                // the incoming object.
+                (storeUtils.isReference(existing) || helpers.storeValueIsStoreObject(existing))) ?
+                existing
+                : void 0;
+            // This narrowing is implied by mergeTree.map.size > 0 and
+            // !isReference(incoming), though TypeScript understandably cannot
+            // hope to infer this type.
+            const i = incoming;
+            // The options.storage objects provided to read and merge functions
+            // are derived from the identity of the parent object plus a
+            // sequence of storeFieldName strings/numbers identifying the nested
+            // field name path of each field value to be merged.
+            if (e && !getStorageArgs) {
+                getStorageArgs = [storeUtils.isReference(e) ? e.__ref : e];
+            }
+            // It's possible that applying merge functions to this subtree will
+            // not change the incoming data, so this variable tracks the fields
+            // that did change, so we can create a new incoming object when (and
+            // only when) at least one incoming field has changed. We use a Map
+            // to preserve the type of numeric keys.
+            let changedFields;
+            const getValue = (from, name) => {
+                return (isArray.isArray(from) ?
+                    typeof name === "number" ?
+                        from[name]
+                        : void 0
+                    : context.store.getFieldValue(from, String(name)));
+            };
+            mergeTree.map.forEach((childTree, storeFieldName) => {
+                const eVal = getValue(e, storeFieldName);
+                const iVal = getValue(i, storeFieldName);
+                // If we have no incoming data, leave any existing data untouched.
+                if (void 0 === iVal)
+                    return;
+                if (getStorageArgs) {
+                    getStorageArgs.push(storeFieldName);
+                }
+                const aVal = this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
+                if (aVal !== iVal) {
+                    changedFields = changedFields || new Map();
+                    changedFields.set(storeFieldName, aVal);
+                }
+                if (getStorageArgs) {
+                    index.invariant(getStorageArgs.pop() === storeFieldName);
+                }
+            });
+            if (changedFields) {
+                // Shallow clone i so we can add changed fields to it.
+                incoming = (isArray.isArray(i) ? i.slice(0) : { ...i });
+                changedFields.forEach((value, name) => {
+                    incoming[name] = value;
+                });
+            }
+        }
+        if (mergeTree.info) {
+            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && context.store.getStorage(...getStorageArgs));
+        }
+        return incoming;
+    }
+}
+const emptyMergeTreePool = [];
+function getChildMergeTree({ map }, name) {
+    if (!map.has(name)) {
+        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });
+    }
+    return map.get(name);
+}
+function mergeMergeTrees(left, right) {
+    if (left === right || !right || mergeTreeIsEmpty(right))
+        return left;
+    if (!left || mergeTreeIsEmpty(left))
+        return right;
+    const info = left.info && right.info ?
+        {
+            ...left.info,
+            ...right.info,
+        }
+        : left.info || right.info;
+    const needToMergeMaps = left.map.size && right.map.size;
+    const map = needToMergeMaps ? new Map()
+        : left.map.size ? left.map
+            : right.map;
+    const merged = { info, map };
+    if (needToMergeMaps) {
+        const remainingRightKeys = new Set(right.map.keys());
+        left.map.forEach((leftTree, key) => {
+            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
+            remainingRightKeys.delete(key);
+        });
+        remainingRightKeys.forEach((key) => {
+            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
+        });
+    }
+    return merged;
+}
+function mergeTreeIsEmpty(tree) {
+    return !tree || !(tree.info || tree.map.size);
+}
+function maybeRecycleChildMergeTree({ map }, name) {
+    const childTree = map.get(name);
+    if (childTree && mergeTreeIsEmpty(childTree)) {
+        emptyMergeTreePool.push(childTree);
+        map.delete(name);
+    }
+}
+function getTypenameFromResult(result, selectionSet, fragmentMap) {
+    let fragments;
+    for (const selection of selectionSet.selections) {
+        if (isField.isField(selection)) {
+            if (selection.name.value === "__typename") {
+                return result[resultKeyNameFromField.resultKeyNameFromField(selection)];
+            }
+        }
+        else if (fragments) {
+            fragments.push(selection);
+        }
+        else {
+            fragments = [selection];
+        }
+    }
+    if (typeof result.__typename === "string") {
+        return result.__typename;
+    }
+    if (fragments) {
+        for (const selection of fragments) {
+            const typename = getTypenameFromResult(result, getFragmentFromSelection.getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);
+            if (typeof typename === "string") {
+                return typename;
+            }
+        }
+    }
+}
+
+exports.StoreWriter = StoreWriter;
+//# sourceMappingURL=writeToStore.cjs.map

package/dist/cjs/node_modules/@apollo/client/cache/inmemory/writeToStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeToStore.cjs","sources":["../../../../../../../node_modules/@apollo/client/cache/inmemory/writeToStore.js"],"sourcesContent":["import { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { Kind } from \"graphql\";\nimport { addTypenameToDocument, canonicalStringify, isReference, } from \"@apollo/client/utilities\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { argumentsObjectFromField, cloneDeep, getDefaultValues, getFragmentFromSelection, getOperationDefinition, hasDirectives, isArray, isField, isNonEmptyArray, makeReference, resultKeyNameFromField, shouldInclude, streamInfoSymbol, } from \"@apollo/client/utilities/internal\";\nimport { invariant, newInvariantError, } from \"@apollo/client/utilities/invariant\";\nimport { extractFragmentContext, fieldNameFromStoreName, makeProcessedFieldsMerger, storeValueIsStoreObject, } from \"./helpers.js\";\nimport { defaultStreamFieldMergeFn, normalizeReadFieldOptions, } from \"./policies.js\";\n// Since there are only four possible combinations of context.clientOnly and\n// context.deferred values, we should need at most four \"flavors\" of any given\n// WriteContext. To avoid creating multiple copies of the same context, we cache\n// the contexts in the context.flavors Map (shared by all flavors) according to\n// their clientOnly and deferred values (always in that order).\nfunction getContextFlavor(context, clientOnly, deferred) {\n    const key = `${clientOnly}${deferred}`;\n    let flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, (flavored =\n            context.clientOnly === clientOnly && context.deferred === deferred ?\n                context\n                : {\n                    ...context,\n                    clientOnly,\n                    deferred,\n                }));\n    }\n    return flavored;\n}\nexport class StoreWriter {\n    cache;\n    reader;\n    fragments;\n    constructor(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    writeToStore(store, { query, result, dataId, variables, overwrite, extensions, }) {\n        const operationDefinition = getOperationDefinition(query);\n        const merger = makeProcessedFieldsMerger();\n        variables = {\n            ...getDefaultValues(operationDefinition),\n            ...variables,\n        };\n        const context = {\n            store,\n            written: {},\n            merge(existing, incoming) {\n                return merger.merge(existing, incoming);\n            },\n            variables: variables,\n            varString: canonicalStringify(variables),\n            ...extractFragmentContext(query, this.fragments),\n            overwrite: !!overwrite,\n            incomingById: new Map(),\n            clientOnly: false,\n            deferred: false,\n            flavors: new Map(),\n            extensions,\n        };\n        const ref = this.processSelectionSet({\n            result: result || {},\n            dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map() },\n            context,\n            path: [],\n        });\n        if (!isReference(ref)) {\n            throw newInvariantError(109, result);\n        }\n        // So far, the store has not been modified, so now it's time to process\n        // context.incomingById and merge those incoming fields into context.store.\n        context.incomingById.forEach(({ storeObject, mergeTree, fieldNodeSet }, dataId) => {\n            const entityRef = makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                const applied = this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (isReference(applied)) {\n                    // Assume References returned by applyMerges have already been merged\n                    // into the store. See makeMergeObjectsFunction in policies.ts for an\n                    // example of how this can happen.\n                    return;\n                }\n                // Otherwise, applyMerges returned a StoreObject, whose fields we should\n                // merge into the store (see store.merge statement below).\n                storeObject = applied;\n            }\n            if (__DEV__ && !context.overwrite) {\n                const fieldsWithSelectionSets = {};\n                fieldNodeSet.forEach((field) => {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets[field.name.value] = true;\n                    }\n                });\n                const hasSelectionSet = (storeFieldName) => fieldsWithSelectionSets[fieldNameFromStoreName(storeFieldName)] ===\n                    true;\n                const hasMergeFunction = (storeFieldName) => {\n                    const childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach((storeFieldName) => {\n                    // If a merge function was defined for this field, trust that it\n                    // did the right thing about (not) clobbering data. If the field\n                    // has no selection set, it's a scalar field, so it doesn't need\n                    // a merge function (even if it's an object, like JSON data).\n                    if (hasSelectionSet(storeFieldName) &&\n                        !hasMergeFunction(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        // Any IDs written explicitly to the cache will be retained as\n        // reachable root IDs for garbage collection purposes. Although this\n        // logic includes root IDs like ROOT_QUERY and ROOT_MUTATION, their\n        // retainment counts are effectively ignored because cache.gc() always\n        // includes them in its root ID set.\n        store.retain(ref.__ref);\n        return ref;\n    }\n    processSelectionSet({ dataId, result, selectionSet, context, \n    // This object allows processSelectionSet to report useful information\n    // to its callers without explicitly returning that information.\n    mergeTree, path: currentPath, }) {\n        const { policies } = this.cache;\n        // This variable will be repeatedly updated using context.merge to\n        // accumulate all fields that need to be written into the store.\n        let incoming = {};\n        // If typename was not passed in, infer it. Note that typename is\n        // always passed in for tricky-to-infer cases such as \"Query\" for\n        // ROOT_QUERY.\n        const typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        // This readField function will be passed as context.readField in the\n        // KeyFieldsContext object created within policies.identify (called below).\n        // In addition to reading from the existing context.store (thanks to the\n        // policies.readField(options, context) line at the very bottom), this\n        // version of readField can read from Reference objects that are currently\n        // pending in context.incomingById, which is important whenever keyFields\n        // need to be extracted from a child object that processSelectionSet has\n        // turned into a Reference.\n        const readField = (...args) => {\n            const options = normalizeReadFieldOptions(args, incoming, context.variables);\n            if (isReference(options.from)) {\n                const info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    const result = policies.readField({\n                        ...options,\n                        from: info.storeObject,\n                    }, context);\n                    if (result !== void 0) {\n                        return result;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        const fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result, \n        // This WriteContext will be the default context value for fields returned\n        // by the flattenFields method, but some fields may be assigned a modified\n        // context, depending on the presence of @client and other directives.\n        context, typename).forEach((context, field) => {\n            const resultFieldKey = resultKeyNameFromField(field);\n            const value = result[resultFieldKey];\n            const path = [...currentPath, field.name.value];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                const storeFieldName = policies.getStoreFieldName({\n                    typename,\n                    fieldName: field.name.value,\n                    field,\n                    variables: context.variables,\n                });\n                const childTree = getChildMergeTree(mergeTree, storeFieldName);\n                let incomingValue = this.processFieldValue(value, field, \n                // Reset context.clientOnly and context.deferred to their default\n                // values before processing nested selection sets.\n                field.selectionSet ?\n                    getContextFlavor(context, false, false)\n                    : context, childTree, path);\n                // To determine if this field holds a child object with a merge function\n                // defined in its type policy (see PR #7070), we need to figure out the\n                // child object's __typename.\n                let childTypename;\n                // The field's value can be an object that has a __typename only if the\n                // field has a selection set. Otherwise incomingValue is scalar.\n                if (field.selectionSet &&\n                    (isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                const merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        // TODO Check compatibility against any existing childTree.field?\n                        field,\n                        typename,\n                        merge,\n                        path,\n                    };\n                }\n                else if (hasDirectives([\"stream\"], field) &&\n                    Array.isArray(incomingValue) &&\n                    context.extensions?.[streamInfoSymbol]) {\n                    childTree.info = {\n                        field,\n                        typename,\n                        merge: defaultStreamFieldMergeFn,\n                        path,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, {\n                    [storeFieldName]: incomingValue,\n                });\n            }\n            else if (__DEV__ &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !addTypenameToDocument.added(field) &&\n                // If the field has a read function, it may be a synthetic field or\n                // provide a default value, so its absence from the written data should\n                // not be cause for alarm.\n                !policies.getReadFunction(typename, field.name.value)) {\n                invariant.error(110, resultKeyNameFromField(field), result);\n            }\n        });\n        // Identify the result object, even if dataId was already provided,\n        // since we always need keyObject below.\n        try {\n            const [id, keyObject] = policies.identify(result, {\n                typename,\n                selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField,\n            });\n            // If dataId was not provided, fall back to the id just generated by\n            // policies.identify.\n            dataId = dataId || id;\n            // Write any key fields that were used during identification, even if\n            // they were not mentioned in the original query.\n            if (keyObject) {\n                // TODO Reverse the order of the arguments?\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            // If dataId was provided, tolerate failure of policies.identify.\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            const dataRef = makeReference(dataId);\n            // Avoid processing the same entity object using the same selection\n            // set more than once. We use an array instead of a Set since most\n            // entity IDs will be written using only one selection set, so the\n            // size of this array is likely to be very small, meaning indexOf is\n            // likely to be faster than Set.prototype.has.\n            const sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            // If we're about to write a result object into the store, but we\n            // happen to know that the exact same (===) result object would be\n            // returned if we were to reread the result with the same inputs,\n            // then we can skip the rest of the processSelectionSet work for\n            // this object, and immediately return a Reference to it.\n            if (this.reader &&\n                this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            const previous = context.incomingById.get(dataId);\n            if (previous) {\n                previous.storeObject = context.merge(previous.storeObject, incoming);\n                previous.mergeTree = mergeMergeTrees(previous.mergeTree, mergeTree);\n                fieldNodeSet.forEach((field) => previous.fieldNodeSet.add(field));\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    // Save a reference to mergeTree only if it is not empty, because\n                    // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and\n                    // reused for entirely different parts of the result tree.\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    }\n    processFieldValue(value, field, context, mergeTree, path) {\n        if (!field.selectionSet || value === null) {\n            // In development, we need to clone scalar values so that they can be\n            // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,\n            // it's cheaper to store the scalar values directly in the cache.\n            return __DEV__ ? cloneDeep(value) : value;\n        }\n        if (isArray(value)) {\n            return value.map((item, i) => {\n                const value = this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i), [...path, i]);\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context,\n            mergeTree,\n            path,\n        });\n    }\n    // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with\n    // some additions for tracking @client and @defer directives.\n    flattenFields(selectionSet, result, context, typename = getTypenameFromResult(result, selectionSet, context.fragmentMap)) {\n        const fieldMap = new Map();\n        const { policies } = this.cache;\n        const limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.\n        (function flatten(selectionSet, inheritedContext) {\n            const visitedNode = limitingTrie.lookup(selectionSet, \n            // Because we take inheritedClientOnly and inheritedDeferred into\n            // consideration here (in addition to selectionSet), it's possible for\n            // the same selection set to be flattened more than once, if it appears\n            // in the query with different @client and/or @directive configurations.\n            inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach((selection) => {\n                if (!shouldInclude(selection, context.variables))\n                    return;\n                let { clientOnly, deferred } = inheritedContext;\n                if (\n                // Since the presence of @client or @defer on this field can only\n                // cause clientOnly or deferred to become true, we can skip the\n                // forEach loop if both clientOnly and deferred are already true.\n                !(clientOnly && deferred) &&\n                    isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach((dir) => {\n                        const name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            const args = argumentsObjectFromField(dir, context.variables);\n                            // The @defer directive takes an optional args.if boolean\n                            // argument, similar to @include(if: boolean). Note that\n                            // @defer(if: false) does not make context.deferred false, but\n                            // instead behaves as if there was no @defer directive.\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                            // TODO In the future, we may want to record args.label using\n                            // context.deferred, if a label is specified.\n                        }\n                    });\n                }\n                if (isField(selection)) {\n                    const existing = fieldMap.get(selection);\n                    if (existing) {\n                        // If this field has been visited along another recursive path\n                        // before, the final context should have clientOnly or deferred set\n                        // to true only if *all* paths have the directive (hence the &&).\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    const fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                        throw newInvariantError(111, selection.name.value);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    }\n    applyMerges(mergeTree, existing, incoming, context, getStorageArgs) {\n        if (mergeTree.map.size && !isReference(incoming)) {\n            const e = \n            // Items in the same position in different arrays are not\n            // necessarily related to each other, so when incoming is an array\n            // we process its elements as if there was no existing data.\n            (!isArray(incoming) &&\n                // Likewise, existing must be either a Reference or a StoreObject\n                // in order for its fields to be safe to merge with the fields of\n                // the incoming object.\n                (isReference(existing) || storeValueIsStoreObject(existing))) ?\n                existing\n                : void 0;\n            // This narrowing is implied by mergeTree.map.size > 0 and\n            // !isReference(incoming), though TypeScript understandably cannot\n            // hope to infer this type.\n            const i = incoming;\n            // The options.storage objects provided to read and merge functions\n            // are derived from the identity of the parent object plus a\n            // sequence of storeFieldName strings/numbers identifying the nested\n            // field name path of each field value to be merged.\n            if (e && !getStorageArgs) {\n                getStorageArgs = [isReference(e) ? e.__ref : e];\n            }\n            // It's possible that applying merge functions to this subtree will\n            // not change the incoming data, so this variable tracks the fields\n            // that did change, so we can create a new incoming object when (and\n            // only when) at least one incoming field has changed. We use a Map\n            // to preserve the type of numeric keys.\n            let changedFields;\n            const getValue = (from, name) => {\n                return (isArray(from) ?\n                    typeof name === \"number\" ?\n                        from[name]\n                        : void 0\n                    : context.store.getFieldValue(from, String(name)));\n            };\n            mergeTree.map.forEach((childTree, storeFieldName) => {\n                const eVal = getValue(e, storeFieldName);\n                const iVal = getValue(i, storeFieldName);\n                // If we have no incoming data, leave any existing data untouched.\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                const aVal = this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields = changedFields || new Map();\n                    changedFields.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields) {\n                // Shallow clone i so we can add changed fields to it.\n                incoming = (isArray(i) ? i.slice(0) : { ...i });\n                changedFields.forEach((value, name) => {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && context.store.getStorage(...getStorageArgs));\n        }\n        return incoming;\n    }\n}\nconst emptyMergeTreePool = [];\nfunction getChildMergeTree({ map }, name) {\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    const info = left.info && right.info ?\n        {\n            ...left.info,\n            ...right.info,\n        }\n        : left.info || right.info;\n    const needToMergeMaps = left.map.size && right.map.size;\n    const map = needToMergeMaps ? new Map()\n        : left.map.size ? left.map\n            : right.map;\n    const merged = { info, map };\n    if (needToMergeMaps) {\n        const remainingRightKeys = new Set(right.map.keys());\n        left.map.forEach((leftTree, key) => {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys.delete(key);\n        });\n        remainingRightKeys.forEach((key) => {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree({ map }, name) {\n    const childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nconst warnings = new Set();\n// Note that this function is unused in production, and thus should be\n// pruned by any well-configured minifier.\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    const getChild = (objOrRef) => {\n        const child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    const existing = getChild(existingRef);\n    if (!existing)\n        return;\n    const incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    // It's always safe to replace a reference, since it refers to data\n    // safely stored elsewhere.\n    if (isReference(existing))\n        return;\n    // If the values are structurally equivalent, we do not need to worry\n    // about incoming replacing existing.\n    if (equal(existing, incoming))\n        return;\n    // If we're replacing every key of the existing object, then the\n    // existing data would be overwritten even if the objects were\n    // normalized, so warning would not be helpful here.\n    if (Object.keys(existing).every((key) => store.getFieldValue(incoming, key) !== void 0)) {\n        return;\n    }\n    const parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    const fieldName = fieldNameFromStoreName(storeFieldName);\n    const typeDotName = `${parentType}.${fieldName}`;\n    // Avoid warning more than once for the same type and field name.\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    const childTypenames = [];\n    // Arrays do not have __typename fields, and always need a custom merge\n    // function, even if their elements are normalized entities.\n    if (!isArray(existing) && !isArray(incoming)) {\n        [existing, incoming].forEach((child) => {\n            const typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" && !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    __DEV__ && invariant.warn(112, fieldName, parentType, childTypenames.length ?\n        \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") +\n            \" have an ID or a custom merge function, or \"\n        : \"\", typeDotName, Array.isArray(existing) ? [...existing] : { ...existing }, Array.isArray(incoming) ? [...incoming] : { ...incoming });\n}\nfunction getTypenameFromResult(result, selectionSet, fragmentMap) {\n    let fragments;\n    for (const selection of selectionSet.selections) {\n        if (isField(selection)) {\n            if (selection.name.value === \"__typename\") {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else if (fragments) {\n            fragments.push(selection);\n        }\n        else {\n            fragments = [selection];\n        }\n    }\n    if (typeof result.__typename === \"string\") {\n        return result.__typename;\n    }\n    if (fragments) {\n        for (const selection of fragments) {\n            const typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === \"string\") {\n                return typename;\n            }\n        }\n    }\n}\n//# sourceMappingURL=writeToStore.js.map\n"],"names":["getOperationDefinition","makeProcessedFieldsMerger","getDefaultValues","canonicalStringify","extractFragmentContext","isReference","newInvariantError","makeReference","policies","normalizeReadFieldOptions","resultKeyNameFromField","storeValueIsStoreObject","hasDirectives","streamInfoSymbol","defaultStreamFieldMergeFn","isArray","Trie","shouldInclude","isNonEmptyArray","argumentsObjectFromField","isField","getFragmentFromSelection","Kind","invariant"],"mappings":"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","x_google_ignoreList":[0]}