@apollo/client 3.13.8 → 3.13.9-rc.0

package/cache/inmemory/writeToStore.js

@@ -1,10 +1,11 @@
-import { __assign } from "tslib";
-import { invariant, newInvariantError } from "../../utilities/globals/index.js";
 import { equal } from "@wry/equality";
 import { Trie } from "@wry/trie";
 import { Kind } from "graphql";
-import { getFragmentFromSelection, getDefaultValues, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, cloneDeep, addTypenameToDocument, isNonEmptyArray, argumentsObjectFromField, canonicalStringify, } from "../../utilities/index.js";
-import { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext, } from "./helpers.js";
+import { addTypenameToDocument, canonicalStringify, isReference, } from "@apollo/client/utilities";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { argumentsObjectFromField, cloneDeep, getDefaultValues, getFragmentFromSelection, getOperationDefinition, isArray, isField, isNonEmptyArray, makeReference, resultKeyNameFromField, shouldInclude, } from "@apollo/client/utilities/internal";
+import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
+import { extractFragmentContext, fieldNameFromStoreName, makeProcessedFieldsMerger, storeValueIsStoreObject, } from "./helpers.js";
 import { normalizeReadFieldOptions } from "./policies.js";
 // Since there are only four possible combinations of context.clientOnly and
 // context.deferred values, we should need at most four "flavors" of any given
@@ -12,48 +13,67 @@ import { normalizeReadFieldOptions } from "./policies.js";
 // 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) {
-    var key = "".concat(clientOnly).concat(deferred);
-    var flavored = context.flavors.get(key);
+    const key = `${clientOnly}${deferred}`;
+    let flavored = context.flavors.get(key);
     if (!flavored) {
         context.flavors.set(key, (flavored =
             context.clientOnly === clientOnly && context.deferred === deferred ?
                 context
-                : __assign(__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));
+                : {
+                    ...context,
+                    clientOnly,
+                    deferred,
+                }));
     }
     return flavored;
 }
