@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.1

package/cache/inmemory/policies.js

@@ -1,46 +1,43 @@
-import { disableWarningsSlot } from "@apollo/client/masking";
-import { isReference } from "@apollo/client/utilities";
-import { __DEV__ } from "@apollo/client/utilities/environment";
-import { argumentsObjectFromField, getStoreKeyName, isArray, isNonNullObject, storeKeyNameFromField, stringifyForDisplay, } from "@apollo/client/utilities/internal";
-import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
-import { defaultDataIdFromObject, fieldNameFromStoreName, hasOwn, selectionSetMatchesResult, storeValueIsStoreObject, TypeOrFieldNameRegExp, } from "./helpers.js";
-import { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from "./key-extractor.js";
+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 { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from "./key-extractor.js";
+import { disableWarningsSlot } from "../../masking/index.js";
 function argsFromFieldSpecifier(spec) {
     return (spec.args !== void 0 ? spec.args
         : spec.field ? argumentsObjectFromField(spec.field, spec.variables)
             : null);
 }
-const nullKeyFieldsFn = () => void 0;
-const simpleKeyArgsFn = (_args, context) => context.fieldName;
+var nullKeyFieldsFn = function () { return void 0; };
+var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
 // These merge functions can be selected by specifying merge:true or
 // merge:false in a field policy.
-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) {
+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) {
         this.config = config;
-        this.config = {
-            dataIdFromObject: defaultDataIdFromObject,
-            ...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.cache = this.config.cache;
         this.setRootTypename("Query");
         this.setRootTypename("Mutation");
@@ -52,10 +49,11 @@ export class Policies {
             this.addTypePolicies(config.typePolicies);
         }
     }
-    identify(object, partialContext) {
-        const policies = this;
-        const typename = (partialContext &&
-            (partialContext.typename || partialContext.storeObject?.__typename)) ||
+    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))) ||
             object.__typename;
         // It should be possible to write root Query fields with writeFragment,
         // using { __typename: "Query", ... } as the data, but it does not make
@@ -66,26 +64,21 @@ export class Policies {
             return ["ROOT_QUERY"];
         }
         // Default context.storeObject to object if not otherwise provided.
