planning

node_modules/apollo-client/core/LocalState.d.ts

@@ -0,0 +1,67 @@
+import { DocumentNode, FieldNode, ASTNode } from 'graphql';
+import { ApolloCache } from 'apollo-cache';
+import { FragmentMap } from 'apollo-utilities';
+import { FetchResult } from 'apollo-link';
+import ApolloClient from '../ApolloClient';
+import { Resolvers, OperationVariables } from './types';
+export declare type Resolver = (rootValue?: any, args?: any, context?: any, info?: {
+    field: FieldNode;
+    fragmentMap: FragmentMap;
+}) => any;
+export declare type VariableMap = {
+    [name: string]: any;
+};
+export declare type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean;
+export declare type ExecContext = {
+    fragmentMap: FragmentMap;
+    context: any;
+    variables: VariableMap;
+    fragmentMatcher: FragmentMatcher;
+    defaultOperationType: string;
+    exportedVariables: Record<string, any>;
+    onlyRunForcedResolvers: boolean;
+};
+export declare type LocalStateOptions<TCacheShape> = {
+    cache: ApolloCache<TCacheShape>;
+    client?: ApolloClient<TCacheShape>;
+    resolvers?: Resolvers | Resolvers[];
+    fragmentMatcher?: FragmentMatcher;
+};
+export declare class LocalState<TCacheShape> {
+    private cache;
+    private client;
+    private resolvers?;
+    private fragmentMatcher;
+    constructor({ cache, client, resolvers, fragmentMatcher, }: LocalStateOptions<TCacheShape>);
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    getResolvers(): Resolvers;
+    runResolvers<TData>({ document, remoteResult, context, variables, onlyRunForcedResolvers, }: {
+        document: DocumentNode | null;
+        remoteResult: FetchResult<TData>;
+        context?: Record<string, any>;
+        variables?: Record<string, any>;
+        onlyRunForcedResolvers?: boolean;
+    }): Promise<FetchResult<TData>>;
+    setFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    getFragmentMatcher(): FragmentMatcher;
+    clientQuery(document: DocumentNode): DocumentNode | null;
+    serverQuery(document: DocumentNode): DocumentNode | null;
+    prepareContext(context?: {}): {
+        cache: ApolloCache<TCacheShape>;
+        getCacheKey: (obj: {
+            __typename: string;
+            id: string | number;
+        }) => any;
+    };
+    addExportedVariables(document: DocumentNode, variables?: OperationVariables, context?: {}): Promise<{
+        [x: string]: any;
+    }>;
+    shouldForceResolvers(document: ASTNode): boolean;
+    private buildRootValueFromCache;
+    private resolveDocument;
+    private resolveSelectionSet;
+    private resolveField;
+    private resolveSubSelectedArray;
+}
+//# sourceMappingURL=LocalState.d.ts.map

node_modules/apollo-client/core/LocalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalState.d.ts","sourceRoot":"","sources":["../src/core/LocalState.ts"],"names":[],"mappings":"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"}

node_modules/apollo-client/core/LocalState.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var visitor_1 = require("graphql/language/visitor");
+var apollo_utilities_1 = require("apollo-utilities");
+var ts_invariant_1 = require("ts-invariant");
+var capitalizeFirstLetter_1 = require("../util/capitalizeFirstLetter");
+var LocalState = (function () {
+    function LocalState(_a) {
+        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
+        this.cache = cache;
+        if (client) {
+            this.client = client;
+        }
+        if (resolvers) {
+            this.addResolvers(resolvers);
+        }
+        if (fragmentMatcher) {
+            this.setFragmentMatcher(fragmentMatcher);
+        }
+    }
+    LocalState.prototype.addResolvers = function (resolvers) {
+        var _this = this;
+        this.resolvers = this.resolvers || {};
+        if (Array.isArray(resolvers)) {
+            resolvers.forEach(function (resolverGroup) {
+                _this.resolvers = apollo_utilities_1.mergeDeep(_this.resolvers, resolverGroup);
+            });
+        }
+        else {
+            this.resolvers = apollo_utilities_1.mergeDeep(this.resolvers, resolvers);
+        }
+    };
+    LocalState.prototype.setResolvers = function (resolvers) {
+        this.resolvers = {};
+        this.addResolvers(resolvers);
+    };
+    LocalState.prototype.getResolvers = function () {
+        return this.resolvers || {};
+    };
+    LocalState.prototype.runResolvers = function (_a) {
+        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_c) {
+                if (document) {
+                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib_1.__assign(tslib_1.__assign({}, remoteResult), { data: localResult.result })); })];
+                }
+                return [2, remoteResult];
+            });
+        });
+    };
+    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {
+        this.fragmentMatcher = fragmentMatcher;
+    };
+    LocalState.prototype.getFragmentMatcher = function () {
+        return this.fragmentMatcher;
+    };
+    LocalState.prototype.clientQuery = function (document) {
+        if (apollo_utilities_1.hasDirectives(['client'], document)) {
+            if (this.resolvers) {
+                return document;
+            }
+            ts_invariant_1.invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +
+                'were specified. This means ApolloClient local resolver handling ' +
+                'has been disabled, and @client directives will be passed through ' +
+                'to your link chain.');
+        }
+        return null;
+    };
+    LocalState.prototype.serverQuery = function (document) {
+        return this.resolvers ? apollo_utilities_1.removeClientSetsFromDocument(document) : document;
+    };
+    LocalState.prototype.prepareContext = function (context) {
+        if (context === void 0) { context = {}; }
+        var cache = this.cache;
+        var newContext = tslib_1.__assign(tslib_1.__assign({}, context), { cache: cache, getCacheKey: function (obj) {
+                if (cache.config) {
+                    return cache.config.dataIdFromObject(obj);
+                }
+                else {
+                    ts_invariant_1.invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +
+                        'a configurable dataIdFromObject, like apollo-cache-inmemory.');
+                }
+            } });
+        return newContext;
+    };
+    LocalState.prototype.addExportedVariables = function (document, variables, context) {
+        if (variables === void 0) { variables = {}; }
+        if (context === void 0) { context = {}; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (document) {
+                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib_1.__assign(tslib_1.__assign({}, variables), data.exportedVariables)); })];
+                }
+                return [2, tslib_1.__assign({}, variables)];
+            });
+        });
+    };
+    LocalState.prototype.shouldForceResolvers = function (document) {
+        var forceResolvers = false;
+        visitor_1.visit(document, {
+            Directive: {
+                enter: function (node) {
+                    if (node.name.value === 'client' && node.arguments) {
+                        forceResolvers = node.arguments.some(function (arg) {
+                            return arg.name.value === 'always' &&
+                                arg.value.kind === 'BooleanValue' &&
+                                arg.value.value === true;
+                        });
+                        if (forceResolvers) {
+                            return visitor_1.BREAK;
+                        }
+                    }
+                },
+            },
+        });
+        return forceResolvers;
+    };
+    LocalState.prototype.buildRootValueFromCache = function (document, variables) {
+        return this.cache.diff({
+            query: apollo_utilities_1.buildQueryFromSelectionSet(document),
+            variables: variables,
+            returnPartialData: true,
+            optimistic: false,
+        }).result;
+    };
+    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {
+        if (context === void 0) { context = {}; }
+        if (variables === void 0) { variables = {}; }
+        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
+        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;
+            return tslib_1.__generator(this, function (_b) {
+                mainDefinition = apollo_utilities_1.getMainDefinition(document);
+                fragments = apollo_utilities_1.getFragmentDefinitions(document);
+                fragmentMap = apollo_utilities_1.createFragmentMap(fragments);
+                definitionOperation = mainDefinition
+                    .operation;
+                defaultOperationType = definitionOperation
+                    ? capitalizeFirstLetter_1.capitalizeFirstLetter(definitionOperation)
+                    : 'Query';
+                _a = this, cache = _a.cache, client = _a.client;
+                execContext = {
+                    fragmentMap: fragmentMap,
+                    context: tslib_1.__assign(tslib_1.__assign({}, context), { cache: cache,
+                        client: client }),
+                    variables: variables,
+                    fragmentMatcher: fragmentMatcher,
+                    defaultOperationType: defaultOperationType,
+                    exportedVariables: {},
+                    onlyRunForcedResolvers: onlyRunForcedResolvers,
+                };
+                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({
+                        result: result,
+                        exportedVariables: execContext.exportedVariables,
+                    }); })];
+            });
+        });
+    };
+    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var fragmentMap, context, variables, resultsToMerge, execute;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
+                resultsToMerge = [rootValue];
+                execute = function (selection) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var fragment, typeCondition;
+                    return tslib_1.__generator(this, function (_a) {
+                        if (!apollo_utilities_1.shouldInclude(selection, variables)) {
+                            return [2];
+                        }
+                        if (apollo_utilities_1.isField(selection)) {
+                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {
+                                    var _a;
+                                    if (typeof fieldResult !== 'undefined') {
+                                        resultsToMerge.push((_a = {},
+                                            _a[apollo_utilities_1.resultKeyNameFromField(selection)] = fieldResult,
+                                            _a));
+                                    }
+                                })];
+                        }
+                        if (apollo_utilities_1.isInlineFragment(selection)) {
+                            fragment = selection;
+                        }
+                        else {
+                            fragment = fragmentMap[selection.name.value];
+                            ts_invariant_1.invariant(fragment, "No fragment named " + selection.name.value);
+                        }
+                        if (fragment && fragment.typeCondition) {
+                            typeCondition = fragment.typeCondition.name.value;
+                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
+                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {
+                                        resultsToMerge.push(fragmentResult);
+                                    })];
+                            }
+                        }
+                        return [2];
+                    });
+                }); };
+                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {
+                        return apollo_utilities_1.mergeDeepArray(resultsToMerge);
+                    })];
+            });
+        });
+    };
+    LocalState.prototype.resolveField = function (field, rootValue, execContext) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                variables = execContext.variables;
+                fieldName = field.name.value;
+                aliasedFieldName = apollo_utilities_1.resultKeyNameFromField(field);
+                aliasUsed = fieldName !== aliasedFieldName;
+                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];
+                resultPromise = Promise.resolve(defaultResult);
+                if (!execContext.onlyRunForcedResolvers ||
+                    this.shouldForceResolvers(field)) {
+                    resolverType = rootValue.__typename || execContext.defaultOperationType;
+                    resolverMap = this.resolvers && this.resolvers[resolverType];
+                    if (resolverMap) {
+                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];
+                        if (resolve) {
+                            resultPromise = Promise.resolve(resolve(rootValue, apollo_utilities_1.argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));
+                        }
+                    }
+                }
+                return [2, resultPromise.then(function (result) {
+                        if (result === void 0) { result = defaultResult; }
+                        if (field.directives) {
+                            field.directives.forEach(function (directive) {
+                                if (directive.name.value === 'export' && directive.arguments) {
+                                    directive.arguments.forEach(function (arg) {
+                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {
+                                            execContext.exportedVariables[arg.value.value] = result;
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                        if (!field.selectionSet) {
+                            return result;
+                        }
+                        if (result == null) {
+                            return result;
+                        }
+                        if (Array.isArray(result)) {
+                            return _this.resolveSubSelectedArray(field, result, execContext);
+                        }
+                        if (field.selectionSet) {
+                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);
+                        }
+                    })];
+            });
+        });
+    };
+    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {
+        var _this = this;
+        return Promise.all(result.map(function (item) {
+            if (item === null) {
+                return null;
+            }
+            if (Array.isArray(item)) {
+                return _this.resolveSubSelectedArray(field, item, execContext);
+            }
+            if (field.selectionSet) {
+                return _this.resolveSelectionSet(field.selectionSet, item, execContext);
+            }
+        }));
+    };
+    return LocalState;
+}());
+exports.LocalState = LocalState;
+//# sourceMappingURL=LocalState.js.map