-var StoreWriter = /** @class */ (function () {
-    function StoreWriter(cache, reader, fragments) {
+export class StoreWriter {
+    cache;
+    reader;
+    fragments;
+    constructor(cache, reader, fragments) {
         this.cache = cache;
         this.reader = reader;
         this.fragments = fragments;
     }
-    StoreWriter.prototype.writeToStore = function (store, _a) {
-        var _this = this;
-        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
-        var operationDefinition = getOperationDefinition(query);
-        var merger = makeProcessedFieldsMerger();
-        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);
-        var context = __assign(__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {
+    writeToStore(store, { query, result, dataId, variables, overwrite, }) {
+        const operationDefinition = getOperationDefinition(query);
+        const merger = makeProcessedFieldsMerger();
+        variables = {
+            ...getDefaultValues(operationDefinition),
+            ...variables,
+        };
+        const context = {
+            store,
+            written: {},
+            merge(existing, incoming) {
                 return merger.merge(existing, incoming);
-            }, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });
-        var ref = this.processSelectionSet({
-            result: result || Object.create(null),
-            dataId: dataId,
+            },
+            variables: variables,
+            varString: canonicalStringify(variables),
+            ...extractFragmentContext(query, this.fragments),
+            overwrite: !!overwrite,
+            incomingById: new Map(),
+            clientOnly: false,
+            deferred: false,
+            flavors: new Map(),
+        };
+        const ref = this.processSelectionSet({
+            result: result || {},
+            dataId,
             selectionSet: operationDefinition.selectionSet,
             mergeTree: { map: new Map() },
-            context: context,
+            context,
         });
         if (!isReference(ref)) {
-            throw newInvariantError(12, result);
+            throw newInvariantError(107, 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(function (_a, dataId) {
-            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
-            var entityRef = makeReference(dataId);
+        context.incomingById.forEach(({ storeObject, mergeTree, fieldNodeSet }, dataId) => {
+            const entityRef = makeReference(dataId);
             if (mergeTree && mergeTree.map.size) {
-                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
+                const applied = this.applyMerges(mergeTree, entityRef, storeObject, context);
                 if (isReference(applied)) {
                     // Assume References returned by applyMerges have already been merged
                     // into the store. See makeMergeObjectsFunction in policies.ts for an
@@ -64,28 +84,26 @@ var StoreWriter = /** @class */ (function () {
                 // merge into the store (see store.merge statement below).
                 storeObject = applied;
             }
-            if (globalThis.__DEV__ !== false && !context.overwrite) {
-                var fieldsWithSelectionSets_1 = Object.create(null);
-                fieldNodeSet.forEach(function (field) {
+            if (__DEV__ && !context.overwrite) {
+                const fieldsWithSelectionSets = {};
+                fieldNodeSet.forEach((field) => {
                     if (field.selectionSet) {
-                        fieldsWithSelectionSets_1[field.name.value] = true;
+                        fieldsWithSelectionSets[field.name.value] = true;
                     }
                 });
-                var hasSelectionSet_1 = function (storeFieldName) {
-                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===
-                        true;
-                };
-                var hasMergeFunction_1 = function (storeFieldName) {
-                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
+                const hasSelectionSet = (storeFieldName) => fieldsWithSelectionSets[fieldNameFromStoreName(storeFieldName)] ===
+                    true;
+                const hasMergeFunction = (storeFieldName) => {
+                    const childTree = mergeTree && mergeTree.map.get(storeFieldName);
                     return Boolean(childTree && childTree.info && childTree.info.merge);
                 };
-                Object.keys(storeObject).forEach(function (storeFieldName) {
+                Object.keys(storeObject).forEach((storeFieldName) => {
                     // If a merge function was defined for this field, trust that it
                     // did the right thing about (not) clobbering data. If the field
                     // has no selection set, it's a scalar field, so it doesn't need
                     // a merge function (even if it's an object, like JSON data).
-                    if (hasSelectionSet_1(storeFieldName) &&
-                        !hasMergeFunction_1(storeFieldName)) {
+                    if (hasSelectionSet(storeFieldName) &&
+                        !hasMergeFunction(storeFieldName)) {
                         warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
                     }
                 });
@@ -99,21 +117,19 @@ var StoreWriter = /** @class */ (function () {
         // includes them in its root ID set.
         store.retain(ref.__ref);
         return ref;
-    };
-    StoreWriter.prototype.processSelectionSet = function (_a) {
-        var _this = this;
-        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, 
-        // This object allows processSelectionSet to report useful information
-        // to its callers without explicitly returning that information.
-        mergeTree = _a.mergeTree;
-        var policies = this.cache.policies;
+    }
+    processSelectionSet({ dataId, result, selectionSet, context, 
+    // This object allows processSelectionSet to report useful information
+    // to its callers without explicitly returning that information.
+    mergeTree, }) {
+        const { policies } = this.cache;
         // This variable will be repeatedly updated using context.merge to
         // accumulate all fields that need to be written into the store.
-        var incoming = Object.create(null);
+        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.
-        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
+        const typename = (dataId && policies.rootTypenamesById[dataId]) ||
             getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
             (dataId && context.store.get(dataId, "__typename"));
         if ("string" === typeof typename) {
@@ -127,38 +143,40 @@ var StoreWriter = /** @class */ (function () {
         // pending in context.incomingById, which is important whenever keyFields
         // need to be extracted from a child object that processSelectionSet has
         // turned into a Reference.
-        var readField = function () {
-            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
+        const readField = (...args) => {
+            const options = normalizeReadFieldOptions(args, incoming, context.variables);
             if (isReference(options.from)) {
-                var info = context.incomingById.get(options.from.__ref);
+                const info = context.incomingById.get(options.from.__ref);
                 if (info) {
-                    var result_1 = policies.readField(__assign(__assign({}, options), { from: info.storeObject }), context);
-                    if (result_1 !== void 0) {
-                        return result_1;
+                    const result = policies.readField({
+                        ...options,
+                        from: info.storeObject,
+                    }, context);
+                    if (result !== void 0) {
+                        return result;
                     }
                 }
             }
             return policies.readField(options, context);
         };
-        var fieldNodeSet = new Set();
+        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(function (context, field) {
-            var _a;
-            var resultFieldKey = resultKeyNameFromField(field);
-            var value = result[resultFieldKey];
+        context, typename).forEach((context, field) => {
+            const resultFieldKey = resultKeyNameFromField(field);
+            const value = result[resultFieldKey];
             fieldNodeSet.add(field);
             if (value !== void 0) {
-                var storeFieldName = policies.getStoreFieldName({
-                    typename: typename,
+                const storeFieldName = policies.getStoreFieldName({
+                    typename,
                     fieldName: field.name.value,
-                    field: field,
+                    field,
                     variables: context.variables,
                 });
-                var childTree = getChildMergeTree(mergeTree, storeFieldName);
-                var incomingValue = _this.processFieldValue(value, field, 
+                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 ?
@@ -167,30 +185,30 @@ var StoreWriter = /** @class */ (function () {
                 // 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.
-                var childTypename = void 0;
+                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 &&
                     (isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {
                     childTypename = readField("__typename", incomingValue);
                 }
-                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
+                const merge = policies.getMergeFunction(typename, field.name.value, childTypename);
                 if (merge) {
                     childTree.info = {
                         // TODO Check compatibility against any existing childTree.field?
-                        field: field,
-                        typename: typename,
-                        merge: merge,
+                        field,
+                        typename,
+                        merge,
                     };
                 }
                 else {
                     maybeRecycleChildMergeTree(mergeTree, storeFieldName);
                 }
-                incoming = context.merge(incoming, (_a = {},
-                    _a[storeFieldName] = incomingValue,
-                    _a));
+                incoming = context.merge(incoming, {
+                    [storeFieldName]: incomingValue,
+                });
             }
-            else if (globalThis.__DEV__ !== false &&
+            else if (__DEV__ &&
                 !context.clientOnly &&
                 !context.deferred &&
                 !addTypenameToDocument.added(field) &&
@@ -198,19 +216,19 @@ var StoreWriter = /** @class */ (function () {
                 // provide a default value, so its absence from the written data should
                 // not be cause for alarm.
                 !policies.getReadFunction(typename, field.name.value)) {
-                globalThis.__DEV__ !== false && invariant.error(13, resultKeyNameFromField(field), result);
+                __DEV__ && invariant.error(108, resultKeyNameFromField(field), result);
             }
         });
         // Identify the result object, even if dataId was already provided,
         // since we always need keyObject below.
         try {
-            var _b = policies.identify(result, {
-                typename: typename,
-                selectionSet: selectionSet,
+            const [id, keyObject] = policies.identify(result, {
+                typename,
+                selectionSet,
                 fragmentMap: context.fragmentMap,
                 storeObject: incoming,
-                readField: readField,
-            }), id = _b[0], keyObject = _b[1];
+                readField,
+            });
             // If dataId was not provided, fall back to the id just generated by
             // policies.identify.
             dataId = dataId || id;
@@ -227,13 +245,13 @@ var StoreWriter = /** @class */ (function () {
                 throw e;
         }
         if ("string" === typeof dataId) {
-            var dataRef = makeReference(dataId);
+            const dataRef = 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.
-            var sets = context.written[dataId] || (context.written[dataId] = []);
+            const sets = context.written[dataId] || (context.written[dataId] = []);
             if (sets.indexOf(selectionSet) >= 0)
                 return dataRef;
             sets.push(selectionSet);
@@ -246,11 +264,11 @@ var StoreWriter = /** @class */ (function () {
                 this.reader.isFresh(result, dataRef, selectionSet, context)) {
                 return dataRef;
             }
-            var previous_1 = context.incomingById.get(dataId);
-            if (previous_1) {
-                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
-                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
-                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
+            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, {
@@ -259,24 +277,23 @@ var StoreWriter = /** @class */ (function () {
                     // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and
                     // reused for entirely different parts of the result tree.
                     mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
-                    fieldNodeSet: fieldNodeSet,
+                    fieldNodeSet,
                 });
             }
             return dataRef;
         }
         return incoming;
-    };
-    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
-        var _this = this;
+    }
+    processFieldValue(value, field, context, mergeTree) {
         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 globalThis.__DEV__ !== false ? cloneDeep(value) : value;
+            return __DEV__ ? cloneDeep(value) : value;
         }
         if (isArray(value)) {
-            return value.map(function (item, i) {
-                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
+            return value.map((item, i) => {
+                const value = this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
                 maybeRecycleChildMergeTree(mergeTree, i);
                 return value;
             });
@@ -284,19 +301,18 @@ var StoreWriter = /** @class */ (function () {
         return this.processSelectionSet({
             result: value,
             selectionSet: field.selectionSet,
-            context: context,
-            mergeTree: mergeTree,
+            context,
+            mergeTree,
         });
-    };
+    }
     // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with
     // some additions for tracking @client and @defer directives.
-    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
-        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }
-        var fieldMap = new Map();
-        var policies = this.cache.policies;
-        var limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.
+    flattenFields(selectionSet, result, context, typename = getTypenameFromResult(result, selectionSet, context.fragmentMap)) {
+        const fieldMap = new Map();
+        const { policies } = this.cache;
+        const limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.
         (function flatten(selectionSet, inheritedContext) {
-            var visitedNode = limitingTrie.lookup(selectionSet, 
+            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
@@ -305,22 +321,22 @@ var StoreWriter = /** @class */ (function () {
             if (visitedNode.visited)
                 return;
             visitedNode.visited = true;
-            selectionSet.selections.forEach(function (selection) {
+            selectionSet.selections.forEach((selection) => {
                 if (!shouldInclude(selection, context.variables))
                     return;
-                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
+                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(selection.directives)) {
-                    selection.directives.forEach(function (dir) {
-                        var name = dir.name.value;
+                    selection.directives.forEach((dir) => {
+                        const name = dir.name.value;
                         if (name === "client")
                             clientOnly = true;
                         if (name === "defer") {
-                            var args = argumentsObjectFromField(dir, context.variables);
+                            const args = 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
@@ -334,7 +350,7 @@ var StoreWriter = /** @class */ (function () {
                     });
                 }
                 if (isField(selection)) {
-                    var existing = fieldMap.get(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
@@ -345,9 +361,9 @@ var StoreWriter = /** @class */ (function () {
                     fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
                 }
                 else {
-                    var fragment = getFragmentFromSelection(selection, context.lookupFragment);
+                    const fragment = getFragmentFromSelection(selection, context.lookupFragment);
                     if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {
-                        throw newInvariantError(14, selection.name.value);
+                        throw newInvariantError(109, selection.name.value);
                     }
                     if (fragment &&
                         policies.fragmentMatches(fragment, typename, result, context.variables)) {
@@ -357,12 +373,10 @@ var StoreWriter = /** @class */ (function () {
             });
         })(selectionSet, context);
         return fieldMap;
-    };
-    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
-        var _a;
-        var _this = this;
+    }
+    applyMerges(mergeTree, existing, incoming, context, getStorageArgs) {
         if (mergeTree.map.size && !isReference(incoming)) {
-            var e_1 = 
+            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.
@@ -376,64 +390,61 @@ var StoreWriter = /** @class */ (function () {
             // This narrowing is implied by mergeTree.map.size > 0 and
             // !isReference(incoming), though TypeScript understandably cannot
             // hope to infer this type.
-            var i_1 = incoming;
+            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_1 && !getStorageArgs) {
-                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];
+            if (e && !getStorageArgs) {
+                getStorageArgs = [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.
-            var changedFields_1;
-            var getValue_1 = function (from, name) {
+            let changedFields;
+            const getValue = (from, name) => {
                 return (isArray(from) ?
                     typeof name === "number" ?
                         from[name]
                         : void 0
                     : context.store.getFieldValue(from, String(name)));
             };
-            mergeTree.map.forEach(function (childTree, storeFieldName) {
-                var eVal = getValue_1(e_1, storeFieldName);
-                var iVal = getValue_1(i_1, storeFieldName);
+            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);
                 }
-                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
+                const aVal = this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
                 if (aVal !== iVal) {
-                    changedFields_1 = changedFields_1 || new Map();
-                    changedFields_1.set(storeFieldName, aVal);
+                    changedFields = changedFields || new Map();
+                    changedFields.set(storeFieldName, aVal);
                 }
                 if (getStorageArgs) {
                     invariant(getStorageArgs.pop() === storeFieldName);
                 }
             });
-            if (changedFields_1) {
+            if (changedFields) {
                 // Shallow clone i so we can add changed fields to it.
-                incoming = (isArray(i_1) ? i_1.slice(0) : __assign({}, i_1));
-                changedFields_1.forEach(function (value, name) {
+                incoming = (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 && (_a = context.store).getStorage.apply(_a, getStorageArgs));
+            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && context.store.getStorage(...getStorageArgs));
         }
         return incoming;
-    };
-    return StoreWriter;
-}());
-export { StoreWriter };
-var emptyMergeTreePool = [];
-function getChildMergeTree(_a, name) {
-    var map = _a.map;
+    }
+}
+const emptyMergeTreePool = [];
+function getChildMergeTree({ map }, name) {
     if (!map.has(name)) {
         map.set(name, emptyMergeTreePool.pop() || { map: new Map() });
     }
@@ -444,19 +455,24 @@ function mergeMergeTrees(left, right) {
         return left;
     if (!left || mergeTreeIsEmpty(left))
         return right;
-    var info = left.info && right.info ? __assign(__assign({}, left.info), right.info) : left.info || right.info;
-    var needToMergeMaps = left.map.size && right.map.size;
-    var map = needToMergeMaps ? new Map()
+    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;
-    var merged = { info: info, map: map };
+    const merged = { info, map };
     if (needToMergeMaps) {
-        var remainingRightKeys_1 = new Set(right.map.keys());
-        left.map.forEach(function (leftTree, key) {
+        const remainingRightKeys = new Set(right.map.keys());
+        left.map.forEach((leftTree, key) => {
             merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
-            remainingRightKeys_1.delete(key);
+            remainingRightKeys.delete(key);
         });
-        remainingRightKeys_1.forEach(function (key) {
+        remainingRightKeys.forEach((key) => {
             merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
         });
     }
@@ -465,26 +481,25 @@ function mergeMergeTrees(left, right) {
 function mergeTreeIsEmpty(tree) {
     return !tree || !(tree.info || tree.map.size);
 }
-function maybeRecycleChildMergeTree(_a, name) {
-    var map = _a.map;
-    var childTree = map.get(name);
+function maybeRecycleChildMergeTree({ map }, name) {
+    const childTree = map.get(name);
     if (childTree && mergeTreeIsEmpty(childTree)) {
         emptyMergeTreePool.push(childTree);
         map.delete(name);
     }
 }
-var warnings = new Set();
+const warnings = new Set();
 // Note that this function is unused in production, and thus should be
 // pruned by any well-configured minifier.
 function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
-    var getChild = function (objOrRef) {
-        var child = store.getFieldValue(objOrRef, storeFieldName);
+    const getChild = (objOrRef) => {
+        const child = store.getFieldValue(objOrRef, storeFieldName);
         return typeof child === "object" && child;
     };
-    var existing = getChild(existingRef);
+    const existing = getChild(existingRef);
     if (!existing)
         return;
-    var incoming = getChild(incomingObj);
+    const incoming = getChild(incomingObj);
     if (!incoming)
         return;
     // It's always safe to replace a reference, since it refers to data
@@ -498,32 +513,59 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
     // If we're replacing every key of the existing object, then the
     // existing data would be overwritten even if the objects were
     // normalized, so warning would not be helpful here.
-    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
+    if (Object.keys(existing).every((key) => store.getFieldValue(incoming, key) !== void 0)) {
         return;
     }
-    var parentType = store.getFieldValue(existingRef, "__typename") ||
+    const parentType = store.getFieldValue(existingRef, "__typename") ||
         store.getFieldValue(incomingObj, "__typename");
-    var fieldName = fieldNameFromStoreName(storeFieldName);
-    var typeDotName = "".concat(parentType, ".").concat(fieldName);
+    const fieldName = fieldNameFromStoreName(storeFieldName);
+    const typeDotName = `${parentType}.${fieldName}`;
     // Avoid warning more than once for the same type and field name.
     if (warnings.has(typeDotName))
         return;
     warnings.add(typeDotName);
-    var childTypenames = [];
+    const childTypenames = [];
     // Arrays do not have __typename fields, and always need a custom merge
     // function, even if their elements are normalized entities.
     if (!isArray(existing) && !isArray(incoming)) {
-        [existing, incoming].forEach(function (child) {
-            var typename = store.getFieldValue(child, "__typename");
+        [existing, incoming].forEach((child) => {
+            const typename = store.getFieldValue(child, "__typename");
             if (typeof typename === "string" && !childTypenames.includes(typename)) {
                 childTypenames.push(typename);
             }
         });
     }
-    globalThis.__DEV__ !== false && invariant.warn(15, fieldName, parentType, childTypenames.length ?
+    __DEV__ && invariant.warn(110, fieldName, parentType, childTypenames.length ?
         "either ensure all objects of type " +
             childTypenames.join(" and ") +
             " have an ID or a custom merge function, or "
-        : "", typeDotName, __assign({}, existing), __assign({}, incoming));
+        : "", typeDotName, { ...existing }, { ...incoming });
+}
+function getTypenameFromResult(result, selectionSet, fragmentMap) {
+    let fragments;
+    for (const selection of selectionSet.selections) {
+        if (isField(selection)) {
+            if (selection.name.value === "__typename") {
+                return result[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(selection, fragmentMap).selectionSet, fragmentMap);
+            if (typeof typename === "string") {
+                return typename;
+            }
+        }
+    }
 }
-//# sourceMappingURL=writeToStore.js.map
+//# sourceMappingURL=writeToStore.js.map