-        const storeObject = (partialContext && partialContext.storeObject) || object;
-        const context = {
-            ...partialContext,
-            typename,
-            storeObject,
-            readField: (partialContext && partialContext.readField) ||
-                ((...args) => {
-                    const options = normalizeReadFieldOptions(args, storeObject);
+        var storeObject = (partialContext && partialContext.storeObject) || object;
+        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||
+                function () {
+                    var options = normalizeReadFieldOptions(arguments, storeObject);
                     return policies.readField(options, {
                         store: policies.cache["data"],
                         variables: options.variables,
                     });
-                }),
-        };
-        let id;
-        const policy = typename && this.getTypePolicy(typename);
-        let keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
-        disableWarningsSlot.withValue(true, () => {
+                } });
+        var id;
+        var policy = typename && this.getTypePolicy(typename);
+        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
+        disableWarningsSlot.withValue(true, function () {
             while (keyFn) {
-                const specifierOrId = keyFn({ ...object, ...storeObject }, context);
+                var specifierOrId = keyFn(__assign(__assign({}, object), storeObject), context);
                 if (isArray(specifierOrId)) {
                     keyFn = keyFieldsFnFromSpecifier(specifierOrId);
                 }
@@ -97,10 +90,11 @@ export class Policies {
         });
         id = id ? String(id) : void 0;
         return context.keyObject ? [id, context.keyObject] : [id];
-    }
-    addTypePolicies(typePolicies) {
-        Object.keys(typePolicies).forEach((typename) => {
-            const { queryType, mutationType, subscriptionType, ...incoming } = typePolicies[typename];
+    };
+    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"]);
             // 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
@@ -116,22 +110,22 @@ export class Policies {
             // 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];
             }
         });
-    }
-    updateTypePolicy(typename, incoming) {
-        const existing = this.getTypePolicy(typename);
-        const { keyFields, fields } = incoming;
+    };
+    Policies.prototype.updateTypePolicy = function (typename, incoming, existingFieldPolicies) {
+        var existing = this.getTypePolicy(typename);
+        var keyFields = incoming.keyFields, fields = incoming.fields;
         function setMerge(existing, merge) {
             existing.merge =
                 typeof merge === "function" ? merge
@@ -157,14 +151,22 @@ export class Policies {
                         // Leave existing.keyFn unchanged if above cases fail.
                         : existing.keyFn;
         if (fields) {
-            Object.keys(fields).forEach((fieldName) => {
-                const existing = this.getFieldPolicy(typename, fieldName, true);
-                const incoming = fields[fieldName];
+            Object.keys(fields).forEach(function (fieldName) {
+                var existing = existingFieldPolicies[fieldName];
+                // Field policy inheritance is atomic/shallow: you can't inherit a
+                // field policy and then override just its read function, since read
+                // and merge functions often need to cooperate, so changing only one
+                // of them would be a recipe for inconsistency.
+                // So here we avoid merging an inherited field policy with an updated one.
+                if (!existing || (existing === null || existing === void 0 ? void 0 : existing.typename) !== typename) {
+                    existing = existingFieldPolicies[fieldName] = { typename: typename };
+                }
+                var incoming = fields[fieldName];
                 if (typeof incoming === "function") {
                     existing.read = incoming;
                 }
                 else {
-                    const { keyArgs, read, merge } = incoming;
+                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;
                     existing.keyFn =
                         // Pass false to disable argument-based differentiation of
                         // field identities.
@@ -191,12 +193,13 @@ export class Policies {
                 }
             });
         }
-    }
-    setRootTypename(which, typename = which) {
-        const rootId = "ROOT_" + which.toUpperCase();
-        const old = this.rootTypenamesById[rootId];
+    };
+    Policies.prototype.setRootTypename = function (which, typename) {
+        if (typename === void 0) { typename = which; }
+        var rootId = "ROOT_" + which.toUpperCase();
+        var old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            invariant(!old || old === which, 101, which);
+            invariant(!old || old === which, 6, which);
             // First, delete any old __typename associated with this rootId from
             // rootIdsByTypename.
             if (old)
@@ -206,28 +209,30 @@ export class Policies {
             // Finally, update the __typename associated with this rootId.
             this.rootTypenamesById[rootId] = typename;
         }
-    }
-    addPossibleTypes(possibleTypes) {
+    };
+    Policies.prototype.addPossibleTypes = function (possibleTypes) {
+        var _this = this;
         this.usingPossibleTypes = true;
-        Object.keys(possibleTypes).forEach((supertype) => {
+        Object.keys(possibleTypes).forEach(function (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((subtype) => {
-                this.getSupertypeSet(subtype, true).add(supertype);
-                const match = subtype.match(TypeOrFieldNameRegExp);
+            _this.getSupertypeSet(supertype, true);
+            possibleTypes[supertype].forEach(function (subtype) {
+                _this.getSupertypeSet(subtype, true).add(supertype);
+                var 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));
                 }
             });
         });
-    }
-    getTypePolicy(typename) {
+    };
+    Policies.prototype.getTypePolicy = function (typename) {
+        var _this = this;
         if (!hasOwn.call(this.typePolicies, typename)) {
-            const policy = (this.typePolicies[typename] = {});
-            policy.fields = {};
+            var policy_1 = (this.typePolicies[typename] = Object.create(null));
+            policy_1.fields = Object.create(null);
             // 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.
@@ -249,81 +254,82 @@ export class Policies {
             // 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.
-            let supertypes = this.supertypeMap.get(typename);
-            if (!supertypes && this.fuzzySubtypes.size) {
+            var supertypes_1 = this.supertypeMap.get(typename);
+            if (!supertypes_1 && 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 = this.getSupertypeSet(typename, true);
+                supertypes_1 = 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((regExp, fuzzy) => {
+                this.fuzzySubtypes.forEach(function (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.
-                        const fuzzySupertypes = this.supertypeMap.get(fuzzy);
+                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);
                         if (fuzzySupertypes) {
-                            fuzzySupertypes.forEach((supertype) => supertypes.add(supertype));
+                            fuzzySupertypes.forEach(function (supertype) {
+                                return supertypes_1.add(supertype);
+                            });
                         }
                     }
                 });
             }
-            if (supertypes && supertypes.size) {
-                supertypes.forEach((supertype) => {
-                    const { fields, ...rest } = this.getTypePolicy(supertype);
-                    Object.assign(policy, rest);
-                    Object.assign(policy.fields, fields);
+            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);
                 });
             }
         }
-        const inbox = this.toBeAdded[typename];
+        var 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((policy) => {
-                this.updateTypePolicy(typename, policy);
+            inbox.splice(0).forEach(function (policy) {
+                _this.updateTypePolicy(typename, policy, _this.typePolicies[typename].fields);
             });
         }
         return this.typePolicies[typename];
-    }
-    getFieldPolicy(typename, fieldName, createIfMissing) {
+    };
+    Policies.prototype.getFieldPolicy = function (typename, fieldName) {
         if (typename) {
-            const fieldPolicies = this.getTypePolicy(typename).fields;
-            return (fieldPolicies[fieldName] ||
-                (createIfMissing && (fieldPolicies[fieldName] = {})));
+            return this.getTypePolicy(typename).fields[fieldName];
         }
-    }
-    getSupertypeSet(subtype, createIfMissing) {
-        let supertypeSet = this.supertypeMap.get(subtype);
+    };
+    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {
+        var supertypeSet = this.supertypeMap.get(subtype);
         if (!supertypeSet && createIfMissing) {
             this.supertypeMap.set(subtype, (supertypeSet = new Set()));
         }
         return supertypeSet;
-    }
-    fragmentMatches(fragment, typename, result, variables) {
+    };
+    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {
+        var _this = this;
         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;
-        const supertype = fragment.typeCondition.name.value;
+        var 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)) {
-            const typenameSupertypeSet = this.getSupertypeSet(typename, true);
-            const workQueue = [typenameSupertypeSet];
-            const maybeEnqueue = (subtype) => {
-                const supertypeSet = this.getSupertypeSet(subtype, false);
+            var typenameSupertypeSet = this.getSupertypeSet(typename, true);
+            var workQueue_1 = [typenameSupertypeSet];
+            var maybeEnqueue_1 = function (subtype) {
+                var supertypeSet = _this.getSupertypeSet(subtype, false);
                 if (supertypeSet &&
                     supertypeSet.size &&
-                    workQueue.indexOf(supertypeSet) < 0) {
-                    workQueue.push(supertypeSet);
+                    workQueue_1.indexOf(supertypeSet) < 0) {
+                    workQueue_1.push(supertypeSet);
                 }
             };
             // We need to check fuzzy subtypes only if we encountered fuzzy
@@ -332,16 +338,16 @@ export class Policies {
             // strong signal of fragment matching. The StoreReader class calls
             // policies.fragmentMatches without passing a result object, so
             // needToCheckFuzzySubtypes is always false while reading.
-            let needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
-            let checkingFuzzySubtypes = false;
+            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
+            var 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 (let i = 0; i < workQueue.length; ++i) {
-                const supertypeSet = workQueue[i];
+            for (var i = 0; i < workQueue_1.length; ++i) {
+                var supertypeSet = workQueue_1[i];
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && invariant.warn(102, typename, supertype);
+                            globalThis.__DEV__ !== false && invariant.warn(7, typename, supertype);
                         }
                         // Record positive results for faster future lookup.
                         // Unfortunately, we cannot safely cache negative results,
@@ -351,11 +357,11 @@ export class Policies {
                     }
                     return true;
                 }
-                supertypeSet.forEach(maybeEnqueue);
+                supertypeSet.forEach(maybeEnqueue_1);
                 if (needToCheckFuzzySubtypes &&
                     // Start checking fuzzy subtypes only after exhausting all
                     // non-fuzzy subtypes (after the final iteration of the loop).
-                    i === workQueue.length - 1 &&
+                    i === workQueue_1.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
@@ -370,36 +376,36 @@ export class Policies {
                     // 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((regExp, fuzzyString) => {
-                        const match = typename.match(regExp);
+                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {
+                        var match = typename.match(regExp);
                         if (match && match[0] === typename) {
-                            maybeEnqueue(fuzzyString);
+                            maybeEnqueue_1(fuzzyString);
                         }
                     });
                 }
             }
         }
         return false;
-    }
-    hasKeyArgs(typename, fieldName) {
-        const policy = this.getFieldPolicy(typename, fieldName, false);
+    };
+    Policies.prototype.hasKeyArgs = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName);
         return !!(policy && policy.keyFn);
-    }
-    getStoreFieldName(fieldSpec) {
-        const { typename, fieldName } = fieldSpec;
-        const policy = this.getFieldPolicy(typename, fieldName, false);
-        let storeFieldName;
-        let keyFn = policy && policy.keyFn;
+    };
+    Policies.prototype.getStoreFieldName = function (fieldSpec) {
+        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;
+        var policy = this.getFieldPolicy(typename, fieldName);
+        var storeFieldName;
+        var keyFn = policy && policy.keyFn;
         if (keyFn && typename) {
-            const context = {
-                typename,
-                fieldName,
+            var context = {
+                typename: typename,
+                fieldName: fieldName,
                 field: fieldSpec.field || null,
                 variables: fieldSpec.variables,
             };
-            const args = argsFromFieldSpecifier(fieldSpec);
+            var args = argsFromFieldSpecifier(fieldSpec);
             while (keyFn) {
-                const specifierOrString = keyFn(args, context);
+                var specifierOrString = keyFn(args, context);
                 if (isArray(specifierOrString)) {
                     keyFn = keyArgsFnFromSpecifier(specifierOrString);
                 }
@@ -427,26 +433,26 @@ export class Policies {
         // StoreObject correspond to which original field names.
         return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName
             : fieldName + ":" + storeFieldName;
-    }
-    readField(options, context) {
-        const objectOrReference = options.from;
+    };
+    Policies.prototype.readField = function (options, context) {
+        var objectOrReference = options.from;
         if (!objectOrReference)
             return;
-        const nameOrField = options.field || options.fieldName;
+        var nameOrField = options.field || options.fieldName;
         if (!nameOrField)
             return;
         if (options.typename === void 0) {
-            const typename = context.store.getFieldValue(objectOrReference, "__typename");
+            var typename = context.store.getFieldValue(objectOrReference, "__typename");
             if (typename)
                 options.typename = typename;
         }
-        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;
+        var storeFieldName = this.getStoreFieldName(options);
+        var fieldName = fieldNameFromStoreName(storeFieldName);
+        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);
+        var policy = this.getFieldPolicy(options.typename, fieldName);
+        var read = policy && policy.read;
         if (read) {
-            const readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?
+            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?
                 objectOrReference.__ref
                 : objectOrReference, storeFieldName));
             // Call read(existing, readOptions) with cacheSlot holding this.cache.
@@ -456,21 +462,22 @@ export class Policies {
             ]);
         }
         return existing;
-    }
-    getReadFunction(typename, fieldName) {
-        const policy = this.getFieldPolicy(typename, fieldName, false);
+    };
+    Policies.prototype.getReadFunction = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName);
         return policy && policy.read;
-    }
-    getMergeFunction(parentTypename, fieldName, childTypename) {
-        let policy = this.getFieldPolicy(parentTypename, fieldName, false);
-        let merge = policy && policy.merge;
+    };
+    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
+        var policy = this.getFieldPolicy(parentTypename, fieldName);
+        var merge = policy && policy.merge;
         if (!merge && childTypename) {
             policy = this.getTypePolicy(childTypename);
             merge = policy && policy.merge;
         }
         return merge;
-    }
-    runMergeFunction(existing, incoming, { field, typename, merge }, context, storage) {
+    };
+    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {
+        var field = _a.field, typename = _a.typename, merge = _a.merge;
         if (merge === mergeTrueFn) {
             // Instead of going to the trouble of creating a full
             // FieldFunctionOptions object and calling mergeTrueFn, we can
@@ -501,38 +508,40 @@ export class Policies {
         // 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 || {}));
-    }
-}
+        }, context, storage || Object.create(null)));
+    };
+    return Policies;
+}());
+export { Policies };
 function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