node_modules/apollo-client/core/ObservableQuery.d.ts

@@ -0,0 +1,75 @@
+import { GraphQLError } from 'graphql';
+import { NetworkStatus } from './networkStatus';
+import { Observable } from '../util/Observable';
+import { ApolloError } from '../errors/ApolloError';
+import { QueryManager } from './QueryManager';
+import { ApolloQueryResult, OperationVariables } from './types';
+import { WatchQueryOptions, FetchMoreQueryOptions, SubscribeToMoreOptions, ErrorPolicy } from './watchQueryOptions';
+import { QueryStoreValue } from '../data/queries';
+export declare type ApolloCurrentResult<T> = {
+    data: T | {};
+    errors?: ReadonlyArray<GraphQLError>;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    error?: ApolloError;
+    partial?: boolean;
+};
+export declare type ApolloCurrentQueryResult<T> = {
+    data: T | undefined;
+    errors?: ReadonlyArray<GraphQLError>;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    error?: ApolloError;
+    partial?: boolean;
+    stale?: boolean;
+};
+export interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
+    updateQuery: (previousQueryResult: TData, options: {
+        fetchMoreResult?: TData;
+        variables?: TVariables;
+    }) => TData;
+}
+export interface UpdateQueryOptions<TVariables> {
+    variables?: TVariables;
+}
+export declare const hasError: (storeValue: QueryStoreValue, policy?: ErrorPolicy) => boolean | Error;
+export declare class ObservableQuery<TData = any, TVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {
+    options: WatchQueryOptions<TVariables>;
+    readonly queryId: string;
+    readonly queryName?: string;
+    variables: TVariables;
+    private shouldSubscribe;
+    private isTornDown;
+    private queryManager;
+    private observers;
+    private subscriptions;
+    private lastResult;
+    private lastResultSnapshot;
+    private lastError;
+    constructor({ queryManager, options, shouldSubscribe, }: {
+        queryManager: QueryManager<any>;
+        options: WatchQueryOptions<TVariables>;
+        shouldSubscribe?: boolean;
+    });
+    result(): Promise<ApolloQueryResult<TData>>;
+    currentResult(): ApolloCurrentResult<TData>;
+    getCurrentResult(): ApolloCurrentQueryResult<TData>;
+    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>): boolean;
+    getLastResult(): ApolloQueryResult<TData>;
+    getLastError(): ApolloError;
+    resetLastResults(): void;
+    resetQueryStoreErrors(): void;
+    refetch(variables?: TVariables): Promise<ApolloQueryResult<TData>>;
+    fetchMore<K extends keyof TVariables>(fetchMoreOptions: FetchMoreQueryOptions<TVariables, K> & FetchMoreOptions<TData, TVariables>): Promise<ApolloQueryResult<TData>>;
+    subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>): () => void;
+    setOptions(opts: WatchQueryOptions): Promise<ApolloQueryResult<TData> | void>;
+    setVariables(variables: TVariables, tryFetch?: boolean, fetchResults?: boolean): Promise<ApolloQueryResult<TData> | void>;
+    updateQuery<TVars = TVariables>(mapFn: (previousQueryResult: TData, options: UpdateQueryOptions<TVars>) => TData): void;
+    stopPolling(): void;
+    startPolling(pollInterval: number): void;
+    private updateLastResult;
+    private onSubscribe;
+    private setUpQuery;
+    private tearDownQuery;
+}
+//# sourceMappingURL=ObservableQuery.d.ts.map

node_modules/apollo-client/core/ObservableQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableQuery.d.ts","sourceRoot":"","sources":["../src/core/ObservableQuery.ts"],"names":[],"mappings":"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"}

