@apollo/client 3.13.4 → 4.0.0-alpha.0

package/cache/inmemory/policies.js

@@ -1,43 +1,45 @@
-import { __assign, __rest } from "tslib";
-import { invariant, newInvariantError } from "../../utilities/globals/index.js";
-import { storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, isNonNullObject, stringifyForDisplay, } from "../../utilities/index.js";
-import { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, defaultDataIdFromObject, isArray, } from "./helpers.js";
-import { cacheSlot } from "./reactiveVars.js";
+import { disableWarningsSlot } from "@apollo/client/masking";
+import { argumentsObjectFromField, getStoreKeyName, isNonNullObject, isReference, storeKeyNameFromField, stringifyForDisplay, } from "@apollo/client/utilities";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
+import { defaultDataIdFromObject, fieldNameFromStoreName, hasOwn, isArray, selectionSetMatchesResult, storeValueIsStoreObject, TypeOrFieldNameRegExp, } from "./helpers.js";
 import { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from "./key-extractor.js";
-import { disableWarningsSlot } from "../../masking/index.js";
+import { cacheSlot } from "./reactiveVars.js";
 function argsFromFieldSpecifier(spec) {
     return (spec.args !== void 0 ? spec.args
         : spec.field ? argumentsObjectFromField(spec.field, spec.variables)
             : null);
 }
-var nullKeyFieldsFn = function () { return void 0; };
-var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
+const nullKeyFieldsFn = () => void 0;
+const simpleKeyArgsFn = (_args, context) => context.fieldName;
 // These merge functions can be selected by specifying merge:true or
 // merge:false in a field policy.
-var mergeTrueFn = function (existing, incoming, _a) {
-    var mergeObjects = _a.mergeObjects;
-    return mergeObjects(existing, incoming);
-};
-var mergeFalseFn = function (_, incoming) { return incoming; };
-var Policies = /** @class */ (function () {
-    function Policies(config) {
+const mergeTrueFn = (existing, incoming, { mergeObjects }) => mergeObjects(existing, incoming);
+const mergeFalseFn = (_, incoming) => incoming;
+export class Policies {
+    config;
+    typePolicies = {};
+    toBeAdded = {};
+    // Map from subtype names to sets of supertype names. Note that this
+    // representation inverts the structure of possibleTypes (whose keys are
+    // supertypes and whose values are arrays of subtypes) because it tends
+    // to be much more efficient to search upwards than downwards.
+    supertypeMap = new Map();
+    // Any fuzzy subtypes specified by possibleTypes will be converted to
+    // RegExp objects and recorded here. Every key of this map can also be
+    // found in supertypeMap. In many cases this Map will be empty, which
+    // means no fuzzy subtype checking will happen in fragmentMatches.
+    fuzzySubtypes = new Map();
+    cache;
+    rootIdsByTypename = {};
+    rootTypenamesById = {};
+    usingPossibleTypes = false;
+    constructor(config) {
         this.config = config;
-        this.typePolicies = Object.create(null);
-        this.toBeAdded = Object.create(null);
-        // Map from subtype names to sets of supertype names. Note that this
-        // representation inverts the structure of possibleTypes (whose keys are
-        // supertypes and whose values are arrays of subtypes) because it tends
-        // to be much more efficient to search upwards than downwards.
-        this.supertypeMap = new Map();
-        // Any fuzzy subtypes specified by possibleTypes will be converted to
-        // RegExp objects and recorded here. Every key of this map can also be
-        // found in supertypeMap. In many cases this Map will be empty, which
-        // means no fuzzy subtype checking will happen in fragmentMatches.
-        this.fuzzySubtypes = new Map();
-        this.rootIdsByTypename = Object.create(null);
-        this.rootTypenamesById = Object.create(null);
-        this.usingPossibleTypes = false;
-        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);
+        this.config = {
+            dataIdFromObject: defaultDataIdFromObject,
+            ...config,
+        };
         this.cache = this.config.cache;
         this.setRootTypename("Query");
         this.setRootTypename("Mutation");
@@ -49,11 +51,10 @@ var Policies = /** @class */ (function () {
             this.addTypePolicies(config.typePolicies);
         }
     }
-    Policies.prototype.identify = function (object, partialContext) {
-        var _a;
-        var policies = this;
-        var typename = (partialContext &&
-            (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||
+    identify(object, partialContext) {
+        const policies = this;
+        const typename = (partialContext &&
+            (partialContext.typename || partialContext.storeObject?.__typename)) ||
             object.__typename;
         // It should be possible to write root Query fields with writeFragment,
         // using { __typename: "Query", ... } as the data, but it does not make
@@ -64,21 +65,26 @@ var Policies = /** @class */ (function () {
             return ["ROOT_QUERY"];
         }
         // Default context.storeObject to object if not otherwise provided.
-        var storeObject = (partialContext && partialContext.storeObject) || object;
-        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||
+        const storeObject = (partialContext && partialContext.storeObject) || object;
+        const context = {
+            ...partialContext,
+            typename,
+            storeObject,
+            readField: (partialContext && partialContext.readField) ||
                 function () {
-                    var options = normalizeReadFieldOptions(arguments, storeObject);
+                    const options = normalizeReadFieldOptions(arguments, storeObject);
                     return policies.readField(options, {
                         store: policies.cache["data"],
                         variables: options.variables,
                     });
-                } });
-        var id;
-        var policy = typename && this.getTypePolicy(typename);
-        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
-        disableWarningsSlot.withValue(true, function () {
+                },
+        };
+        let id;
+        const policy = typename && this.getTypePolicy(typename);
+        let keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
+        disableWarningsSlot.withValue(true, () => {
             while (keyFn) {
-                var specifierOrId = keyFn(__assign(__assign({}, object), storeObject), context);
+                const specifierOrId = keyFn({ ...object, ...storeObject }, context);
                 if (isArray(specifierOrId)) {
                     keyFn = keyFieldsFnFromSpecifier(specifierOrId);
                 }
@@ -90,11 +96,10 @@ var Policies = /** @class */ (function () {
         });
         id = id ? String(id) : void 0;
         return context.keyObject ? [id, context.keyObject] : [id];
-    };
-    Policies.prototype.addTypePolicies = function (typePolicies) {
-        var _this = this;
-        Object.keys(typePolicies).forEach(function (typename) {
-            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = __rest(_a, ["queryType", "mutationType", "subscriptionType"]);
+    }
+    addTypePolicies(typePolicies) {
+        Object.keys(typePolicies).forEach((typename) => {
+            const { queryType, mutationType, subscriptionType, ...incoming } = typePolicies[typename];
             // Though {query,mutation,subscription}Type configurations are rare,
             // it's important to call setRootTypename as early as possible,
             // since these configurations should apply consistently for the
@@ -110,23 +115,22 @@ var Policies = /** @class */ (function () {
             // properties, there's also no need to delay their processing using
             // the this.toBeAdded queue.
             if (queryType)
-                _this.setRootTypename("Query", typename);
+                this.setRootTypename("Query", typename);
             if (mutationType)
-                _this.setRootTypename("Mutation", typename);
+                this.setRootTypename("Mutation", typename);
             if (subscriptionType)
-                _this.setRootTypename("Subscription", typename);
-            if (hasOwn.call(_this.toBeAdded, typename)) {
-                _this.toBeAdded[typename].push(incoming);
+                this.setRootTypename("Subscription", typename);
+            if (hasOwn.call(this.toBeAdded, typename)) {
+                this.toBeAdded[typename].push(incoming);
             }
             else {
-                _this.toBeAdded[typename] = [incoming];
+                this.toBeAdded[typename] = [incoming];
             }
         });
-    };
-    Policies.prototype.updateTypePolicy = function (typename, incoming) {
-        var _this = this;
-        var existing = this.getTypePolicy(typename);
-        var keyFields = incoming.keyFields, fields = incoming.fields;
+    }
+    updateTypePolicy(typename, incoming) {
+        const existing = this.getTypePolicy(typename);
+        const { keyFields, fields } = incoming;
         function setMerge(existing, merge) {
             existing.merge =
                 typeof merge === "function" ? merge
@@ -152,14 +156,14 @@ var Policies = /** @class */ (function () {
                         // Leave existing.keyFn unchanged if above cases fail.
                         : existing.keyFn;
         if (fields) {
-            Object.keys(fields).forEach(function (fieldName) {
-                var existing = _this.getFieldPolicy(typename, fieldName, true);
-                var incoming = fields[fieldName];
+            Object.keys(fields).forEach((fieldName) => {
+                const existing = this.getFieldPolicy(typename, fieldName, true);
+                const incoming = fields[fieldName];
                 if (typeof incoming === "function") {
                     existing.read = incoming;
                 }
                 else {
-                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;
+                    const { keyArgs, read, merge } = incoming;
                     existing.keyFn =
                         // Pass false to disable argument-based differentiation of
                         // field identities.
@@ -186,13 +190,12 @@ var Policies = /** @class */ (function () {
                 }
             });
         }
-    };
-    Policies.prototype.setRootTypename = function (which, typename) {
-        if (typename === void 0) { typename = which; }
-        var rootId = "ROOT_" + which.toUpperCase();
-        var old = this.rootTypenamesById[rootId];
+    }
+    setRootTypename(which, typename = which) {
+        const rootId = "ROOT_" + which.toUpperCase();
+        const old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            invariant(!old || old === which, 6, which);
+            invariant(!old || old === which, 86, which);
             // First, delete any old __typename associated with this rootId from
             // rootIdsByTypename.
             if (old)
@@ -202,30 +205,28 @@ var Policies = /** @class */ (function () {
             // Finally, update the __typename associated with this rootId.
             this.rootTypenamesById[rootId] = typename;
         }
-    };
-    Policies.prototype.addPossibleTypes = function (possibleTypes) {
-        var _this = this;
+    }
+    addPossibleTypes(possibleTypes) {
         this.usingPossibleTypes = true;
-        Object.keys(possibleTypes).forEach(function (supertype) {
+        Object.keys(possibleTypes).forEach((supertype) => {
             // Make sure all types have an entry in this.supertypeMap, even if
             // their supertype set is empty, so we can return false immediately
             // from policies.fragmentMatches for unknown supertypes.
-            _this.getSupertypeSet(supertype, true);
-            possibleTypes[supertype].forEach(function (subtype) {
-                _this.getSupertypeSet(subtype, true).add(supertype);
-                var match = subtype.match(TypeOrFieldNameRegExp);
+            this.getSupertypeSet(supertype, true);
+            possibleTypes[supertype].forEach((subtype) => {
+                this.getSupertypeSet(subtype, true).add(supertype);
+                const match = subtype.match(TypeOrFieldNameRegExp);
                 if (!match || match[0] !== subtype) {
                     // TODO Don't interpret just any invalid typename as a RegExp.
-                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));
+                    this.fuzzySubtypes.set(subtype, new RegExp(subtype));
                 }
             });
         });
-    };
-    Policies.prototype.getTypePolicy = function (typename) {
-        var _this = this;
+    }
+    getTypePolicy(typename) {
         if (!hasOwn.call(this.typePolicies, typename)) {
-            var policy_1 = (this.typePolicies[typename] = Object.create(null));
-            policy_1.fields = Object.create(null);
+            const policy = (this.typePolicies[typename] = {});
+            policy.fields = {};
             // When the TypePolicy for typename is first accessed, instead of
             // starting with an empty policy object, inherit any properties or
             // fields from the type policies of the supertypes of typename.
@@ -247,84 +248,81 @@ var Policies = /** @class */ (function () {
             // still be updated directly using addTypePolicies, but future changes to
             // inherited supertype policies will not be reflected in this subtype
             // policy, because this code runs at most once per typename.
-            var supertypes_1 = this.supertypeMap.get(typename);
-            if (!supertypes_1 && this.fuzzySubtypes.size) {
+            let supertypes = this.supertypeMap.get(typename);
+            if (!supertypes && this.fuzzySubtypes.size) {
                 // To make the inheritance logic work for unknown typename strings that
                 // may have fuzzy supertypes, we give this typename an empty supertype
                 // set and then populate it with any fuzzy supertypes that match.
-                supertypes_1 = this.getSupertypeSet(typename, true);
+                supertypes = this.getSupertypeSet(typename, true);
                 // This only works for typenames that are directly matched by a fuzzy
                 // supertype. What if there is an intermediate chain of supertypes?
                 // While possible, that situation can only be solved effectively by
                 // specifying the intermediate relationships via possibleTypes, manually
                 // and in a non-fuzzy way.
-                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {
+                this.fuzzySubtypes.forEach((regExp, fuzzy) => {
                     if (regExp.test(typename)) {
                         // The fuzzy parameter is just the original string version of regExp
                         // (not a valid __typename string), but we can look up the
                         // associated supertype(s) in this.supertypeMap.
-                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);
+                        const fuzzySupertypes = this.supertypeMap.get(fuzzy);
                         if (fuzzySupertypes) {
-                            fuzzySupertypes.forEach(function (supertype) {
-                                return supertypes_1.add(supertype);
-                            });
+                            fuzzySupertypes.forEach((supertype) => supertypes.add(supertype));
                         }
                     }
                 });
             }
-            if (supertypes_1 && supertypes_1.size) {
-                supertypes_1.forEach(function (supertype) {
-                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = __rest(_a, ["fields"]);
-                    Object.assign(policy_1, rest);
-                    Object.assign(policy_1.fields, fields);
+            if (supertypes && supertypes.size) {
+                supertypes.forEach((supertype) => {
+                    const { fields, ...rest } = this.getTypePolicy(supertype);
+                    Object.assign(policy, rest);
+                    Object.assign(policy.fields, fields);
                 });
             }
         }
-        var inbox = this.toBeAdded[typename];
+        const inbox = this.toBeAdded[typename];
         if (inbox && inbox.length) {
             // Merge the pending policies into this.typePolicies, in the order they
             // were originally passed to addTypePolicy.
-            inbox.splice(0).forEach(function (policy) {
-                _this.updateTypePolicy(typename, policy);
+            inbox.splice(0).forEach((policy) => {
+                this.updateTypePolicy(typename, policy);
             });
         }
         return this.typePolicies[typename];
-    };
-    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {
+    }
+    getFieldPolicy(typename, fieldName, createIfMissing) {
         if (typename) {
-            var fieldPolicies = this.getTypePolicy(typename).fields;
+            const fieldPolicies = this.getTypePolicy(typename).fields;
             return (fieldPolicies[fieldName] ||
-                (createIfMissing && (fieldPolicies[fieldName] = Object.create(null))));
+                (createIfMissing && (fieldPolicies[fieldName] = {})));
         }
-    };
-    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {
-        var supertypeSet = this.supertypeMap.get(subtype);
+    }
+    getSupertypeSet(subtype, createIfMissing) {
+        let supertypeSet = this.supertypeMap.get(subtype);
         if (!supertypeSet && createIfMissing) {
             this.supertypeMap.set(subtype, (supertypeSet = new Set()));
         }
         return supertypeSet;
-    };
-    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {
-        var _this = this;
+    }
+    fragmentMatches(fragment, typename, result, variables) {
         if (!fragment.typeCondition)
             return true;
         // If the fragment has a type condition but the object we're matching
         // against does not have a __typename, the fragment cannot match.
         if (!typename)
             return false;
-        var supertype = fragment.typeCondition.name.value;
+        const supertype = fragment.typeCondition.name.value;
         // Common case: fragment type condition and __typename are the same.
         if (typename === supertype)
             return true;
         if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {
-            var typenameSupertypeSet = this.getSupertypeSet(typename, true);
-            var workQueue_1 = [typenameSupertypeSet];
-            var maybeEnqueue_1 = function (subtype) {
-                var supertypeSet = _this.getSupertypeSet(subtype, false);
+            const typenameSupertypeSet = this.getSupertypeSet(typename, true);
+            const workQueue = [typenameSupertypeSet];
+            const maybeEnqueue = (subtype) => {
+                const supertypeSet = this.getSupertypeSet(subtype, false);
                 if (supertypeSet &&
                     supertypeSet.size &&
-                    workQueue_1.indexOf(supertypeSet) < 0) {
-                    workQueue_1.push(supertypeSet);
+                    workQueue.indexOf(supertypeSet) < 0) {
+                    workQueue.push(supertypeSet);
                 }
             };
             // We need to check fuzzy subtypes only if we encountered fuzzy
@@ -333,16 +331,16 @@ var Policies = /** @class */ (function () {
             // strong signal of fragment matching. The StoreReader class calls
             // policies.fragmentMatches without passing a result object, so
             // needToCheckFuzzySubtypes is always false while reading.
-            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
-            var checkingFuzzySubtypes = false;
+            let needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
+            let checkingFuzzySubtypes = false;
             // It's important to keep evaluating workQueue.length each time through
             // the loop, because the queue can grow while we're iterating over it.
-            for (var i = 0; i < workQueue_1.length; ++i) {
-                var supertypeSet = workQueue_1[i];
+            for (let i = 0; i < workQueue.length; ++i) {
+                const supertypeSet = workQueue[i];
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            globalThis.__DEV__ !== false && invariant.warn(7, typename, supertype);
+                            __DEV__ && invariant.warn(87, typename, supertype);
                         }
                         // Record positive results for faster future lookup.
                         // Unfortunately, we cannot safely cache negative results,
@@ -352,11 +350,11 @@ var Policies = /** @class */ (function () {
                     }
                     return true;
                 }
-                supertypeSet.forEach(maybeEnqueue_1);
+                supertypeSet.forEach(maybeEnqueue);
                 if (needToCheckFuzzySubtypes &&
                     // Start checking fuzzy subtypes only after exhausting all
                     // non-fuzzy subtypes (after the final iteration of the loop).
-                    i === workQueue_1.length - 1 &&
+                    i === workQueue.length - 1 &&
                     // We could wait to compare fragment.selectionSet to result
                     // after we verify the supertype, but this check is often less
                     // expensive than that search, and we will have to do the
@@ -371,36 +369,36 @@ var Policies = /** @class */ (function () {
                     // workQueue to search through the supertypes of those fuzzy
                     // subtypes. Otherwise the for-loop will terminate and we'll
                     // return false below.
-                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {
-                        var match = typename.match(regExp);
+                    this.fuzzySubtypes.forEach((regExp, fuzzyString) => {
+                        const match = typename.match(regExp);
                         if (match && match[0] === typename) {
-                            maybeEnqueue_1(fuzzyString);
+                            maybeEnqueue(fuzzyString);
                         }
                     });
                 }
             }
         }
         return false;
-    };
-    Policies.prototype.hasKeyArgs = function (typename, fieldName) {
-        var policy = this.getFieldPolicy(typename, fieldName, false);
+    }
+    hasKeyArgs(typename, fieldName) {
+        const policy = this.getFieldPolicy(typename, fieldName, false);
         return !!(policy && policy.keyFn);
-    };
-    Policies.prototype.getStoreFieldName = function (fieldSpec) {
-        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;
-        var policy = this.getFieldPolicy(typename, fieldName, false);
-        var storeFieldName;
-        var keyFn = policy && policy.keyFn;
+    }
+    getStoreFieldName(fieldSpec) {
+        const { typename, fieldName } = fieldSpec;
+        const policy = this.getFieldPolicy(typename, fieldName, false);
+        let storeFieldName;
+        let keyFn = policy && policy.keyFn;
         if (keyFn && typename) {
-            var context = {
-                typename: typename,
-                fieldName: fieldName,
+            const context = {
+                typename,
+                fieldName,
                 field: fieldSpec.field || null,
                 variables: fieldSpec.variables,
             };
-            var args = argsFromFieldSpecifier(fieldSpec);
+            const args = argsFromFieldSpecifier(fieldSpec);
             while (keyFn) {
-                var specifierOrString = keyFn(args, context);
+                const specifierOrString = keyFn(args, context);
                 if (isArray(specifierOrString)) {
                     keyFn = keyArgsFnFromSpecifier(specifierOrString);
                 }
@@ -428,26 +426,26 @@ var Policies = /** @class */ (function () {
         // StoreObject correspond to which original field names.
         return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName
             : fieldName + ":" + storeFieldName;
-    };
-    Policies.prototype.readField = function (options, context) {
-        var objectOrReference = options.from;
+    }
+    readField(options, context) {
+        const objectOrReference = options.from;
         if (!objectOrReference)
             return;
-        var nameOrField = options.field || options.fieldName;
+        const nameOrField = options.field || options.fieldName;
         if (!nameOrField)
             return;
         if (options.typename === void 0) {
-            var typename = context.store.getFieldValue(objectOrReference, "__typename");
+            const typename = context.store.getFieldValue(objectOrReference, "__typename");
             if (typename)
                 options.typename = typename;
         }
-        var storeFieldName = this.getStoreFieldName(options);
-        var fieldName = fieldNameFromStoreName(storeFieldName);
-        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);
-        var policy = this.getFieldPolicy(options.typename, fieldName, false);
-        var read = policy && policy.read;
+        const storeFieldName = this.getStoreFieldName(options);
+        const fieldName = fieldNameFromStoreName(storeFieldName);
+        const existing = context.store.getFieldValue(objectOrReference, storeFieldName);
+        const policy = this.getFieldPolicy(options.typename, fieldName, false);
+        const read = policy && policy.read;
         if (read) {
-            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?
+            const readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?
                 objectOrReference.__ref
                 : objectOrReference, storeFieldName));
             // Call read(existing, readOptions) with cacheSlot holding this.cache.
@@ -457,22 +455,21 @@ var Policies = /** @class */ (function () {
             ]);
         }
         return existing;
-    };
-    Policies.prototype.getReadFunction = function (typename, fieldName) {
-        var policy = this.getFieldPolicy(typename, fieldName, false);
+    }
+    getReadFunction(typename, fieldName) {
+        const policy = this.getFieldPolicy(typename, fieldName, false);
         return policy && policy.read;
-    };
-    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
-        var policy = this.getFieldPolicy(parentTypename, fieldName, false);
-        var merge = policy && policy.merge;
+    }
+    getMergeFunction(parentTypename, fieldName, childTypename) {
+        let policy = this.getFieldPolicy(parentTypename, fieldName, false);
+        let merge = policy && policy.merge;
         if (!merge && childTypename) {
             policy = this.getTypePolicy(childTypename);
             merge = policy && policy.merge;
         }
         return merge;
-    };
-    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {
-        var field = _a.field, typename = _a.typename, merge = _a.merge;
+    }
+    runMergeFunction(existing, incoming, { field, typename, merge }, context, storage) {
         if (merge === mergeTrueFn) {
             // Instead of going to the trouble of creating a full
             // FieldFunctionOptions object and calling mergeTrueFn, we can
@@ -503,40 +500,38 @@ var Policies = /** @class */ (function () {
         // However, readField(name, ref) is useful for merge functions
         // that need to deduplicate child objects and references.
         void 0, {
-            typename: typename,
+            typename,
             fieldName: field.name.value,
-            field: field,
+            field,
             variables: context.variables,
-        }, context, storage || Object.create(null)));
-    };
-    return Policies;
-}());
-export { Policies };
+        }, context, storage || {}));
+    }
+}
 function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
-    var storeFieldName = policies.getStoreFieldName(fieldSpec);
-    var fieldName = fieldNameFromStoreName(storeFieldName);
-    var variables = fieldSpec.variables || context.variables;
-    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;
+    const storeFieldName = policies.getStoreFieldName(fieldSpec);
+    const fieldName = fieldNameFromStoreName(storeFieldName);
+    const variables = fieldSpec.variables || context.variables;
+    const { toReference, canRead } = context.store;
     return {
         args: argsFromFieldSpecifier(fieldSpec),
         field: fieldSpec.field || null,
-        fieldName: fieldName,
-        storeFieldName: storeFieldName,
-        variables: variables,
-        isReference: isReference,
-        toReference: toReference,
-        storage: storage,
+        fieldName,
+        storeFieldName,
+        variables,
+        isReference,
+        toReference,
+        storage,
         cache: policies.cache,
-        canRead: canRead,
-        readField: function () {
+        canRead,
+        readField() {
             return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);
         },
         mergeObjects: makeMergeObjectsFunction(context.store),
     };
 }
 export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
-    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
-    var options;
+    const { 0: fieldNameOrOptions, 1: from, length: argc } = readFieldArgs;
+    let options;
     if (typeof fieldNameOrOptions === "string") {
         options = {
             fieldName: fieldNameOrOptions,
@@ -547,15 +542,15 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
         };
     }
     else {
-        options = __assign({}, fieldNameOrOptions);
+        options = { ...fieldNameOrOptions };
         // Default to objectOrReference only when fieldNameOrOptions.from is
         // actually omitted, rather than just undefined.
         if (!hasOwn.call(options, "from")) {
             options.from = objectOrReference;
         }
     }
-    if (globalThis.__DEV__ !== false && options.from === void 0) {
-        globalThis.__DEV__ !== false && invariant.warn(8, stringifyForDisplay(Array.from(readFieldArgs)));
+    if (__DEV__ && options.from === void 0) {
+        __DEV__ && invariant.warn(88, stringifyForDisplay(Array.from(readFieldArgs)));
     }
     if (void 0 === options.variables) {
         options.variables = variables;
@@ -565,16 +560,16 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if (isArray(existing) || isArray(incoming)) {
-            throw newInvariantError(9);
+            throw newInvariantError(89);
         }
         // These dynamic checks are necessary because the parameters of a
         // custom merge function can easily have the any type, so the type
         // system cannot always enforce the StoreObject | Reference parameter
         // types of options.mergeObjects.
         if (isNonNullObject(existing) && isNonNullObject(incoming)) {
-            var eType = store.getFieldValue(existing, "__typename");
-            var iType = store.getFieldValue(incoming, "__typename");
-            var typesDiffer = eType && iType && eType !== iType;
+            const eType = store.getFieldValue(existing, "__typename");
+            const iType = store.getFieldValue(incoming, "__typename");
+            const typesDiffer = eType && iType && eType !== iType;
             if (typesDiffer) {
                 return incoming;
             }
@@ -595,10 +590,10 @@ function makeMergeObjectsFunction(store) {
             }
             if (storeValueIsStoreObject(existing) &&
                 storeValueIsStoreObject(incoming)) {
-                return __assign(__assign({}, existing), incoming);
+                return { ...existing, ...incoming };
             }
         }
         return incoming;
     };
 }
-//# sourceMappingURL=policies.js.map
+//# sourceMappingURL=policies.js.map