{"version":3,"sources":["webpack:///./node_modules/apollo-cache-inmemory/lib/bundle.esm.js"],"names":["haveWarned","shouldWarn","answer","HeuristicFragmentMatcher","prototype","ensureReady","Promise","resolve","canBypassInit","match","idValue","typeCondition","context","obj","store","get","id","isRootQuery","_a","__typename","IntrospectionFragmentMatcher","options","introspectionQueryResultData","this","possibleTypesMap","parseIntrospectionResult","isReady","bind","implementingTypes","indexOf","introspectionResultData","typeMap","__schema","types","forEach","type","kind","name","possibleTypes","map","implementingType","hasOwn","Object","hasOwnProperty","DepTrackingCache","data","_this","create","depend","dataId","disposable","makeCacheKey","toObject","set","value","oldValue","dirty","delete","call","clear","replace","newData","keys","defaultNormalizedCacheFactory","seed","StoreReader","_b","_c","cacheKeyRoot","_d","freezeResults","_e","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","query","rootValue","contextValue","variableValues","fragmentMatcher","lookup","JSON","stringify","selectionSet","execContext","field","array","readQueryFromStore","diffQueryAgainstStore","returnPartialData","result","variables","previousResult","rootId","fragmentMatcherFunction","config","queryDefinition","dataIdFromObject","cacheRedirects","execResult","generated","typename","hasMissingFields","missing","length","info","tolerable","complete","defaultFragmentMatcher","mainDefinition","fragments","fragmentMap","finalResult","objectsToMerge","object","handleMissing","push","apply","selections","selection","fieldResult","executeField","fragment","fragmentExecResult","fieldName","args","resultKey","directives","readStoreResult","readStoreResolver","Array","isArray","combineExecResults","assertSelectionSetForIdValue","execResults","_i","arguments","pop","childResult","item","assertIdValue","storeKeyName","fieldValue","resolver","getCacheKey","storeObj","json","ObjectCache","defaultNormalizedCacheFactory$1","WriteError","_super","Error","enhanceErrorWithDocument","error","document","enhancedError","message","stack","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","e","resultFieldKey","writeFieldToStore","isDefered","isClient","some","directive","matches","undefined","fakeContext","storeValue","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","index","itemDataId","generatedKey","realKey","cache","real","madeChanges","key","realValue","newRealValue","defaultConfig","defaultDataIdFromObject","addTypename","resultCaching","_id","hasOwn$1","OptimisticCacheLayer","optimisticId","parent","transaction","InMemoryCache","watches","Set","typenameDocumentCache","Map","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","c","optimistic","restore","extract","read","transformDocument","write","broadcastWatches","diff","watch","add","evict","reset","removeOptimistic","idToRemove","toReapply","removedCount","layer","layer_1","performTransaction","recordOptimisticTransaction","callback"],"mappings":"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","file":"js/npm.apollo-cache-inmemory~02134805.954c30e0.js","sourcesContent":["import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\n\nvar haveWarned = false;\nfunction shouldWarn() {\n    var answer = !haveWarned;\n    if (!isTest()) {\n        haveWarned = true;\n    }\n    return answer;\n}\nvar HeuristicFragmentMatcher = (function () {\n    function HeuristicFragmentMatcher() {\n    }\n    HeuristicFragmentMatcher.prototype.ensureReady = function () {\n        return Promise.resolve();\n    };\n    HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n        return true;\n    };\n    HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        if (!__typename) {\n            if (shouldWarn()) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n                process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" +\n                    \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n            }\n            return 'heuristic';\n        }\n        if (__typename === typeCondition) {\n            return true;\n        }\n        if (shouldWarn()) {\n            process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' +\n                'queries contain union or interface types. Apollo Client will not be ' +\n                'able to accurately map fragments. To make this error go away, use ' +\n                'the `IntrospectionFragmentMatcher` as described in the docs: ' +\n                'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n        }\n        return 'heuristic';\n    };\n    return HeuristicFragmentMatcher;\n}());\nvar IntrospectionFragmentMatcher = (function () {\n    function IntrospectionFragmentMatcher(options) {\n        if (options && options.introspectionQueryResultData) {\n            this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n            this.isReady = true;\n        }\n        else {\n            this.isReady = false;\n        }\n        this.match = this.match.bind(this);\n    }\n    IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 1) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        process.env.NODE_ENV === \"production\" ? invariant(__typename, 2) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n        if (__typename === typeCondition) {\n            return true;\n        }\n        var implementingTypes = this.possibleTypesMap[typeCondition];\n        if (__typename &&\n            implementingTypes &&\n            implementingTypes.indexOf(__typename) > -1) {\n            return true;\n        }\n        return false;\n    };\n    IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n        var typeMap = {};\n        introspectionResultData.__schema.types.forEach(function (type) {\n            if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n                typeMap[type.name] = type.possibleTypes.map(function (implementingType) { return implementingType.name; });\n            }\n        });\n        return typeMap;\n    };\n    return IntrospectionFragmentMatcher;\n}());\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar DepTrackingCache = (function () {\n    function DepTrackingCache(data) {\n        var _this = this;\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n        this.depend = wrap(function (dataId) { return _this.data[dataId]; }, {\n            disposable: true,\n            makeCacheKey: function (dataId) {\n                return dataId;\n            },\n        });\n    }\n    DepTrackingCache.prototype.toObject = function () {\n        return this.data;\n    };\n    DepTrackingCache.prototype.get = function (dataId) {\n        this.depend(dataId);\n        return this.data[dataId];\n    };\n    DepTrackingCache.prototype.set = function (dataId, value) {\n        var oldValue = this.data[dataId];\n        if (value !== oldValue) {\n            this.data[dataId] = value;\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.delete = function (dataId) {\n        if (hasOwn.call(this.data, dataId)) {\n            delete this.data[dataId];\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.clear = function () {\n        this.replace(null);\n    };\n    DepTrackingCache.prototype.replace = function (newData) {\n        var _this = this;\n        if (newData) {\n            Object.keys(newData).forEach(function (dataId) {\n                _this.set(dataId, newData[dataId]);\n            });\n            Object.keys(this.data).forEach(function (dataId) {\n                if (!hasOwn.call(newData, dataId)) {\n                    _this.delete(dataId);\n                }\n            });\n        }\n        else {\n            Object.keys(this.data).forEach(function (dataId) {\n                _this.delete(dataId);\n            });\n        }\n    };\n    return DepTrackingCache;\n}());\nfunction defaultNormalizedCacheFactory(seed) {\n    return new DepTrackingCache(seed);\n}\n\nvar StoreReader = (function () {\n    function StoreReader(_a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.cacheKeyRoot, cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c, _d = _b.freezeResults, freezeResults = _d === void 0 ? false : _d;\n        var _e = this, executeStoreQuery = _e.executeStoreQuery, executeSelectionSet = _e.executeSelectionSet, executeSubSelectedArray = _e.executeSubSelectedArray;\n        this.freezeResults = freezeResults;\n        this.executeStoreQuery = wrap(function (options) {\n            return executeStoreQuery.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, fragmentMatcher = _a.fragmentMatcher;\n                if (contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSelectionSet = wrap(function (options) {\n            return executeSelectionSet.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            return executeSubSelectedArray.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n                }\n            }\n        });\n    }\n    StoreReader.prototype.readQueryFromStore = function (options) {\n        return this.diffQueryAgainstStore(__assign(__assign({}, options), { returnPartialData: false })).result;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, variables = _a.variables, previousResult = _a.previousResult, _b = _a.returnPartialData, returnPartialData = _b === void 0 ? true : _b, _c = _a.rootId, rootId = _c === void 0 ? 'ROOT_QUERY' : _c, fragmentMatcherFunction = _a.fragmentMatcherFunction, config = _a.config;\n        var queryDefinition = getQueryDefinition(query);\n        variables = assign({}, getDefaultValues(queryDefinition), variables);\n        var context = {\n            store: store,\n            dataIdFromObject: config && config.dataIdFromObject,\n            cacheRedirects: (config && config.cacheRedirects) || {},\n        };\n        var execResult = this.executeStoreQuery({\n            query: query,\n            rootValue: {\n                type: 'id',\n                id: rootId,\n                generated: true,\n                typename: 'Query',\n            },\n            contextValue: context,\n            variableValues: variables,\n            fragmentMatcher: fragmentMatcherFunction,\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            execResult.missing.forEach(function (info) {\n                if (info.tolerable)\n                    return;\n                throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n            });\n        }\n        if (previousResult) {\n            if (isEqual(previousResult, execResult.result)) {\n                execResult.result = previousResult;\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !hasMissingFields,\n        };\n    };\n    StoreReader.prototype.executeStoreQuery = function (_a) {\n        var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, _b = _a.fragmentMatcher, fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n        var mainDefinition = getMainDefinition(query);\n        var fragments = getFragmentDefinitions(query);\n        var fragmentMap = createFragmentMap(fragments);\n        var execContext = {\n            query: query,\n            fragmentMap: fragmentMap,\n            contextValue: contextValue,\n            variableValues: variableValues,\n            fragmentMatcher: fragmentMatcher,\n        };\n        return this.executeSelectionSet({\n            selectionSet: mainDefinition.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext,\n        });\n    };\n    StoreReader.prototype.executeSelectionSet = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n        var fragmentMap = execContext.fragmentMap, contextValue = execContext.contextValue, variables = execContext.variableValues;\n        var finalResult = { result: null };\n        var objectsToMerge = [];\n        var object = contextValue.store.get(rootValue.id);\n        var typename = (object && object.__typename) ||\n            (rootValue.id === 'ROOT_QUERY' && 'Query') ||\n            void 0;\n        function handleMissing(result) {\n            var _a;\n            if (result.missing) {\n                finalResult.missing = finalResult.missing || [];\n                (_a = finalResult.missing).push.apply(_a, result.missing);\n            }\n            return result.result;\n        }\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n                if (typeof fieldResult !== 'undefined') {\n                    objectsToMerge.push((_a = {},\n                        _a[resultKeyNameFromField(selection)] = fieldResult,\n                        _a));\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = fragmentMap[selection.name.value];\n                    if (!fragment) {\n                        throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n                    }\n                }\n                var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n                var match = !typeCondition ||\n                    execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n                if (match) {\n                    var fragmentExecResult = _this.executeSelectionSet({\n                        selectionSet: fragment.selectionSet,\n                        rootValue: rootValue,\n                        execContext: execContext,\n                    });\n                    if (match === 'heuristic' && fragmentExecResult.missing) {\n                        fragmentExecResult = __assign(__assign({}, fragmentExecResult), { missing: fragmentExecResult.missing.map(function (info) {\n                                return __assign(__assign({}, info), { tolerable: true });\n                            }) });\n                    }\n                    objectsToMerge.push(handleMissing(fragmentExecResult));\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        return finalResult;\n    };\n    StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n        var variables = execContext.variableValues, contextValue = execContext.contextValue;\n        var fieldName = field.name.value;\n        var args = argumentsObjectFromField(field, variables);\n        var info = {\n            resultKey: resultKeyNameFromField(field),\n            directives: getDirectiveInfoFromField(field, variables),\n        };\n        var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n        if (Array.isArray(readStoreResult.result)) {\n            return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n                field: field,\n                array: readStoreResult.result,\n                execContext: execContext,\n            }));\n        }\n        if (!field.selectionSet) {\n            assertSelectionSetForIdValue(field, readStoreResult.result);\n            if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n                maybeDeepFreeze(readStoreResult);\n            }\n            return readStoreResult;\n        }\n        if (readStoreResult.result == null) {\n            return readStoreResult;\n        }\n        return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n            selectionSet: field.selectionSet,\n            rootValue: readStoreResult.result,\n            execContext: execContext,\n        }));\n    };\n    StoreReader.prototype.combineExecResults = function () {\n        var execResults = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            execResults[_i] = arguments[_i];\n        }\n        var missing;\n        execResults.forEach(function (execResult) {\n            if (execResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, execResult.missing);\n            }\n        });\n        return {\n            result: execResults.pop().result,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.executeSubSelectedArray = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, execContext = _a.execContext;\n        var missing;\n        function handleMissing(childResult) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            return childResult.result;\n        }\n        array = array.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    execContext: execContext,\n                }));\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    rootValue: item,\n                    execContext: execContext,\n                }));\n            }\n            assertSelectionSetForIdValue(field, item);\n            return item;\n        });\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nfunction assertSelectionSetForIdValue(field, value) {\n    if (!field.selectionSet && isIdValue(value)) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n    }\n}\nfunction defaultFragmentMatcher() {\n    return true;\n}\nfunction assertIdValue(idValue) {\n    process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n    var resultKey = _a.resultKey, directives = _a.directives;\n    var storeKeyName = fieldName;\n    if (args || directives) {\n        storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n    }\n    var fieldValue = void 0;\n    if (object) {\n        fieldValue = object[storeKeyName];\n        if (typeof fieldValue === 'undefined' &&\n            context.cacheRedirects &&\n            typeof typename === 'string') {\n            var type = context.cacheRedirects[typename];\n            if (type) {\n                var resolver = type[fieldName];\n                if (resolver) {\n                    fieldValue = resolver(object, args, {\n                        getCacheKey: function (storeObj) {\n                            var id = context.dataIdFromObject(storeObj);\n                            return id && toIdValue({\n                                id: id,\n                                typename: storeObj.__typename,\n                            });\n                        },\n                    });\n                }\n            }\n        }\n    }\n    if (typeof fieldValue === 'undefined') {\n        return {\n            result: fieldValue,\n            missing: [{\n                    object: object,\n                    fieldName: storeKeyName,\n                    tolerable: false,\n                }],\n        };\n    }\n    if (isJsonValue(fieldValue)) {\n        fieldValue = fieldValue.json;\n    }\n    return {\n        result: fieldValue,\n    };\n}\n\nvar ObjectCache = (function () {\n    function ObjectCache(data) {\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n    }\n    ObjectCache.prototype.toObject = function () {\n        return this.data;\n    };\n    ObjectCache.prototype.get = function (dataId) {\n        return this.data[dataId];\n    };\n    ObjectCache.prototype.set = function (dataId, value) {\n        this.data[dataId] = value;\n    };\n    ObjectCache.prototype.delete = function (dataId) {\n        this.data[dataId] = void 0;\n    };\n    ObjectCache.prototype.clear = function () {\n        this.data = Object.create(null);\n    };\n    ObjectCache.prototype.replace = function (newData) {\n        this.data = newData || Object.create(null);\n    };\n    return ObjectCache;\n}());\nfunction defaultNormalizedCacheFactory$1(seed) {\n    return new ObjectCache(seed);\n}\n\nvar WriteError = (function (_super) {\n    __extends(WriteError, _super);\n    function WriteError() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = 'WriteError';\n        return _this;\n    }\n    return WriteError;\n}(Error));\nfunction enhanceErrorWithDocument(error, document) {\n    var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n    enhancedError.message += '\\n' + error.message;\n    enhancedError.stack = error.stack;\n    return enhancedError;\n}\nvar StoreWriter = (function () {\n    function StoreWriter() {\n    }\n    StoreWriter.prototype.writeQueryToStore = function (_a) {\n        var query = _a.query, result = _a.result, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        return this.writeResultToStore({\n            dataId: 'ROOT_QUERY',\n            result: result,\n            document: query,\n            store: store,\n            variables: variables,\n            dataIdFromObject: dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n    };\n    StoreWriter.prototype.writeResultToStore = function (_a) {\n        var dataId = _a.dataId, result = _a.result, document = _a.document, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        var operationDefinition = getOperationDefinition(document);\n        try {\n            return this.writeSelectionSetToStore({\n                result: result,\n                dataId: dataId,\n                selectionSet: operationDefinition.selectionSet,\n                context: {\n                    store: store,\n                    processedData: {},\n                    variables: assign({}, getDefaultValues(operationDefinition), variables),\n                    dataIdFromObject: dataIdFromObject,\n                    fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n                    fragmentMatcherFunction: fragmentMatcherFunction,\n                },\n            });\n        }\n        catch (e) {\n            throw enhanceErrorWithDocument(e, document);\n        }\n    };\n    StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n        var _this = this;\n        var result = _a.result, dataId = _a.dataId, selectionSet = _a.selectionSet, context = _a.context;\n        var variables = context.variables, store = context.store, fragmentMap = context.fragmentMap;\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    _this.writeFieldToStore({\n                        dataId: dataId,\n                        value: value,\n                        field: selection,\n                        context: context,\n                    });\n                }\n                else {\n                    var isDefered = false;\n                    var isClient = false;\n                    if (selection.directives && selection.directives.length) {\n                        isDefered = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'defer'; });\n                        isClient = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'client'; });\n                    }\n                    if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n                        process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                    }\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = (fragmentMap || {})[selection.name.value];\n                    process.env.NODE_ENV === \"production\" ? invariant(fragment, 3) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n                }\n                var matches = true;\n                if (context.fragmentMatcherFunction && fragment.typeCondition) {\n                    var id = dataId || 'self';\n                    var idValue = toIdValue({ id: id, typename: undefined });\n                    var fakeContext = {\n                        store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n                        cacheRedirects: {},\n                    };\n                    var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n                    if (!isProduction() && match === 'heuristic') {\n                        process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n                    }\n                    matches = !!match;\n                }\n                if (matches) {\n                    _this.writeSelectionSetToStore({\n                        result: result,\n                        selectionSet: fragment.selectionSet,\n                        dataId: dataId,\n                        context: context,\n                    });\n                }\n            }\n        });\n        return store;\n    };\n    StoreWriter.prototype.writeFieldToStore = function (_a) {\n        var _b;\n        var field = _a.field, value = _a.value, dataId = _a.dataId, context = _a.context;\n        var variables = context.variables, dataIdFromObject = context.dataIdFromObject, store = context.store;\n        var storeValue;\n        var storeObject;\n        var storeFieldName = storeKeyNameFromField(field, variables);\n        if (!field.selectionSet || value === null) {\n            storeValue =\n                value != null && typeof value === 'object'\n                    ?\n                        { type: 'json', json: value }\n                    :\n                        value;\n        }\n        else if (Array.isArray(value)) {\n            var generatedId = dataId + \".\" + storeFieldName;\n            storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n        }\n        else {\n            var valueDataId = dataId + \".\" + storeFieldName;\n            var generated = true;\n            if (!isGeneratedId(valueDataId)) {\n                valueDataId = '$' + valueDataId;\n            }\n            if (dataIdFromObject) {\n                var semanticId = dataIdFromObject(value);\n                process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 4) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n                if (semanticId ||\n                    (typeof semanticId === 'number' && semanticId === 0)) {\n                    valueDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(valueDataId, field, context.processedData)) {\n                this.writeSelectionSetToStore({\n                    dataId: valueDataId,\n                    result: value,\n                    selectionSet: field.selectionSet,\n                    context: context,\n                });\n            }\n            var typename = value.__typename;\n            storeValue = toIdValue({ id: valueDataId, typename: typename }, generated);\n            storeObject = store.get(dataId);\n            var escapedId = storeObject && storeObject[storeFieldName];\n            if (escapedId !== storeValue && isIdValue(escapedId)) {\n                var hadTypename = escapedId.typename !== undefined;\n                var hasTypename = typename !== undefined;\n                var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n                process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 5) : invariant(!generated || escapedId.generated || typenameChanged, \"Store error: the application attempted to write an object with no provided id but the store already contains an id of \" + escapedId.id + \" for this object. The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                process.env.NODE_ENV === \"production\" ? invariant(!hadTypename || hasTypename, 6) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                if (escapedId.generated) {\n                    if (typenameChanged) {\n                        if (!generated) {\n                            store.delete(escapedId.id);\n                        }\n                    }\n                    else {\n                        mergeWithGenerated(escapedId.id, storeValue.id, store);\n                    }\n                }\n            }\n        }\n        storeObject = store.get(dataId);\n        if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n            store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n        }\n    };\n    StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n        var _this = this;\n        return value.map(function (item, index) {\n            if (item === null) {\n                return null;\n            }\n            var itemDataId = generatedId + \".\" + index;\n            if (Array.isArray(item)) {\n                return _this.processArrayValue(item, itemDataId, selectionSet, context);\n            }\n            var generated = true;\n            if (context.dataIdFromObject) {\n                var semanticId = context.dataIdFromObject(item);\n                if (semanticId) {\n                    itemDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n                _this.writeSelectionSetToStore({\n                    dataId: itemDataId,\n                    result: item,\n                    selectionSet: selectionSet,\n                    context: context,\n                });\n            }\n            return toIdValue({ id: itemDataId, typename: item.__typename }, generated);\n        });\n    };\n    return StoreWriter;\n}());\nfunction isGeneratedId(id) {\n    return id[0] === '$';\n}\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n    if (generatedKey === realKey) {\n        return false;\n    }\n    var generated = cache.get(generatedKey);\n    var real = cache.get(realKey);\n    var madeChanges = false;\n    Object.keys(generated).forEach(function (key) {\n        var value = generated[key];\n        var realValue = real[key];\n        if (isIdValue(value) &&\n            isGeneratedId(value.id) &&\n            isIdValue(realValue) &&\n            !isEqual(value, realValue) &&\n            mergeWithGenerated(value.id, realValue.id, cache)) {\n            madeChanges = true;\n        }\n    });\n    cache.delete(generatedKey);\n    var newRealValue = __assign(__assign({}, generated), real);\n    if (isEqual(newRealValue, real)) {\n        return madeChanges;\n    }\n    cache.set(realKey, newRealValue);\n    return true;\n}\nfunction isDataProcessed(dataId, field, processedData) {\n    if (!processedData) {\n        return false;\n    }\n    if (processedData[dataId]) {\n        if (processedData[dataId].indexOf(field) >= 0) {\n            return true;\n        }\n        else {\n            processedData[dataId].push(field);\n        }\n    }\n    else {\n        processedData[dataId] = [field];\n    }\n    return false;\n}\n\nvar defaultConfig = {\n    fragmentMatcher: new HeuristicFragmentMatcher(),\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    freezeResults: false,\n};\nfunction defaultDataIdFromObject(result) {\n    if (result.__typename) {\n        if (result.id !== undefined) {\n            return result.__typename + \":\" + result.id;\n        }\n        if (result._id !== undefined) {\n            return result.__typename + \":\" + result._id;\n        }\n    }\n    return null;\n}\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\nvar OptimisticCacheLayer = (function (_super) {\n    __extends(OptimisticCacheLayer, _super);\n    function OptimisticCacheLayer(optimisticId, parent, transaction) {\n        var _this = _super.call(this, Object.create(null)) || this;\n        _this.optimisticId = optimisticId;\n        _this.parent = parent;\n        _this.transaction = transaction;\n        return _this;\n    }\n    OptimisticCacheLayer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    OptimisticCacheLayer.prototype.get = function (dataId) {\n        return hasOwn$1.call(this.data, dataId)\n            ? this.data[dataId]\n            : this.parent.get(dataId);\n    };\n    return OptimisticCacheLayer;\n}(ObjectCache));\nvar InMemoryCache = (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.typenameDocumentCache = new Map();\n        _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n        _this.silenceBroadcast = false;\n        _this.config = __assign(__assign({}, defaultConfig), config);\n        if (_this.config.customResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.customResolvers;\n        }\n        if (_this.config.cacheResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.cacheResolvers;\n        }\n        _this.addTypename = !!_this.config.addTypename;\n        _this.data = _this.config.resultCaching\n            ? new DepTrackingCache()\n            : new ObjectCache();\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter();\n        _this.storeReader = new StoreReader({\n            cacheKeyRoot: _this.cacheKeyRoot,\n            freezeResults: config.freezeResults,\n        });\n        var cache = _this;\n        var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n        _this.maybeBroadcastWatch = wrap(function (c) {\n            return maybeBroadcastWatch.call(_this, c);\n        }, {\n            makeCacheKey: function (c) {\n                if (c.optimistic) {\n                    return;\n                }\n                if (c.previousResult) {\n                    return;\n                }\n                if (cache.data instanceof DepTrackingCache) {\n                    return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n                }\n            }\n        });\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).toObject();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        if (typeof options.rootId === 'string' &&\n            typeof this.data.get(options.rootId) === 'undefined') {\n            return null;\n        }\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.readQueryFromStore({\n            store: options.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(options.query),\n            variables: options.variables,\n            rootId: options.rootId,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            previousResult: options.previousResult,\n            config: this.config,\n        }) || null;\n    };\n    InMemoryCache.prototype.write = function (write) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        this.storeWriter.writeResultToStore({\n            dataId: write.dataId,\n            result: write.result,\n            variables: write.variables,\n            document: this.transformDocument(write.query),\n            store: this.data,\n            dataIdFromObject: this.config.dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.diff = function (query) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.diffQueryAgainstStore({\n            store: query.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(query.query),\n            variables: query.variables,\n            returnPartialData: query.returnPartialData,\n            previousResult: query.previousResult,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            config: this.config,\n        });\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        this.watches.add(watch);\n        return function () {\n            _this.watches.delete(watch);\n        };\n    };\n    InMemoryCache.prototype.evict = function (query) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.broadcastWatches();\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var toReapply = [];\n        var removedCount = 0;\n        var layer = this.optimisticData;\n        while (layer instanceof OptimisticCacheLayer) {\n            if (layer.optimisticId === idToRemove) {\n                ++removedCount;\n            }\n            else {\n                toReapply.push(layer);\n            }\n            layer = layer.parent;\n        }\n        if (removedCount > 0) {\n            this.optimisticData = layer;\n            while (toReapply.length > 0) {\n                var layer_1 = toReapply.pop();\n                this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n            }\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n        var _a = this, data = _a.data, silenceBroadcast = _a.silenceBroadcast;\n        this.silenceBroadcast = true;\n        if (typeof optimisticId === 'string') {\n            this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n        }\n        try {\n            transaction(this);\n        }\n        finally {\n            this.silenceBroadcast = silenceBroadcast;\n            this.data = data;\n        }\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n        return this.performTransaction(transaction, id);\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function () {\n        var _this = this;\n        if (!this.silenceBroadcast) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });\n        }\n    };\n    InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n        c.callback(this.diff({\n            query: c.query,\n            variables: c.variables,\n            previousResult: c.previousResult && c.previousResult(),\n            optimistic: c.optimistic,\n        }));\n    };\n    return InMemoryCache;\n}(ApolloCache));\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };\n//# sourceMappingURL=bundle.esm.js.map\n"],"sourceRoot":""}