node_modules/apollo-client/core/ObservableQuery.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var apollo_utilities_1 = require("apollo-utilities");
+var networkStatus_1 = require("./networkStatus");
+var Observable_1 = require("../util/Observable");
+var ApolloError_1 = require("../errors/ApolloError");
+var types_1 = require("./types");
+var ts_invariant_1 = require("ts-invariant");
+var arrays_1 = require("../util/arrays");
+exports.hasError = function (storeValue, policy) {
+    if (policy === void 0) { policy = 'none'; }
+    return storeValue && (storeValue.networkError ||
+        (policy === 'none' && arrays_1.isNonEmptyArray(storeValue.graphQLErrors)));
+};
+var ObservableQuery = (function (_super) {
+    tslib_1.__extends(ObservableQuery, _super);
+    function ObservableQuery(_a) {
+        var queryManager = _a.queryManager, options = _a.options, _b = _a.shouldSubscribe, shouldSubscribe = _b === void 0 ? true : _b;
+        var _this = _super.call(this, function (observer) {
+            return _this.onSubscribe(observer);
+        }) || this;
+        _this.observers = new Set();
+        _this.subscriptions = new Set();
+        _this.isTornDown = false;
+        _this.options = options;
+        _this.variables = options.variables || {};
+        _this.queryId = queryManager.generateQueryId();
+        _this.shouldSubscribe = shouldSubscribe;
+        var opDef = apollo_utilities_1.getOperationDefinition(options.query);
+        _this.queryName = opDef && opDef.name && opDef.name.value;
+        _this.queryManager = queryManager;
+        return _this;
+    }
+    ObservableQuery.prototype.result = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var observer = {
+                next: function (result) {
+                    resolve(result);
+                    _this.observers.delete(observer);
+                    if (!_this.observers.size) {
+                        _this.queryManager.removeQuery(_this.queryId);
+                    }
+                    setTimeout(function () {
+                        subscription.unsubscribe();
+                    }, 0);
+                },
+                error: reject,
+            };
+            var subscription = _this.subscribe(observer);
+        });
+    };
+    ObservableQuery.prototype.currentResult = function () {
+        var result = this.getCurrentResult();
+        if (result.data === undefined) {
+            result.data = {};
+        }
+        return result;
+    };
+    ObservableQuery.prototype.getCurrentResult = function () {
+        if (this.isTornDown) {
+            var lastResult = this.lastResult;
+            return {
+                data: !this.lastError && lastResult && lastResult.data || void 0,
+                error: this.lastError,
+                loading: false,
+                networkStatus: networkStatus_1.NetworkStatus.error,
+            };
+        }
+        var _a = this.queryManager.getCurrentQueryResult(this), data = _a.data, partial = _a.partial;
+        var queryStoreValue = this.queryManager.queryStore.get(this.queryId);
+        var result;
+        var fetchPolicy = this.options.fetchPolicy;
+        var isNetworkFetchPolicy = fetchPolicy === 'network-only' ||
+            fetchPolicy === 'no-cache';
+        if (queryStoreValue) {
+            var networkStatus = queryStoreValue.networkStatus;
+            if (exports.hasError(queryStoreValue, this.options.errorPolicy)) {
+                return {
+                    data: void 0,
+                    loading: false,
+                    networkStatus: networkStatus,
+                    error: new ApolloError_1.ApolloError({
+                        graphQLErrors: queryStoreValue.graphQLErrors,
+                        networkError: queryStoreValue.networkError,
+                    }),
+                };
+            }
+            if (queryStoreValue.variables) {
+                this.options.variables = tslib_1.__assign(tslib_1.__assign({}, this.options.variables), queryStoreValue.variables);
+                this.variables = this.options.variables;
+            }
+            result = {
+                data: data,
+                loading: networkStatus_1.isNetworkRequestInFlight(networkStatus),
+                networkStatus: networkStatus,
+            };
+            if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {
+                result.errors = queryStoreValue.graphQLErrors;
+            }
+        }
+        else {
+            var loading = isNetworkFetchPolicy ||
+                (partial && fetchPolicy !== 'cache-only');
+            result = {
+                data: data,
+                loading: loading,
+                networkStatus: loading ? networkStatus_1.NetworkStatus.loading : networkStatus_1.NetworkStatus.ready,
+            };
+        }
+        if (!partial) {
+            this.updateLastResult(tslib_1.__assign(tslib_1.__assign({}, result), { stale: false }));
+        }
+        return tslib_1.__assign(tslib_1.__assign({}, result), { partial: partial });
+    };
+    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {
+        var snapshot = this.lastResultSnapshot;
+        return !(snapshot &&
+            newResult &&
+            snapshot.networkStatus === newResult.networkStatus &&
+            snapshot.stale === newResult.stale &&
+            apollo_utilities_1.isEqual(snapshot.data, newResult.data));
+    };
+    ObservableQuery.prototype.getLastResult = function () {
+        return this.lastResult;
+    };
+    ObservableQuery.prototype.getLastError = function () {
+        return this.lastError;
+    };
+    ObservableQuery.prototype.resetLastResults = function () {
+        delete this.lastResult;
+        delete this.lastResultSnapshot;
+        delete this.lastError;
+        this.isTornDown = false;
+    };
+    ObservableQuery.prototype.resetQueryStoreErrors = function () {
+        var queryStore = this.queryManager.queryStore.get(this.queryId);
+        if (queryStore) {
+            queryStore.networkError = null;
+            queryStore.graphQLErrors = [];
+        }
+    };
+    ObservableQuery.prototype.refetch = function (variables) {
+        var fetchPolicy = this.options.fetchPolicy;
+        if (fetchPolicy === 'cache-only') {
+            return Promise.reject(new ts_invariant_1.InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));
+        }
+        if (fetchPolicy !== 'no-cache' &&
+            fetchPolicy !== 'cache-and-network') {
+            fetchPolicy = 'network-only';
+        }
+        if (!apollo_utilities_1.isEqual(this.variables, variables)) {
+            this.variables = tslib_1.__assign(tslib_1.__assign({}, this.variables), variables);
+        }
+        if (!apollo_utilities_1.isEqual(this.options.variables, this.variables)) {
+            this.options.variables = tslib_1.__assign(tslib_1.__assign({}, this.options.variables), this.variables);
+        }
+        return this.queryManager.fetchQuery(this.queryId, tslib_1.__assign(tslib_1.__assign({}, this.options), { fetchPolicy: fetchPolicy }), types_1.FetchType.refetch);
+    };
+    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {
+        var _this = this;
+        ts_invariant_1.invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');
+        var combinedOptions = tslib_1.__assign(tslib_1.__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, this.options), fetchMoreOptions), { variables: tslib_1.__assign(tslib_1.__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });
+        var qid = this.queryManager.generateQueryId();
+        return this.queryManager
+            .fetchQuery(qid, combinedOptions, types_1.FetchType.normal, this.queryId)
+            .then(function (fetchMoreResult) {
+            _this.updateQuery(function (previousResult) {
+                return fetchMoreOptions.updateQuery(previousResult, {
+                    fetchMoreResult: fetchMoreResult.data,
+                    variables: combinedOptions.variables,
+                });
+            });
+            _this.queryManager.stopQuery(qid);
+            return fetchMoreResult;
+        }, function (error) {
+            _this.queryManager.stopQuery(qid);
+            throw error;
+        });
+    };
+    ObservableQuery.prototype.subscribeToMore = function (options) {
+        var _this = this;
+        var subscription = this.queryManager
+            .startGraphQLSubscription({
+            query: options.document,
+            variables: options.variables,
+        })
+            .subscribe({
+            next: function (subscriptionData) {
+                var updateQuery = options.updateQuery;
+                if (updateQuery) {
+                    _this.updateQuery(function (previous, _a) {
+                        var variables = _a.variables;
+                        return updateQuery(previous, {
+                            subscriptionData: subscriptionData,
+                            variables: variables,
+                        });
+                    });
+                }
+            },
+            error: function (err) {
+                if (options.onError) {
+                    options.onError(err);
+                    return;
+                }
+                ts_invariant_1.invariant.error('Unhandled GraphQL subscription error', err);
+            },
+        });
+        this.subscriptions.add(subscription);
+        return function () {
+            if (_this.subscriptions.delete(subscription)) {
+                subscription.unsubscribe();
+            }
+        };
+    };
+    ObservableQuery.prototype.setOptions = function (opts) {
+        var oldFetchPolicy = this.options.fetchPolicy;
+        this.options = tslib_1.__assign(tslib_1.__assign({}, this.options), opts);
+        if (opts.pollInterval) {
+            this.startPolling(opts.pollInterval);
+        }
+        else if (opts.pollInterval === 0) {
+            this.stopPolling();
+        }
+        var fetchPolicy = opts.fetchPolicy;
+        return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' ||
+            oldFetchPolicy === 'standby' ||
+            fetchPolicy === 'network-only'), opts.fetchResults);
+    };
+    ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {
+        if (tryFetch === void 0) { tryFetch = false; }
+        if (fetchResults === void 0) { fetchResults = true; }
+        this.isTornDown = false;
+        variables = variables || this.variables;
+        if (!tryFetch && apollo_utilities_1.isEqual(variables, this.variables)) {
+            return this.observers.size && fetchResults
+                ? this.result()
+                : Promise.resolve();
+        }
+        this.variables = this.options.variables = variables;
+        if (!this.observers.size) {
+            return Promise.resolve();
+        }
+        return this.queryManager.fetchQuery(this.queryId, this.options);
+    };
+    ObservableQuery.prototype.updateQuery = function (mapFn) {
+        var queryManager = this.queryManager;
+        var _a = queryManager.getQueryWithPreviousResult(this.queryId), previousResult = _a.previousResult, variables = _a.variables, document = _a.document;
+        var newResult = apollo_utilities_1.tryFunctionOrLogError(function () {
+            return mapFn(previousResult, { variables: variables });
+        });
+        if (newResult) {
+            queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);
+            queryManager.broadcastQueries();
+        }
+    };
+    ObservableQuery.prototype.stopPolling = function () {
+        this.queryManager.stopPollingQuery(this.queryId);
+        this.options.pollInterval = undefined;
+    };
+    ObservableQuery.prototype.startPolling = function (pollInterval) {
+        assertNotCacheFirstOrOnly(this);
+        this.options.pollInterval = pollInterval;
+        this.queryManager.startPollingQuery(this.options, this.queryId);
+    };
+    ObservableQuery.prototype.updateLastResult = function (newResult) {
+        var previousResult = this.lastResult;
+        this.lastResult = newResult;
+        this.lastResultSnapshot = this.queryManager.assumeImmutableResults
+            ? newResult
+            : apollo_utilities_1.cloneDeep(newResult);
+        return previousResult;
+    };
+    ObservableQuery.prototype.onSubscribe = function (observer) {
+        var _this = this;
+        try {
+            var subObserver = observer._subscription._observer;
+            if (subObserver && !subObserver.error) {
+                subObserver.error = defaultSubscriptionObserverErrorCallback;
+            }
+        }
+        catch (_a) { }
+        var first = !this.observers.size;
+        this.observers.add(observer);
+        if (observer.next && this.lastResult)
+            observer.next(this.lastResult);
+        if (observer.error && this.lastError)
+            observer.error(this.lastError);
+        if (first) {
+            this.setUpQuery();
+        }
+        return function () {
+            if (_this.observers.delete(observer) && !_this.observers.size) {
+                _this.tearDownQuery();
+            }
+        };
+    };
+    ObservableQuery.prototype.setUpQuery = function () {
+        var _this = this;
+        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;
+        if (this.shouldSubscribe) {
+            queryManager.addObservableQuery(queryId, this);
+        }
+        if (this.options.pollInterval) {
+            assertNotCacheFirstOrOnly(this);
+            queryManager.startPollingQuery(this.options, queryId);
+        }
+        var onError = function (error) {
+            _this.updateLastResult(tslib_1.__assign(tslib_1.__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: networkStatus_1.NetworkStatus.error, loading: false }));
+            iterateObserversSafely(_this.observers, 'error', _this.lastError = error);
+        };
+        queryManager.observeQuery(queryId, this.options, {
+            next: function (result) {
+                if (_this.lastError || _this.isDifferentFromLastResult(result)) {
+                    var previousResult_1 = _this.updateLastResult(result);
+                    var _a = _this.options, query_1 = _a.query, variables = _a.variables, fetchPolicy_1 = _a.fetchPolicy;
+                    if (queryManager.transform(query_1).hasClientExports) {
+                        queryManager.getLocalState().addExportedVariables(query_1, variables).then(function (variables) {
+                            var previousVariables = _this.variables;
+                            _this.variables = _this.options.variables = variables;
+                            if (!result.loading &&
+                                previousResult_1 &&
+                                fetchPolicy_1 !== 'cache-only' &&
+                                queryManager.transform(query_1).serverQuery &&
+                                !apollo_utilities_1.isEqual(previousVariables, variables)) {
+                                _this.refetch();
+                            }
+                            else {
+                                iterateObserversSafely(_this.observers, 'next', result);
+                            }
+                        });
+                    }
+                    else {
+                        iterateObserversSafely(_this.observers, 'next', result);
+                    }
+                }
+            },
+            error: onError,
+        }).catch(onError);
+    };
+    ObservableQuery.prototype.tearDownQuery = function () {
+        var queryManager = this.queryManager;
+        this.isTornDown = true;
+        queryManager.stopPollingQuery(this.queryId);
+        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
+        this.subscriptions.clear();
+        queryManager.removeObservableQuery(this.queryId);
+        queryManager.stopQuery(this.queryId);
+        this.observers.clear();
+    };
+    return ObservableQuery;
+}(Observable_1.Observable));
+exports.ObservableQuery = ObservableQuery;
+function defaultSubscriptionObserverErrorCallback(error) {
+    ts_invariant_1.invariant.error('Unhandled error', error.message, error.stack);
+}
+function iterateObserversSafely(observers, method, argument) {
+    var observersWithMethod = [];
+    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });
+    observersWithMethod.forEach(function (obs) { return obs[method](argument); });
+}
+function assertNotCacheFirstOrOnly(obsQuery) {
+    var fetchPolicy = obsQuery.options.fetchPolicy;
+    ts_invariant_1.invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');
+}
+//# sourceMappingURL=ObservableQuery.js.map