-    const storeFieldName = policies.getStoreFieldName(fieldSpec);
-    const fieldName = fieldNameFromStoreName(storeFieldName);
-    const variables = fieldSpec.variables || context.variables;
-    const { toReference, canRead } = context.store;
+    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;
     return {
         args: argsFromFieldSpecifier(fieldSpec),
         field: fieldSpec.field || null,
-        fieldName,
-        storeFieldName,
-        variables,
-        isReference,
-        toReference,
-        storage,
+        fieldName: fieldName,
+        storeFieldName: storeFieldName,
+        variables: variables,
+        isReference: isReference,
+        toReference: toReference,
+        storage: storage,
         cache: policies.cache,
-        canRead,
-        readField(...args) {
-            return policies.readField(normalizeReadFieldOptions(args, objectOrReference, variables), context);
+        canRead: canRead,
+        readField: function () {
+            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);
         },
         mergeObjects: makeMergeObjectsFunction(context.store),
     };
 }
 export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
-    const { 0: fieldNameOrOptions, 1: from, length: argc } = readFieldArgs;
-    let options;
+    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
+    var options;
     if (typeof fieldNameOrOptions === "string") {
         options = {
             fieldName: fieldNameOrOptions,
@@ -543,15 +552,15 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
         };
     }
     else {
-        options = { ...fieldNameOrOptions };
+        options = __assign({}, fieldNameOrOptions);
         // Default to objectOrReference only when fieldNameOrOptions.from is
         // actually omitted, rather than just undefined.
         if (!hasOwn.call(options, "from")) {
             options.from = objectOrReference;
         }
     }
