@apollo/client 3.10.2 → 3.10.4

package/cache/cache.cjs

@@ -7,10 +7,14 @@ var tslib = require('tslib');
 var optimism = require('optimism');
 var utilities = require('../utilities');
 var caches = require('@wry/caches');
-var equality = require('@wry/equality');
+var equal = require('@wry/equality');
 var trie = require('@wry/trie');
 var graphql = require('graphql');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
+
 var getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ?
     _getInMemoryCacheMemoryInternals
     : undefined;
@@ -56,6 +60,72 @@ function recurseTransformInfo(transform) {
         : [];
 }
 
+function equalByQuery(query, _a, _b, variables) {
+    var aData = _a.data, aRest = tslib.__rest(_a, ["data"]);
+    var bData = _b.data, bRest = tslib.__rest(_b, ["data"]);
+    return (equal__default(aRest, bRest) &&
+        equalBySelectionSet(utilities.getMainDefinition(query).selectionSet, aData, bData, {
+            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
+            variables: variables,
+        }));
+}
+function equalBySelectionSet(selectionSet, aResult, bResult, context) {
+    if (aResult === bResult) {
+        return true;
+    }
+    var seenSelections = new Set();
+    return selectionSet.selections.every(function (selection) {
+        if (seenSelections.has(selection))
+            return true;
+        seenSelections.add(selection);
+        if (!utilities.shouldInclude(selection, context.variables))
+            return true;
+        if (selectionHasNonreactiveDirective(selection))
+            return true;
+        if (utilities.isField(selection)) {
+            var resultKey = utilities.resultKeyNameFromField(selection);
+            var aResultChild = aResult && aResult[resultKey];
+            var bResultChild = bResult && bResult[resultKey];
+            var childSelectionSet = selection.selectionSet;
+            if (!childSelectionSet) {
+                return equal__default(aResultChild, bResultChild);
+            }
+            var aChildIsArray = Array.isArray(aResultChild);
+            var bChildIsArray = Array.isArray(bResultChild);
+            if (aChildIsArray !== bChildIsArray)
+                return false;
+            if (aChildIsArray && bChildIsArray) {
+                var length_1 = aResultChild.length;
+                if (bResultChild.length !== length_1) {
+                    return false;
+                }
+                for (var i = 0; i < length_1; ++i) {
+                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);
+        }
+        else {
+            var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
+            if (fragment) {
+                if (selectionHasNonreactiveDirective(fragment))
+                    return true;
+                return equalBySelectionSet(fragment.selectionSet,
+                aResult, bResult, context);
+            }
+        }
+    });
+}
+function selectionHasNonreactiveDirective(selection) {
+    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));
+}
+function directiveIsNonreactive(dir) {
+    return dir.name.value === "nonreactive";
+}
+
 var ApolloCache =  (function () {
     function ApolloCache() {
         this.assumeImmutableResults = false;
@@ -99,16 +169,19 @@ var ApolloCache =  (function () {
     ApolloCache.prototype.watchFragment = function (options) {
         var _this = this;
         var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a;
+        var query = this.getFragmentDoc(fragment, fragmentName);
         var diffOptions = {
             returnPartialData: true,
             id: typeof from === "string" ? from : this.identify(from),
-            query: this.getFragmentDoc(fragment, fragmentName),
+            query: query,
             optimistic: optimistic,
         };
         var latestDiff;
         return new utilities.Observable(function (observer) {
-            return _this.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, query: _this.getFragmentDoc(fragment, fragmentName), callback: function (diff) {
-                    if (equality.equal(diff, latestDiff)) {
+            return _this.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
+                    if (
+                    latestDiff &&
+                        equalByQuery(query, { data: latestDiff === null || latestDiff === void 0 ? void 0 : latestDiff.result }, { data: diff.result })) {
                         return;
                     }
                     var result = {
@@ -731,7 +804,7 @@ var Layer =  (function (_super) {
                     }
                     else if (ownStoreObject !== parentStoreObject) {
                         Object.keys(ownStoreObject).forEach(function (storeFieldName) {
-                            if (!equality.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
+                            if (!equal.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
                                 _this.group.dirty(dataId, storeFieldName);
                             }
                         });
@@ -776,7 +849,7 @@ var Stump =  (function (_super) {
 function storeObjectReconciler(existingObject, incomingObject, property) {
     var existingValue = existingObject[property];
     var incomingValue = incomingObject[property];
-    return equality.equal(existingValue, incomingValue) ? existingValue : incomingValue;
+    return equal.equal(existingValue, incomingValue) ? existingValue : incomingValue;
 }
 function supportsResultCaching(store) {
     return !!(store instanceof exports.EntityStore && store.group.caching);
@@ -2130,7 +2203,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
         return;
     if (utilities.isReference(existing))
         return;
-    if (equality.equal(existing, incoming))
+    if (equal.equal(existing, incoming))
         return;
     if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
         return;
@@ -2155,7 +2228,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
         "either ensure all objects of type " +
             childTypenames.join(" and ") +
             " have an ID or a custom merge function, or "
-        : "", typeDotName, existing, incoming);
+        : "", typeDotName, tslib.__assign({}, existing), tslib.__assign({}, incoming));
 }
 
 var InMemoryCache =  (function (_super) {
@@ -2453,7 +2526,7 @@ var InMemoryCache =  (function (_super) {
                 return;
             }
         }
-        if (!lastDiff || !equality.equal(lastDiff.result, diff.result)) {
+        if (!lastDiff || !equal.equal(lastDiff.result, diff.result)) {
             c.callback((c.lastDiff = diff), lastDiff);
         }
     };