node_modules/apollo-client/core/QueryManager.d.ts

@@ -0,0 +1,102 @@
+import { ApolloLink, FetchResult } from 'apollo-link';
+import { DocumentNode } from 'graphql';
+import { Cache } from 'apollo-cache';
+import { Observer, Subscription, Observable } from '../util/Observable';
+import { DataStore } from '../data/store';
+import { MutationStore } from '../data/mutations';
+import { QueryStore } from '../data/queries';
+import { QueryOptions, WatchQueryOptions, SubscriptionOptions, MutationOptions } from './watchQueryOptions';
+import { ObservableQuery } from './ObservableQuery';
+import { QueryListener, ApolloQueryResult, FetchType, OperationVariables } from './types';
+import { LocalState } from './LocalState';
+export interface QueryInfo {
+    listeners: Set<QueryListener>;
+    invalidated: boolean;
+    newData: Cache.DiffResult<any> | null;
+    document: DocumentNode | null;
+    lastRequestId: number;
+    observableQuery: ObservableQuery<any> | null;
+    subscriptions: Set<Subscription>;
+    cancel?: () => void;
+}
+export declare class QueryManager<TStore> {
+    link: ApolloLink;
+    mutationStore: MutationStore;
+    queryStore: QueryStore;
+    dataStore: DataStore<TStore>;
+    readonly assumeImmutableResults: boolean;
+    private queryDeduplication;
+    private clientAwareness;
+    private localState;
+    private onBroadcast;
+    private ssrMode;
+    private idCounter;
+    private queries;
+    private fetchQueryRejectFns;
+    constructor({ link, queryDeduplication, store, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
+        link: ApolloLink;
+        queryDeduplication?: boolean;
+        store: DataStore<TStore>;
+        onBroadcast?: () => void;
+        ssrMode?: boolean;
+        clientAwareness?: Record<string, string>;
+        localState?: LocalState<TStore>;
+        assumeImmutableResults?: boolean;
+    });
+    stop(): void;
+    mutate<T>({ mutation, variables, optimisticResponse, updateQueries: updateQueriesByName, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, errorPolicy, fetchPolicy, context, }: MutationOptions): Promise<FetchResult<T>>;
+    fetchQuery<T>(queryId: string, options: WatchQueryOptions, fetchType?: FetchType, fetchMoreForQueryId?: string): Promise<FetchResult<T>>;
+    private markQueryResult;
+    queryListenerForObserver<T>(queryId: string, options: WatchQueryOptions, observer: Observer<ApolloQueryResult<T>>): QueryListener;
+    private transformCache;
+    transform(document: DocumentNode): Readonly<{
+        document: Readonly<DocumentNode>;
+        hasClientExports: boolean;
+        hasForcedResolvers: boolean;
+        clientQuery: Readonly<DocumentNode> | null;
+        serverQuery: Readonly<DocumentNode> | null;
+        defaultVars: Readonly<OperationVariables>;
+    }>;
+    private getVariables;
+    watchQuery<T, TVariables = OperationVariables>(options: WatchQueryOptions, shouldSubscribe?: boolean): ObservableQuery<T, TVariables>;
+    query<T>(options: QueryOptions): Promise<ApolloQueryResult<T>>;
+    generateQueryId(): string;
+    stopQueryInStore(queryId: string): void;
+    private stopQueryInStoreNoBroadcast;
+    addQueryListener(queryId: string, listener: QueryListener): void;
+    updateQueryWatch(queryId: string, document: DocumentNode, options: WatchQueryOptions): () => void;
+    addObservableQuery<T>(queryId: string, observableQuery: ObservableQuery<T>): void;
+    removeObservableQuery(queryId: string): void;
+    clearStore(): Promise<void>;
+    resetStore(): Promise<ApolloQueryResult<any>[]>;
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    observeQuery<T>(queryId: string, options: WatchQueryOptions, observer: Observer<ApolloQueryResult<T>>): Promise<FetchResult<T, Record<string, any>, Record<string, any>>>;
+    startQuery<T>(queryId: string, options: WatchQueryOptions, listener: QueryListener): string;
+    startGraphQLSubscription<T = any>({ query, fetchPolicy, variables, }: SubscriptionOptions): Observable<FetchResult<T>>;
+    stopQuery(queryId: string): void;
+    private stopQueryNoBroadcast;
+    removeQuery(queryId: string): void;
+    getCurrentQueryResult<T>(observableQuery: ObservableQuery<T>, optimistic?: boolean): {
+        data: T | undefined;
+        partial: boolean;
+    };
+    getQueryWithPreviousResult<TData, TVariables = OperationVariables>(queryIdOrObservable: string | ObservableQuery<TData, TVariables>): {
+        previousResult: any;
+        variables: TVariables | undefined;
+        document: DocumentNode;
+    };
+    broadcastQueries(): void;
+    getLocalState(): LocalState<TStore>;
+    private inFlightLinkObservables;
+    private getObservableFromLink;
+    private fetchRequest;
+    private getQuery;
+    private setQuery;
+    private invalidate;
+    private prepareContext;
+    checkInFlight(queryId: string): boolean;
+    private pollingInfoByQueryId;
+    startPollingQuery(options: WatchQueryOptions, queryId: string, listener?: QueryListener): string;
+    stopPollingQuery(queryId: string): void;
+}
+//# sourceMappingURL=QueryManager.d.ts.map

node_modules/apollo-client/core/QueryManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryManager.d.ts","sourceRoot":"","sources":["../src/core/QueryManager.ts"],"names":[],"mappings":"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"}

node_modules/apollo-client/core/QueryManager.js