-    if (__DEV__ && options.from === void 0) {
-        __DEV__ && invariant.warn(103, stringifyForDisplay(Array.from(readFieldArgs)));
+    if (globalThis.__DEV__ !== false && options.from === void 0) {
+        globalThis.__DEV__ !== false && invariant.warn(8, stringifyForDisplay(Array.from(readFieldArgs)));
     }
     if (void 0 === options.variables) {
         options.variables = variables;
@@ -561,16 +570,16 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if (isArray(existing) || isArray(incoming)) {
-            throw newInvariantError(104);
+            throw newInvariantError(9);
         }
         // 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)) {
-            const eType = store.getFieldValue(existing, "__typename");
-            const iType = store.getFieldValue(incoming, "__typename");
-            const typesDiffer = eType && iType && eType !== iType;
+            var eType = store.getFieldValue(existing, "__typename");
+            var iType = store.getFieldValue(incoming, "__typename");
+            var typesDiffer = eType && iType && eType !== iType;
             if (typesDiffer) {
                 return incoming;
             }
@@ -591,10 +600,10 @@ function makeMergeObjectsFunction(store) {
             }
             if (storeValueIsStoreObject(existing) &&
                 storeValueIsStoreObject(incoming)) {
-                return { ...existing, ...incoming };
+                return __assign(__assign({}, existing), incoming);
             }
         }
         return incoming;
     };
 }
-//# sourceMappingURL=policies.js.map
+//# sourceMappingURL=policies.js.map