@@ -0,0 +1,867 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var apollo_link_1 = require("apollo-link");
+var apollo_utilities_1 = require("apollo-utilities");
+var ts_invariant_1 = require("ts-invariant");
+var ApolloError_1 = require("../errors/ApolloError");
+var Observable_1 = require("../util/Observable");
+var mutations_1 = require("../data/mutations");
+var queries_1 = require("../data/queries");
+var ObservableQuery_1 = require("./ObservableQuery");
+var networkStatus_1 = require("./networkStatus");
+var types_1 = require("./types");
+var LocalState_1 = require("./LocalState");
+var observables_1 = require("../util/observables");
+var arrays_1 = require("../util/arrays");
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var QueryManager = (function () {
+    function QueryManager(_a) {
+        var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;
+        this.mutationStore = new mutations_1.MutationStore();
+        this.queryStore = new queries_1.QueryStore();
+        this.clientAwareness = {};
+        this.idCounter = 1;
+        this.queries = new Map();
+        this.fetchQueryRejectFns = new Map();
+        this.transformCache = new (apollo_utilities_1.canUseWeakMap ? WeakMap : Map)();
+        this.inFlightLinkObservables = new Map();
+        this.pollingInfoByQueryId = new Map();
+        this.link = link;
+        this.queryDeduplication = queryDeduplication;
+        this.dataStore = store;
+        this.onBroadcast = onBroadcast;
+        this.clientAwareness = clientAwareness;
+        this.localState = localState || new LocalState_1.LocalState({ cache: store.getCache() });
+        this.ssrMode = ssrMode;
+        this.assumeImmutableResults = !!assumeImmutableResults;
+    }
+    QueryManager.prototype.stop = function () {
+        var _this = this;
+        this.queries.forEach(function (_info, queryId) {
+            _this.stopQueryNoBroadcast(queryId);
+        });
+        this.fetchQueryRejectFns.forEach(function (reject) {
+            reject(new ts_invariant_1.InvariantError('QueryManager stopped while query was in flight'));
+        });
+    };
+    QueryManager.prototype.mutate = function (_a) {
+        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var mutationId, generateUpdateQueriesInfo, self;
+            var _this = this;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        ts_invariant_1.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');
+                        ts_invariant_1.invariant(!fetchPolicy || fetchPolicy === 'no-cache', "Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.");
+                        mutationId = this.generateQueryId();
+                        mutation = this.transform(mutation).document;
+                        this.setQuery(mutationId, function () { return ({ document: mutation }); });
+                        variables = this.getVariables(mutation, variables);
+                        if (!this.transform(mutation).hasClientExports) return [3, 2];
+                        return [4, this.localState.addExportedVariables(mutation, variables, context)];
+                    case 1:
+                        variables = _f.sent();
+                        _f.label = 2;
+                    case 2:
+                        generateUpdateQueriesInfo = function () {
+                            var ret = {};
+                            if (updateQueriesByName) {
+                                _this.queries.forEach(function (_a, queryId) {
+                                    var observableQuery = _a.observableQuery;
+                                    if (observableQuery) {
+                                        var queryName = observableQuery.queryName;
+                                        if (queryName &&
+                                            hasOwnProperty.call(updateQueriesByName, queryName)) {
+                                            ret[queryId] = {
+                                                updater: updateQueriesByName[queryName],
+                                                query: _this.queryStore.get(queryId),
+                                            };
+                                        }
+                                    }
+                                });
+                            }
+                            return ret;
+                        };
+                        this.mutationStore.initMutation(mutationId, mutation, variables);
+                        this.dataStore.markMutationInit({
+                            mutationId: mutationId,
+                            document: mutation,
+                            variables: variables,
+                            updateQueries: generateUpdateQueriesInfo(),
+                            update: updateWithProxyFn,
+                            optimisticResponse: optimisticResponse,
+                        });
+                        this.broadcastQueries();
+                        self = this;
+                        return [2, new Promise(function (resolve, reject) {
+                                var storeResult;
+                                var error;
+                                self.getObservableFromLink(mutation, tslib_1.__assign(tslib_1.__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({
+                                    next: function (result) {
+                                        if (apollo_utilities_1.graphQLResultHasError(result) && errorPolicy === 'none') {
+                                            error = new ApolloError_1.ApolloError({
+                                                graphQLErrors: result.errors,
+                                            });
+                                            return;
+                                        }
+                                        self.mutationStore.markMutationResult(mutationId);
+                                        if (fetchPolicy !== 'no-cache') {
+                                            self.dataStore.markMutationResult({
+                                                mutationId: mutationId,
+                                                result: result,
+                                                document: mutation,
+                                                variables: variables,
+                                                updateQueries: generateUpdateQueriesInfo(),
+                                                update: updateWithProxyFn,
+                                            });
+                                        }
+                                        storeResult = result;
+                                    },
+                                    error: function (err) {
+                                        self.mutationStore.markMutationError(mutationId, err);
+                                        self.dataStore.markMutationComplete({
+                                            mutationId: mutationId,
+                                            optimisticResponse: optimisticResponse,
+                                        });
+                                        self.broadcastQueries();
+                                        self.setQuery(mutationId, function () { return ({ document: null }); });
+                                        reject(new ApolloError_1.ApolloError({
+                                            networkError: err,
+                                        }));
+                                    },
+                                    complete: function () {
+                                        if (error) {
+                                            self.mutationStore.markMutationError(mutationId, error);
+                                        }
+                                        self.dataStore.markMutationComplete({
+                                            mutationId: mutationId,
+                                            optimisticResponse: optimisticResponse,
+                                        });
+                                        self.broadcastQueries();
+                                        if (error) {
+                                            reject(error);
+                                            return;
+                                        }
+                                        if (typeof refetchQueries === 'function') {
+                                            refetchQueries = refetchQueries(storeResult);
+                                        }
+                                        var refetchQueryPromises = [];
+                                        if (arrays_1.isNonEmptyArray(refetchQueries)) {
+                                            refetchQueries.forEach(function (refetchQuery) {
+                                                if (typeof refetchQuery === 'string') {
+                                                    self.queries.forEach(function (_a) {
+                                                        var observableQuery = _a.observableQuery;
+                                                        if (observableQuery &&
+                                                            observableQuery.queryName === refetchQuery) {
+                                                            refetchQueryPromises.push(observableQuery.refetch());
+                                                        }
+                                                    });
+                                                }
+                                                else {
+                                                    var queryOptions = {
+                                                        query: refetchQuery.query,
+                                                        variables: refetchQuery.variables,
+                                                        fetchPolicy: 'network-only',
+                                                    };
+                                                    if (refetchQuery.context) {
+                                                        queryOptions.context = refetchQuery.context;
+                                                    }
+                                                    refetchQueryPromises.push(self.query(queryOptions));
+                                                }
+                                            });
+                                        }
+                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {
+                                            self.setQuery(mutationId, function () { return ({ document: null }); });
+                                            if (errorPolicy === 'ignore' &&
+                                                storeResult &&
+                                                apollo_utilities_1.graphQLResultHasError(storeResult)) {
+                                                delete storeResult.errors;
+                                            }
+                                            resolve(storeResult);
+                                        });
+                                    },
+                                });
+                            })];
+                }
+            });
+        });
+    };
+    QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;
+            var _this = this;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;
+                        query = this.transform(options.query).document;
+                        variables = this.getVariables(query, options.variables);
+                        if (!this.transform(query).hasClientExports) return [3, 2];
+                        return [4, this.localState.addExportedVariables(query, variables, context)];
+                    case 1:
+                        variables = _e.sent();
+                        _e.label = 2;
+                    case 2:
+                        options = tslib_1.__assign(tslib_1.__assign({}, options), { variables: variables });
+                        isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';
+                        needToFetch = isNetworkOnly;
+                        if (!isNetworkOnly) {
+                            _d = this.dataStore.getCache().diff({
+                                query: query,
+                                variables: variables,
+                                returnPartialData: true,
+                                optimistic: false,
+                            }), complete = _d.complete, result = _d.result;
+                            needToFetch = !complete || fetchPolicy === 'cache-and-network';
+                            storeResult = result;
+                        }
+                        shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';
+                        if (apollo_utilities_1.hasDirectives(['live'], query))
+                            shouldFetch = true;
+                        requestId = this.idCounter++;
+                        cancel = fetchPolicy !== 'no-cache'
+                            ? this.updateQueryWatch(queryId, query, options)
+                            : undefined;
+                        this.setQuery(queryId, function () { return ({
+                            document: query,
+                            lastRequestId: requestId,
+                            invalidated: true,
+                            cancel: cancel,
+                        }); });
+                        this.invalidate(fetchMoreForQueryId);
+                        this.queryStore.initQuery({
+                            queryId: queryId,
+                            document: query,
+                            storePreviousVariables: shouldFetch,
+                            variables: variables,
+                            isPoll: fetchType === types_1.FetchType.poll,
+                            isRefetch: fetchType === types_1.FetchType.refetch,
+                            metadata: metadata,
+                            fetchMoreForQueryId: fetchMoreForQueryId,
+                        });
+                        this.broadcastQueries();
+                        if (shouldFetch) {
+                            networkResult = this.fetchRequest({
+                                requestId: requestId,
+                                queryId: queryId,
+                                document: query,
+                                options: options,
+                                fetchMoreForQueryId: fetchMoreForQueryId,
+                            }).catch(function (error) {
+                                if (ApolloError_1.isApolloError(error)) {
+                                    throw error;
+                                }
+                                else {
+                                    if (requestId >= _this.getQuery(queryId).lastRequestId) {
+                                        _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);
+                                        _this.invalidate(queryId);
+                                        _this.invalidate(fetchMoreForQueryId);
+                                        _this.broadcastQueries();
+                                    }
+                                    throw new ApolloError_1.ApolloError({ networkError: error });
+                                }
+                            });
+                            if (fetchPolicy !== 'cache-and-network') {
+                                return [2, networkResult];
+                            }
+                            networkResult.catch(function () { });
+                        }
+                        this.queryStore.markQueryResultClient(queryId, !shouldFetch);
+                        this.invalidate(queryId);
+                        this.invalidate(fetchMoreForQueryId);
+                        if (this.transform(query).hasForcedResolvers) {
+                            return [2, this.localState.runResolvers({
+                                    document: query,
+                                    remoteResult: { data: storeResult },
+                                    context: context,
+                                    variables: variables,
+                                    onlyRunForcedResolvers: true,
+                                }).then(function (result) {
+                                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);
+                                    _this.broadcastQueries();
+                                    return result;
+                                })];
+                        }
+                        this.broadcastQueries();
+                        return [2, { data: storeResult }];
+                }
+            });
+        });
+    };
+    QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {
+        var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;
+        if (fetchPolicy === 'no-cache') {
+            this.setQuery(queryId, function () { return ({
+                newData: { result: result.data, complete: true },
+            }); });
+        }
+        else {
+            this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');
+        }
+    };
+    QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {
+        var _this = this;
+        function invoke(method, argument) {
+            if (observer[method]) {
+                try {
+                    observer[method](argument);
+                }
+                catch (e) {
+                    ts_invariant_1.invariant.error(e);
+                }
+            }
+            else if (method === 'error') {
+                ts_invariant_1.invariant.error(argument);
+            }
+        }
+        return function (queryStoreValue, newData) {
+            _this.invalidate(queryId, false);
+            if (!queryStoreValue)
+                return;
+            var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;
+            var fetchPolicy = observableQuery
+                ? observableQuery.options.fetchPolicy
+                : options.fetchPolicy;
+            if (fetchPolicy === 'standby')
+                return;
+            var loading = networkStatus_1.isNetworkRequestInFlight(queryStoreValue.networkStatus);
+            var lastResult = observableQuery && observableQuery.getLastResult();
+            var networkStatusChanged = !!(lastResult &&
+                lastResult.networkStatus !== queryStoreValue.networkStatus);
+            var shouldNotifyIfLoading = options.returnPartialData ||
+                (!newData && queryStoreValue.previousVariables) ||
+                (networkStatusChanged && options.notifyOnNetworkStatusChange) ||
+                fetchPolicy === 'cache-only' ||
+                fetchPolicy === 'cache-and-network';
+            if (loading && !shouldNotifyIfLoading) {
+                return;
+            }
+            var hasGraphQLErrors = arrays_1.isNonEmptyArray(queryStoreValue.graphQLErrors);
+            var errorPolicy = observableQuery
+                && observableQuery.options.errorPolicy
+                || options.errorPolicy
+                || 'none';
+            if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {
+                return invoke('error', new ApolloError_1.ApolloError({
+                    graphQLErrors: queryStoreValue.graphQLErrors,
+                    networkError: queryStoreValue.networkError,
+                }));
+            }
+            try {
+                var data = void 0;
+                var isMissing = void 0;
+                if (newData) {
+                    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {
+                        _this.setQuery(queryId, function () { return ({ newData: null }); });
+                    }
+                    data = newData.result;
+                    isMissing = !newData.complete;
+                }
+                else {
+                    var lastError = observableQuery && observableQuery.getLastError();
+                    var errorStatusChanged = errorPolicy !== 'none' &&
+                        (lastError && lastError.graphQLErrors) !==
+                            queryStoreValue.graphQLErrors;
+                    if (lastResult && lastResult.data && !errorStatusChanged) {
+                        data = lastResult.data;
+                        isMissing = false;
+                    }
+                    else {
+                        var diffResult = _this.dataStore.getCache().diff({
+                            query: document,
+                            variables: queryStoreValue.previousVariables ||
+                                queryStoreValue.variables,
+                            returnPartialData: true,
+                            optimistic: true,
+                        });
+                        data = diffResult.result;
+                        isMissing = !diffResult.complete;
+                    }
+                }
+                var stale = isMissing && !(options.returnPartialData ||
+                    fetchPolicy === 'cache-only');
+                var resultFromStore = {
+                    data: stale ? lastResult && lastResult.data : data,
+                    loading: loading,
+                    networkStatus: queryStoreValue.networkStatus,
+                    stale: stale,
+                };
+                if (errorPolicy === 'all' && hasGraphQLErrors) {
+                    resultFromStore.errors = queryStoreValue.graphQLErrors;
+                }
+                invoke('next', resultFromStore);
+            }
+            catch (networkError) {
+                invoke('error', new ApolloError_1.ApolloError({ networkError: networkError }));
+            }
+        };
+    };
+    QueryManager.prototype.transform = function (document) {
+        var transformCache = this.transformCache;
+        if (!transformCache.has(document)) {
+            var cache = this.dataStore.getCache();
+            var transformed = cache.transformDocument(document);
+            var forLink = apollo_utilities_1.removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));
+            var clientQuery = this.localState.clientQuery(transformed);
+            var serverQuery = this.localState.serverQuery(forLink);
+            var cacheEntry_1 = {
+                document: transformed,
+                hasClientExports: apollo_utilities_1.hasClientExports(transformed),
+                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),
+                clientQuery: clientQuery,
+                serverQuery: serverQuery,
+                defaultVars: apollo_utilities_1.getDefaultValues(apollo_utilities_1.getOperationDefinition(transformed)),
+            };
+            var add = function (doc) {
+                if (doc && !transformCache.has(doc)) {
+                    transformCache.set(doc, cacheEntry_1);
+                }
+            };
+            add(document);
+            add(transformed);
+            add(clientQuery);
+            add(serverQuery);
+        }
+        return transformCache.get(document);
+    };
+    QueryManager.prototype.getVariables = function (document, variables) {
+        return tslib_1.__assign(tslib_1.__assign({}, this.transform(document).defaultVars), variables);
+    };
+    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {
+        if (shouldSubscribe === void 0) { shouldSubscribe = true; }
+        ts_invariant_1.invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to "standby"');
+        options.variables = this.getVariables(options.query, options.variables);
+        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {
+            options.notifyOnNetworkStatusChange = false;
+        }
+        var transformedOptions = tslib_1.__assign({}, options);
+        return new ObservableQuery_1.ObservableQuery({
+            queryManager: this,
+            options: transformedOptions,
+            shouldSubscribe: shouldSubscribe,
+        });
+    };
+    QueryManager.prototype.query = function (options) {
+        var _this = this;
+        ts_invariant_1.invariant(options.query, 'query option is required. You must specify your GraphQL document ' +
+            'in the query option.');
+        ts_invariant_1.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.');
+        ts_invariant_1.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');
+        ts_invariant_1.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');
+        return new Promise(function (resolve, reject) {
+            var watchedQuery = _this.watchQuery(options, false);
+            _this.fetchQueryRejectFns.set("query:" + watchedQuery.queryId, reject);
+            watchedQuery
+                .result()
+                .then(resolve, reject)
+                .then(function () {
+                return _this.fetchQueryRejectFns.delete("query:" + watchedQuery.queryId);
+            });
+        });
+    };
+    QueryManager.prototype.generateQueryId = function () {
+        return String(this.idCounter++);
+    };
+    QueryManager.prototype.stopQueryInStore = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.broadcastQueries();
+    };
+    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
+        this.stopPollingQuery(queryId);
+        this.queryStore.stopQuery(queryId);
+        this.invalidate(queryId);
+    };
+    QueryManager.prototype.addQueryListener = function (queryId, listener) {
+        this.setQuery(queryId, function (_a) {
+            var listeners = _a.listeners;
+            listeners.add(listener);
+            return { invalidated: false };
+        });
+    };
+    QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {
+        var _this = this;
+        var cancel = this.getQuery(queryId).cancel;
+        if (cancel)
+            cancel();
+        var previousResult = function () {
+            var previousResult = null;
+            var observableQuery = _this.getQuery(queryId).observableQuery;
+            if (observableQuery) {
+                var lastResult = observableQuery.getLastResult();
+                if (lastResult) {
+                    previousResult = lastResult.data;
+                }
+            }
+            return previousResult;
+        };
+        return this.dataStore.getCache().watch({
+            query: document,
+            variables: options.variables,
+            optimistic: true,
+            previousResult: previousResult,
+            callback: function (newData) {
+                _this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });
+            },
+        });
+    };
+    QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {
+        this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });
+    };
+    QueryManager.prototype.removeObservableQuery = function (queryId) {
+        var cancel = this.getQuery(queryId).cancel;
+        this.setQuery(queryId, function () { return ({ observableQuery: null }); });
+        if (cancel)
+            cancel();
+    };
+    QueryManager.prototype.clearStore = function () {
+        this.fetchQueryRejectFns.forEach(function (reject) {
+            reject(new ts_invariant_1.InvariantError('Store reset while query was in flight (not completed in link chain)'));
+        });
+        var resetIds = [];
+        this.queries.forEach(function (_a, queryId) {
+            var observableQuery = _a.observableQuery;
+            if (observableQuery)
+                resetIds.push(queryId);
+        });
+        this.queryStore.reset(resetIds);
+        this.mutationStore.reset();
+        return this.dataStore.reset();
+    };
+    QueryManager.prototype.resetStore = function () {
+        var _this = this;
+        return this.clearStore().then(function () {
+            return _this.reFetchObservableQueries();
+        });
+    };
+    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
+        var _this = this;
+        if (includeStandby === void 0) { includeStandby = false; }
+        var observableQueryPromises = [];
+        this.queries.forEach(function (_a, queryId) {
+            var observableQuery = _a.observableQuery;
+            if (observableQuery) {
+                var fetchPolicy = observableQuery.options.fetchPolicy;
+                observableQuery.resetLastResults();
+                if (fetchPolicy !== 'cache-only' &&
+                    (includeStandby || fetchPolicy !== 'standby')) {
+                    observableQueryPromises.push(observableQuery.refetch());
+                }
+                _this.setQuery(queryId, function () { return ({ newData: null }); });
+                _this.invalidate(queryId);
+            }
+        });
+        this.broadcastQueries();
+        return Promise.all(observableQueryPromises);
+    };
+    QueryManager.prototype.observeQuery = function (queryId, options, observer) {
+        this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));
+        return this.fetchQuery(queryId, options);
+    };
+    QueryManager.prototype.startQuery = function (queryId, options, listener) {
+        ts_invariant_1.invariant.warn("The QueryManager.startQuery method has been deprecated");
+        this.addQueryListener(queryId, listener);
+        this.fetchQuery(queryId, options)
+            .catch(function () { return undefined; });
+        return queryId;
+    };
+    QueryManager.prototype.startGraphQLSubscription = function (_a) {
+        var _this = this;
+        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;
+        query = this.transform(query).document;
+        variables = this.getVariables(query, variables);
+        var makeObservable = function (variables) {
+            return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {
+                if (!fetchPolicy || fetchPolicy !== 'no-cache') {
+                    _this.dataStore.markSubscriptionResult(result, query, variables);
+                    _this.broadcastQueries();
+                }
+                if (apollo_utilities_1.graphQLResultHasError(result)) {
+                    throw new ApolloError_1.ApolloError({
+                        graphQLErrors: result.errors,
+                    });
+                }
+                return result;
+            });
+        };
+        if (this.transform(query).hasClientExports) {
+            var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);
+            return new Observable_1.Observable(function (observer) {
+                var sub = null;
+                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);
+                return function () { return sub && sub.unsubscribe(); };
+            });
+        }
+        return makeObservable(variables);
+    };
+    QueryManager.prototype.stopQuery = function (queryId) {
+        this.stopQueryNoBroadcast(queryId);
+        this.broadcastQueries();
+    };
+    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.removeQuery(queryId);
+    };
+    QueryManager.prototype.removeQuery = function (queryId) {
+        this.fetchQueryRejectFns.delete("query:" + queryId);
+        this.fetchQueryRejectFns.delete("fetchRequest:" + queryId);
+        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });
+        this.queries.delete(queryId);
+    };
+    QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {
+        if (optimistic === void 0) { optimistic = true; }
+        var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;
+        var lastResult = observableQuery.getLastResult();
+        var newData = this.getQuery(observableQuery.queryId).newData;
+        if (newData && newData.complete) {
+            return { data: newData.result, partial: false };
+        }
+        if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {
+            return { data: undefined, partial: false };
+        }
+        var _b = this.dataStore.getCache().diff({
+            query: query,
+            variables: variables,
+            previousResult: lastResult ? lastResult.data : undefined,
+            returnPartialData: true,
+            optimistic: optimistic,
+        }), result = _b.result, complete = _b.complete;
+        return {
+            data: (complete || returnPartialData) ? result : void 0,
+            partial: !complete,
+        };
+    };
+    QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {
+        var observableQuery;
+        if (typeof queryIdOrObservable === 'string') {
+            var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;
+            ts_invariant_1.invariant(foundObserveableQuery, "ObservableQuery with this id doesn't exist: " + queryIdOrObservable);
+            observableQuery = foundObserveableQuery;
+        }
+        else {
+            observableQuery = queryIdOrObservable;
+        }
+        var _a = observableQuery.options, variables = _a.variables, query = _a.query;
+        return {
+            previousResult: this.getCurrentQueryResult(observableQuery, false).data,
+            variables: variables,
+            document: query,
+        };
+    };
+    QueryManager.prototype.broadcastQueries = function () {
+        var _this = this;
+        this.onBroadcast();
+        this.queries.forEach(function (info, id) {
+            if (info.invalidated) {
+                info.listeners.forEach(function (listener) {
+                    if (listener) {
+                        listener(_this.queryStore.get(id), info.newData);
+                    }
+                });
+            }
+        });
+    };
+    QueryManager.prototype.getLocalState = function () {
+        return this.localState;
+    };
+    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {
+        var _this = this;
+        if (deduplication === void 0) { deduplication = this.queryDeduplication; }
+        var observable;
+        var serverQuery = this.transform(query).serverQuery;
+        if (serverQuery) {
+            var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;
+            var operation = {
+                query: serverQuery,
+                variables: variables,
+                operationName: apollo_utilities_1.getOperationName(serverQuery) || void 0,
+                context: this.prepareContext(tslib_1.__assign(tslib_1.__assign({}, context), { forceFetch: !deduplication })),
+            };
+            context = operation.context;
+            if (deduplication) {
+                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();
+                inFlightLinkObservables_1.set(serverQuery, byVariables_1);
+                var varJson_1 = JSON.stringify(variables);
+                observable = byVariables_1.get(varJson_1);
+                if (!observable) {
+                    byVariables_1.set(varJson_1, observable = observables_1.multiplex(apollo_link_1.execute(link, operation)));
+                    var cleanup = function () {
+                        byVariables_1.delete(varJson_1);
+                        if (!byVariables_1.size)
+                            inFlightLinkObservables_1.delete(serverQuery);
+                        cleanupSub_1.unsubscribe();
+                    };
+                    var cleanupSub_1 = observable.subscribe({
+                        next: cleanup,
+                        error: cleanup,
+                        complete: cleanup,
+                    });
+                }
+            }
+            else {
+                observable = observables_1.multiplex(apollo_link_1.execute(link, operation));
+            }
+        }
+        else {
+            observable = Observable_1.Observable.of({ data: {} });
+            context = this.prepareContext(context);
+        }
+        var clientQuery = this.transform(query).clientQuery;
+        if (clientQuery) {
+            observable = observables_1.asyncMap(observable, function (result) {
+                return _this.localState.runResolvers({
+                    document: clientQuery,
+                    remoteResult: result,
+                    context: context,
+                    variables: variables,
+                });
+            });
+        }
+        return observable;
+    };
+    QueryManager.prototype.fetchRequest = function (_a) {
+        var _this = this;
+        var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;
+        var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;
+        var resultFromStore;
+        var errorsFromStore;
+        return new Promise(function (resolve, reject) {
+            var observable = _this.getObservableFromLink(document, options.context, variables);
+            var fqrfId = "fetchRequest:" + queryId;
+            _this.fetchQueryRejectFns.set(fqrfId, reject);
+            var cleanup = function () {
+                _this.fetchQueryRejectFns.delete(fqrfId);
+                _this.setQuery(queryId, function (_a) {
+                    var subscriptions = _a.subscriptions;
+                    subscriptions.delete(subscription);
+                });
+            };
+            var subscription = observable.map(function (result) {
+                if (requestId >= _this.getQuery(queryId).lastRequestId) {
+                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);
+                    _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);
+                    _this.invalidate(queryId);
+                    _this.invalidate(fetchMoreForQueryId);
+                    _this.broadcastQueries();
+                }
+                if (errorPolicy === 'none' && arrays_1.isNonEmptyArray(result.errors)) {
+                    return reject(new ApolloError_1.ApolloError({
+                        graphQLErrors: result.errors,
+                    }));
+                }
+                if (errorPolicy === 'all') {
+                    errorsFromStore = result.errors;
+                }
+                if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {
+                    resultFromStore = result.data;
+                }
+                else {
+                    var _a = _this.dataStore.getCache().diff({
+                        variables: variables,
+                        query: document,
+                        optimistic: false,
+                        returnPartialData: true,
+                    }), result_1 = _a.result, complete = _a.complete;
+                    if (complete || options.returnPartialData) {
+                        resultFromStore = result_1;
+                    }
+                }
+            }).subscribe({
+                error: function (error) {
+                    cleanup();
+                    reject(error);
+                },
+                complete: function () {
+                    cleanup();
+                    resolve({
+                        data: resultFromStore,
+                        errors: errorsFromStore,
+                        loading: false,
+                        networkStatus: networkStatus_1.NetworkStatus.ready,
+                        stale: false,
+                    });
+                },
+            });
+            _this.setQuery(queryId, function (_a) {
+                var subscriptions = _a.subscriptions;
+                subscriptions.add(subscription);
+            });
+        });
+    };
+    QueryManager.prototype.getQuery = function (queryId) {
+        return (this.queries.get(queryId) || {
+            listeners: new Set(),
+            invalidated: false,
+            document: null,
+            newData: null,
+            lastRequestId: 1,
+            observableQuery: null,
+            subscriptions: new Set(),
+        });
+    };
+    QueryManager.prototype.setQuery = function (queryId, updater) {
+        var prev = this.getQuery(queryId);
+        var newInfo = tslib_1.__assign(tslib_1.__assign({}, prev), updater(prev));
+        this.queries.set(queryId, newInfo);
+    };
+    QueryManager.prototype.invalidate = function (queryId, invalidated) {
+        if (invalidated === void 0) { invalidated = true; }
+        if (queryId) {
+            this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });
+        }
+    };
+    QueryManager.prototype.prepareContext = function (context) {
+        if (context === void 0) { context = {}; }
+        var newContext = this.localState.prepareContext(context);
+        return tslib_1.__assign(tslib_1.__assign({}, newContext), { clientAwareness: this.clientAwareness });
+    };
+    QueryManager.prototype.checkInFlight = function (queryId) {
+        var query = this.queryStore.get(queryId);
+        return (query &&
+            query.networkStatus !== networkStatus_1.NetworkStatus.ready &&
+            query.networkStatus !== networkStatus_1.NetworkStatus.error);
+    };
+    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {
+        var _this = this;
+        var pollInterval = options.pollInterval;
+        ts_invariant_1.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');
+        if (!this.ssrMode) {
+            var info = this.pollingInfoByQueryId.get(queryId);
+            if (!info) {
+                this.pollingInfoByQueryId.set(queryId, (info = {}));
+            }
+            info.interval = pollInterval;
+            info.options = tslib_1.__assign(tslib_1.__assign({}, options), { fetchPolicy: 'network-only' });
+            var maybeFetch_1 = function () {
+                var info = _this.pollingInfoByQueryId.get(queryId);
+                if (info) {
+                    if (_this.checkInFlight(queryId)) {
+                        poll_1();
+                    }
+                    else {
+                        _this.fetchQuery(queryId, info.options, types_1.FetchType.poll).then(poll_1, poll_1);
+                    }
+                }
+            };
+            var poll_1 = function () {
+                var info = _this.pollingInfoByQueryId.get(queryId);
+                if (info) {
+                    clearTimeout(info.timeout);
+                    info.timeout = setTimeout(maybeFetch_1, info.interval);
+                }
+            };
+            if (listener) {
+                this.addQueryListener(queryId, listener);
+            }
+            poll_1();
+        }
+        return queryId;
+    };
+    QueryManager.prototype.stopPollingQuery = function (queryId) {
+        this.pollingInfoByQueryId.delete(queryId);
+    };
+    return QueryManager;
+}());
+exports.QueryManager = QueryManager;
+//# sourceMappingURL=QueryManager.js.map

node_modules/apollo-client/core/networkStatus.d.ts

@@ -0,0 +1,11 @@
+export declare enum NetworkStatus {
+    loading = 1,
+    setVariables = 2,
+    fetchMore = 3,
+    refetch = 4,
+    poll = 6,
+    ready = 7,
+    error = 8
+}
+export declare function isNetworkRequestInFlight(networkStatus: NetworkStatus): boolean;
+//# sourceMappingURL=networkStatus.d.ts.map

node_modules/apollo-client/core/networkStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatus.d.ts","sourceRoot":"","sources":["../src/core/networkStatus.ts"],"names":[],"mappings":"AAGA,oBAAY,aAAa;IAMvB,OAAO,IAAI;IAMX,YAAY,IAAI;IAMhB,SAAS,IAAI;IAMb,OAAO,IAAI;IAOX,IAAI,IAAI;IAKR,KAAK,IAAI;IAKT,KAAK,IAAI;CACV;AAMD,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,GAC3B,OAAO,CAET"}

node_modules/apollo-client/core/networkStatus.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NetworkStatus;
+(function (NetworkStatus) {
+    NetworkStatus[NetworkStatus["loading"] = 1] = "loading";
+    NetworkStatus[NetworkStatus["setVariables"] = 2] = "setVariables";
+    NetworkStatus[NetworkStatus["fetchMore"] = 3] = "fetchMore";
+    NetworkStatus[NetworkStatus["refetch"] = 4] = "refetch";
+    NetworkStatus[NetworkStatus["poll"] = 6] = "poll";
+    NetworkStatus[NetworkStatus["ready"] = 7] = "ready";
+    NetworkStatus[NetworkStatus["error"] = 8] = "error";
+})(NetworkStatus = exports.NetworkStatus || (exports.NetworkStatus = {}));
+function isNetworkRequestInFlight(networkStatus) {
+    return networkStatus < 7;
+}
+exports.isNetworkRequestInFlight = isNetworkRequestInFlight;
+//# sourceMappingURL=networkStatus.js.map

node_modules/apollo-client/core/networkStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatus.js","sourceRoot":"","sources":["../../src/core/networkStatus.ts"],"names":[],"mappings":";;AAGA,IAAY,aA0CX;AA1CD,WAAY,aAAa;IAMvB,uDAAW,CAAA;IAMX,iEAAgB,CAAA;IAMhB,2DAAa,CAAA;IAMb,uDAAW,CAAA;IAOX,iDAAQ,CAAA;IAKR,mDAAS,CAAA;IAKT,mDAAS,CAAA;AACX,CAAC,EA1CW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QA0CxB;AAMD,SAAgB,wBAAwB,CACtC,aAA4B;IAE5B,OAAO,aAAa,GAAG,CAAC,CAAC;AAC3B,CAAC;AAJD,4DAIC"}

node_modules/apollo-client/core/types.d.ts

@@ -0,0 +1,44 @@
+import { FetchResult } from 'apollo-link';
+import { DocumentNode, GraphQLError } from 'graphql';
+import { QueryStoreValue } from '../data/queries';
+import { NetworkStatus } from './networkStatus';
+import { Resolver } from './LocalState';
+export declare type QueryListener = (queryStoreValue: QueryStoreValue, newData?: any, forceResolvers?: boolean) => void;
+export declare type OperationVariables = {
+    [key: string]: any;
+};
+export declare type PureQueryOptions = {
+    query: DocumentNode;
+    variables?: {
+        [key: string]: any;
+    };
+    context?: any;
+};
+export declare type ApolloQueryResult<T> = {
+    data: T;
+    errors?: ReadonlyArray<GraphQLError>;
+    loading: boolean;
+    networkStatus: NetworkStatus;
+    stale: boolean;
+};
+export declare enum FetchType {
+    normal = 1,
+    refetch = 2,
+    poll = 3
+}
+export declare type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
+    mutationResult: FetchResult<T>;
+    queryName: string | undefined;
+    queryVariables: Record<string, any>;
+}) => Record<string, any>;
+export declare type MutationQueryReducersMap<T = {
+    [key: string]: any;
+}> = {
+    [queryName: string]: MutationQueryReducer<T>;
+};
+export interface Resolvers {
+    [key: string]: {
+        [field: string]: Resolver;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/apollo-client/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/core/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,oBAAY,aAAa,GAAG,CAC1B,eAAe,EAAE,eAAe,EAChC,OAAO,CAAC,EAAE,GAAG,EACb,cAAc,CAAC,EAAE,OAAO,KACrB,IAAI,CAAC;AAEV,oBAAY,kBAAkB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC;AAExD,oBAAY,gBAAgB,GAAG;IAC7B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IACnC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf,CAAC;AAEF,oBAAY,iBAAiB,CAAC,CAAC,IAAI;IACjC,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,oBAAY,SAAS;IACnB,MAAM,IAAI;IACV,OAAO,IAAI;IACX,IAAI,IAAI;CACT;AAGD,oBAAY,oBAAoB,CAAC,CAAC,IAAI,CACpC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,OAAO,EAAE;IACP,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC,KACE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEzB,oBAAY,wBAAwB,CAAC,CAAC,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,IAAI;IACjE,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG;QACb,CAAE,KAAK,EAAE,MAAM,GAAI,QAAQ,CAAC;KAC7B,CAAC;CACH"}

node_modules/apollo-client/core/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FetchType;
+(function (FetchType) {
+    FetchType[FetchType["normal"] = 1] = "normal";
+    FetchType[FetchType["refetch"] = 2] = "refetch";
+    FetchType[FetchType["poll"] = 3] = "poll";
+})(FetchType = exports.FetchType || (exports.FetchType = {}));
+//# sourceMappingURL=types.js.map

node_modules/apollo-client/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":";;AA6BA,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,6CAAU,CAAA;IACV,+CAAW,CAAA;IACX,yCAAQ,CAAA;AACV,CAAC,EAJW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAIpB"}

node_modules/apollo-client/core/watchQueryOptions.d.ts

@@ -0,0 +1,72 @@
+import { DocumentNode } from 'graphql';
+import { FetchResult } from 'apollo-link';
+import { DataProxy } from 'apollo-cache';
+import { MutationQueryReducersMap } from './types';
+import { PureQueryOptions, OperationVariables } from './types';
+export declare type FetchPolicy = 'cache-first' | 'network-only' | 'cache-only' | 'no-cache' | 'standby';
+export declare type WatchQueryFetchPolicy = FetchPolicy | 'cache-and-network';
+export declare type ErrorPolicy = 'none' | 'ignore' | 'all';
+export interface QueryBaseOptions<TVariables = OperationVariables> {
+    query: DocumentNode;
+    variables?: TVariables;
+    errorPolicy?: ErrorPolicy;
+    fetchResults?: boolean;
+    metadata?: any;
+    context?: any;
+}
+export interface QueryOptions<TVariables = OperationVariables> extends QueryBaseOptions<TVariables> {
+    fetchPolicy?: FetchPolicy;
+}
+export interface ModifiableWatchQueryOptions<TVariables = OperationVariables> extends QueryBaseOptions<TVariables> {
+    pollInterval?: number;
+    notifyOnNetworkStatusChange?: boolean;
+    returnPartialData?: boolean;
+}
+export interface WatchQueryOptions<TVariables = OperationVariables> extends QueryBaseOptions<TVariables>, ModifiableWatchQueryOptions<TVariables> {
+    fetchPolicy?: WatchQueryFetchPolicy;
+}
+export interface FetchMoreQueryOptions<TVariables, K extends keyof TVariables> {
+    query?: DocumentNode;
+    variables?: Pick<TVariables, K>;
+    context?: any;
+}
+export declare type UpdateQueryFn<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = (previousQueryResult: TData, options: {
+    subscriptionData: {
+        data: TSubscriptionData;
+    };
+    variables?: TSubscriptionVariables;
+}) => TData;
+export declare type SubscribeToMoreOptions<TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = {
+    document: DocumentNode;
+    variables?: TSubscriptionVariables;
+    updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>;
+    onError?: (error: Error) => void;
+};
+export interface SubscriptionOptions<TVariables = OperationVariables> {
+    query: DocumentNode;
+    variables?: TVariables;
+    fetchPolicy?: FetchPolicy;
+}
+export declare type RefetchQueryDescription = Array<string | PureQueryOptions>;
+export interface MutationBaseOptions<T = {
+    [key: string]: any;
+}, TVariables = OperationVariables> {
+    optimisticResponse?: T | ((vars: TVariables) => T);
+    updateQueries?: MutationQueryReducersMap<T>;
+    refetchQueries?: ((result: FetchResult<T>) => RefetchQueryDescription) | RefetchQueryDescription;
+    awaitRefetchQueries?: boolean;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: TVariables;
+}
+export interface MutationOptions<T = {
+    [key: string]: any;
+}, TVariables = OperationVariables> extends MutationBaseOptions<T, TVariables> {
+    mutation: DocumentNode;
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+}
+export declare type MutationUpdaterFn<T = {
+    [key: string]: any;
+}> = (proxy: DataProxy, mutationResult: FetchResult<T>) => void;
+//# sourceMappingURL=watchQueryOptions.d.ts.map

node_modules/apollo-client/core/watchQueryOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchQueryOptions.d.ts","sourceRoot":"","sources":["../src/core/watchQueryOptions.ts"],"names":[],"mappings":"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"}

node_modules/apollo-client/core/watchQueryOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=watchQueryOptions.js.map

node_modules/apollo-client/core/watchQueryOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchQueryOptions.js","sourceRoot":"","sources":["../../src/core/watchQueryOptions.ts"],"names":[],"mappings":""}