You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8662 lines
349 KiB
8662 lines
349 KiB
4 months ago
|
'use strict';
|
||
|
|
||
|
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
||
|
var tslib = require('tslib');
|
||
|
var tsInvariant = require('ts-invariant');
|
||
|
var equal = require('@wry/equality');
|
||
|
var caches = require('@wry/caches');
|
||
|
var graphql = require('graphql');
|
||
|
var zenObservableTs = require('zen-observable-ts');
|
||
|
require('symbol-observable');
|
||
|
var optimism = require('optimism');
|
||
|
var trie = require('@wry/trie');
|
||
|
var graphqlTag = require('graphql-tag');
|
||
|
var React = require('rehackt');
|
||
|
|
||
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
|
||
|
|
||
|
function _interopNamespace(e) {
|
||
|
if (e && e.__esModule) return e;
|
||
|
var n = Object.create(null);
|
||
|
if (e) {
|
||
|
for (var k in e) {
|
||
|
n[k] = e[k];
|
||
|
}
|
||
|
}
|
||
|
n["default"] = e;
|
||
|
return Object.freeze(n);
|
||
|
}
|
||
|
|
||
|
var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
|
||
|
var React__namespace = /*#__PURE__*/_interopNamespace(React);
|
||
|
|
||
|
var version = "3.9.5";
|
||
|
|
||
|
function maybe(thunk) {
|
||
|
try {
|
||
|
return thunk();
|
||
|
}
|
||
|
catch (_a) { }
|
||
|
}
|
||
|
|
||
|
var global$1 = (maybe(function () { return globalThis; }) ||
|
||
|
maybe(function () { return window; }) ||
|
||
|
maybe(function () { return self; }) ||
|
||
|
maybe(function () { return global; }) ||
|
||
|
maybe(function () {
|
||
|
return maybe.constructor("return this")();
|
||
|
}));
|
||
|
|
||
|
var prefixCounts = new Map();
|
||
|
function makeUniqueId(prefix) {
|
||
|
var count = prefixCounts.get(prefix) || 1;
|
||
|
prefixCounts.set(prefix, count + 1);
|
||
|
return "".concat(prefix, ":").concat(count, ":").concat(Math.random().toString(36).slice(2));
|
||
|
}
|
||
|
|
||
|
function stringifyForDisplay(value, space) {
|
||
|
if (space === void 0) { space = 0; }
|
||
|
var undefId = makeUniqueId("stringifyForDisplay");
|
||
|
return JSON.stringify(value, function (key, value) {
|
||
|
return value === void 0 ? undefId : value;
|
||
|
}, space)
|
||
|
.split(JSON.stringify(undefId))
|
||
|
.join("<undefined>");
|
||
|
}
|
||
|
|
||
|
function wrap(fn) {
|
||
|
return function (message) {
|
||
|
var args = [];
|
||
|
for (var _i = 1; _i < arguments.length; _i++) {
|
||
|
args[_i - 1] = arguments[_i];
|
||
|
}
|
||
|
if (typeof message === "number") {
|
||
|
var arg0 = message;
|
||
|
message = getHandledErrorMsg(arg0);
|
||
|
if (!message) {
|
||
|
message = getFallbackErrorMsg(arg0, args);
|
||
|
args = [];
|
||
|
}
|
||
|
}
|
||
|
fn.apply(void 0, [message].concat(args));
|
||
|
};
|
||
|
}
|
||
|
var invariant = Object.assign(function invariant(condition, message) {
|
||
|
var args = [];
|
||
|
for (var _i = 2; _i < arguments.length; _i++) {
|
||
|
args[_i - 2] = arguments[_i];
|
||
|
}
|
||
|
if (!condition) {
|
||
|
tsInvariant.invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));
|
||
|
}
|
||
|
}, {
|
||
|
debug: wrap(tsInvariant.invariant.debug),
|
||
|
log: wrap(tsInvariant.invariant.log),
|
||
|
warn: wrap(tsInvariant.invariant.warn),
|
||
|
error: wrap(tsInvariant.invariant.error),
|
||
|
});
|
||
|
function newInvariantError(message) {
|
||
|
var optionalParams = [];
|
||
|
for (var _i = 1; _i < arguments.length; _i++) {
|
||
|
optionalParams[_i - 1] = arguments[_i];
|
||
|
}
|
||
|
return new tsInvariant.InvariantError(getHandledErrorMsg(message, optionalParams) ||
|
||
|
getFallbackErrorMsg(message, optionalParams));
|
||
|
}
|
||
|
var ApolloErrorMessageHandler = Symbol.for("ApolloErrorMessageHandler_" + version);
|
||
|
function stringify(arg) {
|
||
|
return typeof arg == "string" ? arg : (stringifyForDisplay(arg, 2).slice(0, 1000));
|
||
|
}
|
||
|
function getHandledErrorMsg(message, messageArgs) {
|
||
|
if (messageArgs === void 0) { messageArgs = []; }
|
||
|
if (!message)
|
||
|
return;
|
||
|
return (global$1[ApolloErrorMessageHandler] &&
|
||
|
global$1[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));
|
||
|
}
|
||
|
function getFallbackErrorMsg(message, messageArgs) {
|
||
|
if (messageArgs === void 0) { messageArgs = []; }
|
||
|
if (!message)
|
||
|
return;
|
||
|
return "An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#".concat(encodeURIComponent(JSON.stringify({
|
||
|
version: version,
|
||
|
message: message,
|
||
|
args: messageArgs.map(stringify),
|
||
|
})));
|
||
|
}
|
||
|
|
||
|
function shouldInclude(_a, variables) {
|
||
|
var directives = _a.directives;
|
||
|
if (!directives || !directives.length) {
|
||
|
return true;
|
||
|
}
|
||
|
return getInclusionDirectives(directives).every(function (_a) {
|
||
|
var directive = _a.directive, ifArgument = _a.ifArgument;
|
||
|
var evaledValue = false;
|
||
|
if (ifArgument.value.kind === "Variable") {
|
||
|
evaledValue =
|
||
|
variables && variables[ifArgument.value.name.value];
|
||
|
invariant(evaledValue !== void 0, 67, directive.name.value);
|
||
|
}
|
||
|
else {
|
||
|
evaledValue = ifArgument.value.value;
|
||
|
}
|
||
|
return directive.name.value === "skip" ? !evaledValue : evaledValue;
|
||
|
});
|
||
|
}
|
||
|
function hasDirectives(names, root, all) {
|
||
|
var nameSet = new Set(names);
|
||
|
var uniqueCount = nameSet.size;
|
||
|
graphql.visit(root, {
|
||
|
Directive: function (node) {
|
||
|
if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {
|
||
|
return graphql.BREAK;
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
return all ? !nameSet.size : nameSet.size < uniqueCount;
|
||
|
}
|
||
|
function hasClientExports(document) {
|
||
|
return document && hasDirectives(["client", "export"], document, true);
|
||
|
}
|
||
|
function isInclusionDirective(_a) {
|
||
|
var value = _a.name.value;
|
||
|
return value === "skip" || value === "include";
|
||
|
}
|
||
|
function getInclusionDirectives(directives) {
|
||
|
var result = [];
|
||
|
if (directives && directives.length) {
|
||
|
directives.forEach(function (directive) {
|
||
|
if (!isInclusionDirective(directive))
|
||
|
return;
|
||
|
var directiveArguments = directive.arguments;
|
||
|
var directiveName = directive.name.value;
|
||
|
invariant(directiveArguments && directiveArguments.length === 1, 68, directiveName);
|
||
|
var ifArgument = directiveArguments[0];
|
||
|
invariant(ifArgument.name && ifArgument.name.value === "if", 69, directiveName);
|
||
|
var ifValue = ifArgument.value;
|
||
|
invariant(ifValue &&
|
||
|
(ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 70, directiveName);
|
||
|
result.push({ directive: directive, ifArgument: ifArgument });
|
||
|
});
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
var canUseWeakMap = typeof WeakMap === "function" &&
|
||
|
!maybe(function () { return navigator.product == "ReactNative" && !global.HermesInternal; });
|
||
|
var canUseWeakSet = typeof WeakSet === "function";
|
||
|
var canUseSymbol = typeof Symbol === "function" && typeof Symbol.for === "function";
|
||
|
var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;
|
||
|
var canUseDOM = typeof maybe(function () { return window.document.createElement; }) === "function";
|
||
|
var usingJSDOM =
|
||
|
maybe(function () { return navigator.userAgent.indexOf("jsdom") >= 0; }) || false;
|
||
|
var canUseLayoutEffect = canUseDOM && !usingJSDOM;
|
||
|
|
||
|
function isNonNullObject(obj) {
|
||
|
return obj !== null && typeof obj === "object";
|
||
|
}
|
||
|
|
||
|
function getFragmentQueryDocument(document, fragmentName) {
|
||
|
var actualFragmentName = fragmentName;
|
||
|
var fragments = [];
|
||
|
document.definitions.forEach(function (definition) {
|
||
|
if (definition.kind === "OperationDefinition") {
|
||
|
throw newInvariantError(
|
||
|
71,
|
||
|
definition.operation,
|
||
|
definition.name ? " named '".concat(definition.name.value, "'") : ""
|
||
|
);
|
||
|
}
|
||
|
if (definition.kind === "FragmentDefinition") {
|
||
|
fragments.push(definition);
|
||
|
}
|
||
|
});
|
||
|
if (typeof actualFragmentName === "undefined") {
|
||
|
invariant(fragments.length === 1, 72, fragments.length);
|
||
|
actualFragmentName = fragments[0].name.value;
|
||
|
}
|
||
|
var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
|
||
|
{
|
||
|
kind: "OperationDefinition",
|
||
|
operation: "query",
|
||
|
selectionSet: {
|
||
|
kind: "SelectionSet",
|
||
|
selections: [
|
||
|
{
|
||
|
kind: "FragmentSpread",
|
||
|
name: {
|
||
|
kind: "Name",
|
||
|
value: actualFragmentName,
|
||
|
},
|
||
|
},
|
||
|
],
|
||
|
},
|
||
|
}
|
||
|
], document.definitions, true) });
|
||
|
return query;
|
||
|
}
|
||
|
function createFragmentMap(fragments) {
|
||
|
if (fragments === void 0) { fragments = []; }
|
||
|
var symTable = {};
|
||
|
fragments.forEach(function (fragment) {
|
||
|
symTable[fragment.name.value] = fragment;
|
||
|
});
|
||
|
return symTable;
|
||
|
}
|
||
|
function getFragmentFromSelection(selection, fragmentMap) {
|
||
|
switch (selection.kind) {
|
||
|
case "InlineFragment":
|
||
|
return selection;
|
||
|
case "FragmentSpread": {
|
||
|
var fragmentName = selection.name.value;
|
||
|
if (typeof fragmentMap === "function") {
|
||
|
return fragmentMap(fragmentName);
|
||
|
}
|
||
|
var fragment = fragmentMap && fragmentMap[fragmentName];
|
||
|
invariant(fragment, 73, fragmentName);
|
||
|
return fragment || null;
|
||
|
}
|
||
|
default:
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var scheduledCleanup = new WeakSet();
|
||
|
function schedule(cache) {
|
||
|
if (!scheduledCleanup.has(cache)) {
|
||
|
scheduledCleanup.add(cache);
|
||
|
setTimeout(function () {
|
||
|
cache.clean();
|
||
|
scheduledCleanup.delete(cache);
|
||
|
}, 100);
|
||
|
}
|
||
|
}
|
||
|
var AutoCleanedWeakCache = function (max, dispose) {
|
||
|
var cache = new caches.WeakCache(max, dispose);
|
||
|
cache.set = function (key, value) {
|
||
|
schedule(this);
|
||
|
return caches.WeakCache.prototype.set.call(this, key, value);
|
||
|
};
|
||
|
return cache;
|
||
|
};
|
||
|
var AutoCleanedStrongCache = function (max, dispose) {
|
||
|
var cache = new caches.StrongCache(max, dispose);
|
||
|
cache.set = function (key, value) {
|
||
|
schedule(this);
|
||
|
return caches.StrongCache.prototype.set.call(this, key, value);
|
||
|
};
|
||
|
return cache;
|
||
|
};
|
||
|
|
||
|
var cacheSizeSymbol = Symbol.for("apollo.cacheSize");
|
||
|
var cacheSizes = tslib.__assign({}, global$1[cacheSizeSymbol]);
|
||
|
|
||
|
var globalCaches = {};
|
||
|
function registerGlobalCache(name, getSize) {
|
||
|
globalCaches[name] = getSize;
|
||
|
}
|
||
|
var getApolloClientMemoryInternals = globalThis.__DEV__ !== false ?
|
||
|
_getApolloClientMemoryInternals
|
||
|
: undefined;
|
||
|
var getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ?
|
||
|
_getInMemoryCacheMemoryInternals
|
||
|
: undefined;
|
||
|
var getApolloCacheMemoryInternals = globalThis.__DEV__ !== false ?
|
||
|
_getApolloCacheMemoryInternals
|
||
|
: undefined;
|
||
|
function getCurrentCacheSizes() {
|
||
|
var defaults = {
|
||
|
parser: 1000 ,
|
||
|
canonicalStringify: 1000 ,
|
||
|
print: 2000 ,
|
||
|
"documentTransform.cache": 2000 ,
|
||
|
"queryManager.getDocumentInfo": 2000 ,
|
||
|
"PersistedQueryLink.persistedQueryHashes": 2000 ,
|
||
|
"fragmentRegistry.transform": 2000 ,
|
||
|
"fragmentRegistry.lookup": 1000 ,
|
||
|
"fragmentRegistry.findFragmentSpreads": 4000 ,
|
||
|
"cache.fragmentQueryDocuments": 1000 ,
|
||
|
"removeTypenameFromVariables.getVariableDefinitions": 2000 ,
|
||
|
"inMemoryCache.maybeBroadcastWatch": 5000 ,
|
||
|
"inMemoryCache.executeSelectionSet": 50000 ,
|
||
|
"inMemoryCache.executeSubSelectedArray": 10000 ,
|
||
|
};
|
||
|
return Object.fromEntries(Object.entries(defaults).map(function (_a) {
|
||
|
var k = _a[0], v = _a[1];
|
||
|
return [
|
||
|
k,
|
||
|
cacheSizes[k] || v,
|
||
|
];
|
||
|
}));
|
||
|
}
|
||
|
function _getApolloClientMemoryInternals() {
|
||
|
var _a, _b, _c, _d, _e;
|
||
|
if (!(globalThis.__DEV__ !== false))
|
||
|
throw new Error("only supported in development mode");
|
||
|
return {
|
||
|
limits: getCurrentCacheSizes(),
|
||
|
sizes: tslib.__assign({ print: (_a = globalCaches.print) === null || _a === void 0 ? void 0 : _a.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {
|
||
|
getDocumentInfo: this["queryManager"]["transformCache"].size,
|
||
|
documentTransforms: transformInfo(this["queryManager"].documentTransform),
|
||
|
} }, (_e = (_d = this.cache).getMemoryInternals) === null || _e === void 0 ? void 0 : _e.call(_d)),
|
||
|
};
|
||
|
}
|
||
|
function _getApolloCacheMemoryInternals() {
|
||
|
return {
|
||
|
cache: {
|
||
|
fragmentQueryDocuments: getWrapperInformation(this["getFragmentDoc"]),
|
||
|
},
|
||
|
};
|
||
|
}
|
||
|
function _getInMemoryCacheMemoryInternals() {
|
||
|
var fragments = this.config.fragments;
|
||
|
return tslib.__assign(tslib.__assign({}, _getApolloCacheMemoryInternals.apply(this)), { addTypenameDocumentTransform: transformInfo(this["addTypenameTransform"]), inMemoryCache: {
|
||
|
executeSelectionSet: getWrapperInformation(this["storeReader"]["executeSelectionSet"]),
|
||
|
executeSubSelectedArray: getWrapperInformation(this["storeReader"]["executeSubSelectedArray"]),
|
||
|
maybeBroadcastWatch: getWrapperInformation(this["maybeBroadcastWatch"]),
|
||
|
}, fragmentRegistry: {
|
||
|
findFragmentSpreads: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.findFragmentSpreads),
|
||
|
lookup: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.lookup),
|
||
|
transform: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.transform),
|
||
|
} });
|
||
|
}
|
||
|
function isWrapper(f) {
|
||
|
return !!f && "dirtyKey" in f;
|
||
|
}
|
||
|
function getWrapperInformation(f) {
|
||
|
return isWrapper(f) ? f.size : undefined;
|
||
|
}
|
||
|
function isDefined(value) {
|
||
|
return value != null;
|
||
|
}
|
||
|
function transformInfo(transform) {
|
||
|
return recurseTransformInfo(transform).map(function (cache) { return ({ cache: cache }); });
|
||
|
}
|
||
|
function recurseTransformInfo(transform) {
|
||
|
return transform ?
|
||
|
tslib.__spreadArray(tslib.__spreadArray([
|
||
|
getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform["performWork"])
|
||
|
], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["left"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["right"]), true).filter(isDefined)
|
||
|
: [];
|
||
|
}
|
||
|
function linkInfo(link) {
|
||
|
var _a;
|
||
|
return link ?
|
||
|
tslib.__spreadArray(tslib.__spreadArray([
|
||
|
(_a = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a === void 0 ? void 0 : _a.call(link)
|
||
|
], linkInfo(link === null || link === void 0 ? void 0 : link.left), true), linkInfo(link === null || link === void 0 ? void 0 : link.right), true).filter(isDefined)
|
||
|
: [];
|
||
|
}
|
||
|
|
||
|
var canonicalStringify = Object.assign(function canonicalStringify(value) {
|
||
|
return JSON.stringify(value, stableObjectReplacer);
|
||
|
}, {
|
||
|
reset: function () {
|
||
|
sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 );
|
||
|
},
|
||
|
});
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
registerGlobalCache("canonicalStringify", function () { return sortingMap.size; });
|
||
|
}
|
||
|
var sortingMap;
|
||
|
canonicalStringify.reset();
|
||
|
function stableObjectReplacer(key, value) {
|
||
|
if (value && typeof value === "object") {
|
||
|
var proto = Object.getPrototypeOf(value);
|
||
|
if (proto === Object.prototype || proto === null) {
|
||
|
var keys = Object.keys(value);
|
||
|
if (keys.every(everyKeyInOrder))
|
||
|
return value;
|
||
|
var unsortedKey = JSON.stringify(keys);
|
||
|
var sortedKeys = sortingMap.get(unsortedKey);
|
||
|
if (!sortedKeys) {
|
||
|
keys.sort();
|
||
|
var sortedKey = JSON.stringify(keys);
|
||
|
sortedKeys = sortingMap.get(sortedKey) || keys;
|
||
|
sortingMap.set(unsortedKey, sortedKeys);
|
||
|
sortingMap.set(sortedKey, sortedKeys);
|
||
|
}
|
||
|
var sortedObject_1 = Object.create(proto);
|
||
|
sortedKeys.forEach(function (key) {
|
||
|
sortedObject_1[key] = value[key];
|
||
|
});
|
||
|
return sortedObject_1;
|
||
|
}
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
function everyKeyInOrder(key, i, keys) {
|
||
|
return i === 0 || keys[i - 1] <= key;
|
||
|
}
|
||
|
|
||
|
function makeReference(id) {
|
||
|
return { __ref: String(id) };
|
||
|
}
|
||
|
function isReference(obj) {
|
||
|
return Boolean(obj && typeof obj === "object" && typeof obj.__ref === "string");
|
||
|
}
|
||
|
function isDocumentNode(value) {
|
||
|
return (isNonNullObject(value) &&
|
||
|
value.kind === "Document" &&
|
||
|
Array.isArray(value.definitions));
|
||
|
}
|
||
|
function isStringValue(value) {
|
||
|
return value.kind === "StringValue";
|
||
|
}
|
||
|
function isBooleanValue(value) {
|
||
|
return value.kind === "BooleanValue";
|
||
|
}
|
||
|
function isIntValue(value) {
|
||
|
return value.kind === "IntValue";
|
||
|
}
|
||
|
function isFloatValue(value) {
|
||
|
return value.kind === "FloatValue";
|
||
|
}
|
||
|
function isVariable(value) {
|
||
|
return value.kind === "Variable";
|
||
|
}
|
||
|
function isObjectValue(value) {
|
||
|
return value.kind === "ObjectValue";
|
||
|
}
|
||
|
function isListValue(value) {
|
||
|
return value.kind === "ListValue";
|
||
|
}
|
||
|
function isEnumValue(value) {
|
||
|
return value.kind === "EnumValue";
|
||
|
}
|
||
|
function isNullValue(value) {
|
||
|
return value.kind === "NullValue";
|
||
|
}
|
||
|
function valueToObjectRepresentation(argObj, name, value, variables) {
|
||
|
if (isIntValue(value) || isFloatValue(value)) {
|
||
|
argObj[name.value] = Number(value.value);
|
||
|
}
|
||
|
else if (isBooleanValue(value) || isStringValue(value)) {
|
||
|
argObj[name.value] = value.value;
|
||
|
}
|
||
|
else if (isObjectValue(value)) {
|
||
|
var nestedArgObj_1 = {};
|
||
|
value.fields.map(function (obj) {
|
||
|
return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);
|
||
|
});
|
||
|
argObj[name.value] = nestedArgObj_1;
|
||
|
}
|
||
|
else if (isVariable(value)) {
|
||
|
var variableValue = (variables || {})[value.name.value];
|
||
|
argObj[name.value] = variableValue;
|
||
|
}
|
||
|
else if (isListValue(value)) {
|
||
|
argObj[name.value] = value.values.map(function (listValue) {
|
||
|
var nestedArgArrayObj = {};
|
||
|
valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);
|
||
|
return nestedArgArrayObj[name.value];
|
||
|
});
|
||
|
}
|
||
|
else if (isEnumValue(value)) {
|
||
|
argObj[name.value] = value.value;
|
||
|
}
|
||
|
else if (isNullValue(value)) {
|
||
|
argObj[name.value] = null;
|
||
|
}
|
||
|
else {
|
||
|
throw newInvariantError(82, name.value, value.kind);
|
||
|
}
|
||
|
}
|
||
|
function storeKeyNameFromField(field, variables) {
|
||
|
var directivesObj = null;
|
||
|
if (field.directives) {
|
||
|
directivesObj = {};
|
||
|
field.directives.forEach(function (directive) {
|
||
|
directivesObj[directive.name.value] = {};
|
||
|
if (directive.arguments) {
|
||
|
directive.arguments.forEach(function (_a) {
|
||
|
var name = _a.name, value = _a.value;
|
||
|
return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);
|
||
|
});
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
var argObj = null;
|
||
|
if (field.arguments && field.arguments.length) {
|
||
|
argObj = {};
|
||
|
field.arguments.forEach(function (_a) {
|
||
|
var name = _a.name, value = _a.value;
|
||
|
return valueToObjectRepresentation(argObj, name, value, variables);
|
||
|
});
|
||
|
}
|
||
|
return getStoreKeyName(field.name.value, argObj, directivesObj);
|
||
|
}
|
||
|
var KNOWN_DIRECTIVES = [
|
||
|
"connection",
|
||
|
"include",
|
||
|
"skip",
|
||
|
"client",
|
||
|
"rest",
|
||
|
"export",
|
||
|
"nonreactive",
|
||
|
];
|
||
|
var storeKeyNameStringify = canonicalStringify;
|
||
|
var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
|
||
|
if (args &&
|
||
|
directives &&
|
||
|
directives["connection"] &&
|
||
|
directives["connection"]["key"]) {
|
||
|
if (directives["connection"]["filter"] &&
|
||
|
directives["connection"]["filter"].length > 0) {
|
||
|
var filterKeys = directives["connection"]["filter"] ?
|
||
|
directives["connection"]["filter"]
|
||
|
: [];
|
||
|
filterKeys.sort();
|
||
|
var filteredArgs_1 = {};
|
||
|
filterKeys.forEach(function (key) {
|
||
|
filteredArgs_1[key] = args[key];
|
||
|
});
|
||
|
return "".concat(directives["connection"]["key"], "(").concat(storeKeyNameStringify(filteredArgs_1), ")");
|
||
|
}
|
||
|
else {
|
||
|
return directives["connection"]["key"];
|
||
|
}
|
||
|
}
|
||
|
var completeFieldName = fieldName;
|
||
|
if (args) {
|
||
|
var stringifiedArgs = storeKeyNameStringify(args);
|
||
|
completeFieldName += "(".concat(stringifiedArgs, ")");
|
||
|
}
|
||
|
if (directives) {
|
||
|
Object.keys(directives).forEach(function (key) {
|
||
|
if (KNOWN_DIRECTIVES.indexOf(key) !== -1)
|
||
|
return;
|
||
|
if (directives[key] && Object.keys(directives[key]).length) {
|
||
|
completeFieldName += "@".concat(key, "(").concat(storeKeyNameStringify(directives[key]), ")");
|
||
|
}
|
||
|
else {
|
||
|
completeFieldName += "@".concat(key);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return completeFieldName;
|
||
|
}, {
|
||
|
setStringify: function (s) {
|
||
|
var previous = storeKeyNameStringify;
|
||
|
storeKeyNameStringify = s;
|
||
|
return previous;
|
||
|
},
|
||
|
});
|
||
|
function argumentsObjectFromField(field, variables) {
|
||
|
if (field.arguments && field.arguments.length) {
|
||
|
var argObj_1 = {};
|
||
|
field.arguments.forEach(function (_a) {
|
||
|
var name = _a.name, value = _a.value;
|
||
|
return valueToObjectRepresentation(argObj_1, name, value, variables);
|
||
|
});
|
||
|
return argObj_1;
|
||
|
}
|
||
|
return null;
|
||
|
}
|
||
|
function resultKeyNameFromField(field) {
|
||
|
return field.alias ? field.alias.value : field.name.value;
|
||
|
}
|
||
|
function getTypenameFromResult(result, selectionSet, fragmentMap) {
|
||
|
var fragments;
|
||
|
for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {
|
||
|
var selection = _a[_i];
|
||
|
if (isField(selection)) {
|
||
|
if (selection.name.value === "__typename") {
|
||
|
return result[resultKeyNameFromField(selection)];
|
||
|
}
|
||
|
}
|
||
|
else if (fragments) {
|
||
|
fragments.push(selection);
|
||
|
}
|
||
|
else {
|
||
|
fragments = [selection];
|
||
|
}
|
||
|
}
|
||
|
if (typeof result.__typename === "string") {
|
||
|
return result.__typename;
|
||
|
}
|
||
|
if (fragments) {
|
||
|
for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {
|
||
|
var selection = fragments_1[_b];
|
||
|
var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);
|
||
|
if (typeof typename === "string") {
|
||
|
return typename;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
function isField(selection) {
|
||
|
return selection.kind === "Field";
|
||
|
}
|
||
|
function isInlineFragment(selection) {
|
||
|
return selection.kind === "InlineFragment";
|
||
|
}
|
||
|
|
||
|
function checkDocument(doc) {
|
||
|
invariant(doc && doc.kind === "Document", 74);
|
||
|
var operations = doc.definitions
|
||
|
.filter(function (d) { return d.kind !== "FragmentDefinition"; })
|
||
|
.map(function (definition) {
|
||
|
if (definition.kind !== "OperationDefinition") {
|
||
|
throw newInvariantError(75, definition.kind);
|
||
|
}
|
||
|
return definition;
|
||
|
});
|
||
|
invariant(operations.length <= 1, 76, operations.length);
|
||
|
return doc;
|
||
|
}
|
||
|
function getOperationDefinition(doc) {
|
||
|
checkDocument(doc);
|
||
|
return doc.definitions.filter(function (definition) {
|
||
|
return definition.kind === "OperationDefinition";
|
||
|
})[0];
|
||
|
}
|
||
|
function getOperationName(doc) {
|
||
|
return (doc.definitions
|
||
|
.filter(function (definition) {
|
||
|
return definition.kind === "OperationDefinition" && !!definition.name;
|
||
|
})
|
||
|
.map(function (x) { return x.name.value; })[0] || null);
|
||
|
}
|
||
|
function getFragmentDefinitions(doc) {
|
||
|
return doc.definitions.filter(function (definition) {
|
||
|
return definition.kind === "FragmentDefinition";
|
||
|
});
|
||
|
}
|
||
|
function getQueryDefinition(doc) {
|
||
|
var queryDef = getOperationDefinition(doc);
|
||
|
invariant(queryDef && queryDef.operation === "query", 77);
|
||
|
return queryDef;
|
||
|
}
|
||
|
function getFragmentDefinition(doc) {
|
||
|
invariant(doc.kind === "Document", 78);
|
||
|
invariant(doc.definitions.length <= 1, 79);
|
||
|
var fragmentDef = doc.definitions[0];
|
||
|
invariant(fragmentDef.kind === "FragmentDefinition", 80);
|
||
|
return fragmentDef;
|
||
|
}
|
||
|
function getMainDefinition(queryDoc) {
|
||
|
checkDocument(queryDoc);
|
||
|
var fragmentDefinition;
|
||
|
for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {
|
||
|
var definition = _a[_i];
|
||
|
if (definition.kind === "OperationDefinition") {
|
||
|
var operation = definition.operation;
|
||
|
if (operation === "query" ||
|
||
|
operation === "mutation" ||
|
||
|
operation === "subscription") {
|
||
|
return definition;
|
||
|
}
|
||
|
}
|
||
|
if (definition.kind === "FragmentDefinition" && !fragmentDefinition) {
|
||
|
fragmentDefinition = definition;
|
||
|
}
|
||
|
}
|
||
|
if (fragmentDefinition) {
|
||
|
return fragmentDefinition;
|
||
|
}
|
||
|
throw newInvariantError(81);
|
||
|
}
|
||
|
function getDefaultValues(definition) {
|
||
|
var defaultValues = Object.create(null);
|
||
|
var defs = definition && definition.variableDefinitions;
|
||
|
if (defs && defs.length) {
|
||
|
defs.forEach(function (def) {
|
||
|
if (def.defaultValue) {
|
||
|
valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return defaultValues;
|
||
|
}
|
||
|
|
||
|
function identity(document) {
|
||
|
return document;
|
||
|
}
|
||
|
var DocumentTransform = (function () {
|
||
|
function DocumentTransform(transform, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
this.resultCache = canUseWeakSet ? new WeakSet() : new Set();
|
||
|
this.transform = transform;
|
||
|
if (options.getCacheKey) {
|
||
|
this.getCacheKey = options.getCacheKey;
|
||
|
}
|
||
|
this.cached = options.cache !== false;
|
||
|
this.resetCache();
|
||
|
}
|
||
|
DocumentTransform.prototype.getCacheKey = function (document) {
|
||
|
return [document];
|
||
|
};
|
||
|
DocumentTransform.identity = function () {
|
||
|
return new DocumentTransform(identity, { cache: false });
|
||
|
};
|
||
|
DocumentTransform.split = function (predicate, left, right) {
|
||
|
if (right === void 0) { right = DocumentTransform.identity(); }
|
||
|
return Object.assign(new DocumentTransform(function (document) {
|
||
|
var documentTransform = predicate(document) ? left : right;
|
||
|
return documentTransform.transformDocument(document);
|
||
|
},
|
||
|
{ cache: false }), { left: left, right: right });
|
||
|
};
|
||
|
DocumentTransform.prototype.resetCache = function () {
|
||
|
var _this = this;
|
||
|
if (this.cached) {
|
||
|
var stableCacheKeys_1 = new trie.Trie(canUseWeakMap);
|
||
|
this.performWork = optimism.wrap(DocumentTransform.prototype.performWork.bind(this), {
|
||
|
makeCacheKey: function (document) {
|
||
|
var cacheKeys = _this.getCacheKey(document);
|
||
|
if (cacheKeys) {
|
||
|
invariant(Array.isArray(cacheKeys), 66);
|
||
|
return stableCacheKeys_1.lookupArray(cacheKeys);
|
||
|
}
|
||
|
},
|
||
|
max: cacheSizes["documentTransform.cache"],
|
||
|
cache: (caches.WeakCache),
|
||
|
});
|
||
|
}
|
||
|
};
|
||
|
DocumentTransform.prototype.performWork = function (document) {
|
||
|
checkDocument(document);
|
||
|
return this.transform(document);
|
||
|
};
|
||
|
DocumentTransform.prototype.transformDocument = function (document) {
|
||
|
if (this.resultCache.has(document)) {
|
||
|
return document;
|
||
|
}
|
||
|
var transformedDocument = this.performWork(document);
|
||
|
this.resultCache.add(transformedDocument);
|
||
|
return transformedDocument;
|
||
|
};
|
||
|
DocumentTransform.prototype.concat = function (otherTransform) {
|
||
|
var _this = this;
|
||
|
return Object.assign(new DocumentTransform(function (document) {
|
||
|
return otherTransform.transformDocument(_this.transformDocument(document));
|
||
|
},
|
||
|
{ cache: false }), {
|
||
|
left: this,
|
||
|
right: otherTransform,
|
||
|
});
|
||
|
};
|
||
|
return DocumentTransform;
|
||
|
}());
|
||
|
|
||
|
var printCache;
|
||
|
var print = Object.assign(function (ast) {
|
||
|
var result = printCache.get(ast);
|
||
|
if (!result) {
|
||
|
result = graphql.print(ast);
|
||
|
printCache.set(ast, result);
|
||
|
}
|
||
|
return result;
|
||
|
}, {
|
||
|
reset: function () {
|
||
|
printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 );
|
||
|
},
|
||
|
});
|
||
|
print.reset();
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
registerGlobalCache("print", function () { return (printCache ? printCache.size : 0); });
|
||
|
}
|
||
|
|
||
|
var isArray = Array.isArray;
|
||
|
function isNonEmptyArray(value) {
|
||
|
return Array.isArray(value) && value.length > 0;
|
||
|
}
|
||
|
|
||
|
var TYPENAME_FIELD = {
|
||
|
kind: graphql.Kind.FIELD,
|
||
|
name: {
|
||
|
kind: graphql.Kind.NAME,
|
||
|
value: "__typename",
|
||
|
},
|
||
|
};
|
||
|
function isEmpty(op, fragmentMap) {
|
||
|
return (!op ||
|
||
|
op.selectionSet.selections.every(function (selection) {
|
||
|
return selection.kind === graphql.Kind.FRAGMENT_SPREAD &&
|
||
|
isEmpty(fragmentMap[selection.name.value], fragmentMap);
|
||
|
}));
|
||
|
}
|
||
|
function nullIfDocIsEmpty(doc) {
|
||
|
return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?
|
||
|
null
|
||
|
: doc;
|
||
|
}
|
||
|
function getDirectiveMatcher(configs) {
|
||
|
var names = new Map();
|
||
|
var tests = new Map();
|
||
|
configs.forEach(function (directive) {
|
||
|
if (directive) {
|
||
|
if (directive.name) {
|
||
|
names.set(directive.name, directive);
|
||
|
}
|
||
|
else if (directive.test) {
|
||
|
tests.set(directive.test, directive);
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
return function (directive) {
|
||
|
var config = names.get(directive.name.value);
|
||
|
if (!config && tests.size) {
|
||
|
tests.forEach(function (testConfig, test) {
|
||
|
if (test(directive)) {
|
||
|
config = testConfig;
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return config;
|
||
|
};
|
||
|
}
|
||
|
function makeInUseGetterFunction(defaultKey) {
|
||
|
var map = new Map();
|
||
|
return function inUseGetterFunction(key) {
|
||
|
if (key === void 0) { key = defaultKey; }
|
||
|
var inUse = map.get(key);
|
||
|
if (!inUse) {
|
||
|
map.set(key, (inUse = {
|
||
|
variables: new Set(),
|
||
|
fragmentSpreads: new Set(),
|
||
|
}));
|
||
|
}
|
||
|
return inUse;
|
||
|
};
|
||
|
}
|
||
|
function removeDirectivesFromDocument(directives, doc) {
|
||
|
checkDocument(doc);
|
||
|
var getInUseByOperationName = makeInUseGetterFunction("");
|
||
|
var getInUseByFragmentName = makeInUseGetterFunction("");
|
||
|
var getInUse = function (ancestors) {
|
||
|
for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
|
||
|
if (isArray(ancestor))
|
||
|
continue;
|
||
|
if (ancestor.kind === graphql.Kind.OPERATION_DEFINITION) {
|
||
|
return getInUseByOperationName(ancestor.name && ancestor.name.value);
|
||
|
}
|
||
|
if (ancestor.kind === graphql.Kind.FRAGMENT_DEFINITION) {
|
||
|
return getInUseByFragmentName(ancestor.name.value);
|
||
|
}
|
||
|
}
|
||
|
globalThis.__DEV__ !== false && invariant.error(83);
|
||
|
return null;
|
||
|
};
|
||
|
var operationCount = 0;
|
||
|
for (var i = doc.definitions.length - 1; i >= 0; --i) {
|
||
|
if (doc.definitions[i].kind === graphql.Kind.OPERATION_DEFINITION) {
|
||
|
++operationCount;
|
||
|
}
|
||
|
}
|
||
|
var directiveMatcher = getDirectiveMatcher(directives);
|
||
|
var shouldRemoveField = function (nodeDirectives) {
|
||
|
return isNonEmptyArray(nodeDirectives) &&
|
||
|
nodeDirectives
|
||
|
.map(directiveMatcher)
|
||
|
.some(function (config) { return config && config.remove; });
|
||
|
};
|
||
|
var originalFragmentDefsByPath = new Map();
|
||
|
var firstVisitMadeChanges = false;
|
||
|
var fieldOrInlineFragmentVisitor = {
|
||
|
enter: function (node) {
|
||
|
if (shouldRemoveField(node.directives)) {
|
||
|
firstVisitMadeChanges = true;
|
||
|
return null;
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
var docWithoutDirectiveSubtrees = graphql.visit(doc, {
|
||
|
Field: fieldOrInlineFragmentVisitor,
|
||
|
InlineFragment: fieldOrInlineFragmentVisitor,
|
||
|
VariableDefinition: {
|
||
|
enter: function () {
|
||
|
return false;
|
||
|
},
|
||
|
},
|
||
|
Variable: {
|
||
|
enter: function (node, _key, _parent, _path, ancestors) {
|
||
|
var inUse = getInUse(ancestors);
|
||
|
if (inUse) {
|
||
|
inUse.variables.add(node.name.value);
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
FragmentSpread: {
|
||
|
enter: function (node, _key, _parent, _path, ancestors) {
|
||
|
if (shouldRemoveField(node.directives)) {
|
||
|
firstVisitMadeChanges = true;
|
||
|
return null;
|
||
|
}
|
||
|
var inUse = getInUse(ancestors);
|
||
|
if (inUse) {
|
||
|
inUse.fragmentSpreads.add(node.name.value);
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
FragmentDefinition: {
|
||
|
enter: function (node, _key, _parent, path) {
|
||
|
originalFragmentDefsByPath.set(JSON.stringify(path), node);
|
||
|
},
|
||
|
leave: function (node, _key, _parent, path) {
|
||
|
var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
|
||
|
if (node === originalNode) {
|
||
|
return node;
|
||
|
}
|
||
|
if (
|
||
|
operationCount > 0 &&
|
||
|
node.selectionSet.selections.every(function (selection) {
|
||
|
return selection.kind === graphql.Kind.FIELD &&
|
||
|
selection.name.value === "__typename";
|
||
|
})) {
|
||
|
getInUseByFragmentName(node.name.value).removed = true;
|
||
|
firstVisitMadeChanges = true;
|
||
|
return null;
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
Directive: {
|
||
|
leave: function (node) {
|
||
|
if (directiveMatcher(node)) {
|
||
|
firstVisitMadeChanges = true;
|
||
|
return null;
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
});
|
||
|
if (!firstVisitMadeChanges) {
|
||
|
return doc;
|
||
|
}
|
||
|
var populateTransitiveVars = function (inUse) {
|
||
|
if (!inUse.transitiveVars) {
|
||
|
inUse.transitiveVars = new Set(inUse.variables);
|
||
|
if (!inUse.removed) {
|
||
|
inUse.fragmentSpreads.forEach(function (childFragmentName) {
|
||
|
populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {
|
||
|
inUse.transitiveVars.add(varName);
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
return inUse;
|
||
|
};
|
||
|
var allFragmentNamesUsed = new Set();
|
||
|
docWithoutDirectiveSubtrees.definitions.forEach(function (def) {
|
||
|
if (def.kind === graphql.Kind.OPERATION_DEFINITION) {
|
||
|
populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {
|
||
|
allFragmentNamesUsed.add(childFragmentName);
|
||
|
});
|
||
|
}
|
||
|
else if (def.kind === graphql.Kind.FRAGMENT_DEFINITION &&
|
||
|
operationCount === 0 &&
|
||
|
!getInUseByFragmentName(def.name.value).removed) {
|
||
|
allFragmentNamesUsed.add(def.name.value);
|
||
|
}
|
||
|
});
|
||
|
allFragmentNamesUsed.forEach(function (fragmentName) {
|
||
|
populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {
|
||
|
allFragmentNamesUsed.add(childFragmentName);
|
||
|
});
|
||
|
});
|
||
|
var fragmentWillBeRemoved = function (fragmentName) {
|
||
|
return !!(
|
||
|
(!allFragmentNamesUsed.has(fragmentName) ||
|
||
|
getInUseByFragmentName(fragmentName).removed));
|
||
|
};
|
||
|
var enterVisitor = {
|
||
|
enter: function (node) {
|
||
|
if (fragmentWillBeRemoved(node.name.value)) {
|
||
|
return null;
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
return nullIfDocIsEmpty(graphql.visit(docWithoutDirectiveSubtrees, {
|
||
|
FragmentSpread: enterVisitor,
|
||
|
FragmentDefinition: enterVisitor,
|
||
|
OperationDefinition: {
|
||
|
leave: function (node) {
|
||
|
if (node.variableDefinitions) {
|
||
|
var usedVariableNames_1 = populateTransitiveVars(
|
||
|
getInUseByOperationName(node.name && node.name.value)).transitiveVars;
|
||
|
if (usedVariableNames_1.size < node.variableDefinitions.length) {
|
||
|
return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {
|
||
|
return usedVariableNames_1.has(varDef.variable.name.value);
|
||
|
}) });
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
}));
|
||
|
}
|
||
|
var addTypenameToDocument = Object.assign(function (doc) {
|
||
|
return graphql.visit(doc, {
|
||
|
SelectionSet: {
|
||
|
enter: function (node, _key, parent) {
|
||
|
if (parent &&
|
||
|
parent.kind ===
|
||
|
graphql.Kind.OPERATION_DEFINITION) {
|
||
|
return;
|
||
|
}
|
||
|
var selections = node.selections;
|
||
|
if (!selections) {
|
||
|
return;
|
||
|
}
|
||
|
var skip = selections.some(function (selection) {
|
||
|
return (isField(selection) &&
|
||
|
(selection.name.value === "__typename" ||
|
||
|
selection.name.value.lastIndexOf("__", 0) === 0));
|
||
|
});
|
||
|
if (skip) {
|
||
|
return;
|
||
|
}
|
||
|
var field = parent;
|
||
|
if (isField(field) &&
|
||
|
field.directives &&
|
||
|
field.directives.some(function (d) { return d.name.value === "export"; })) {
|
||
|
return;
|
||
|
}
|
||
|
return tslib.__assign(tslib.__assign({}, node), { selections: tslib.__spreadArray(tslib.__spreadArray([], selections, true), [TYPENAME_FIELD], false) });
|
||
|
},
|
||
|
},
|
||
|
});
|
||
|
}, {
|
||
|
added: function (field) {
|
||
|
return field === TYPENAME_FIELD;
|
||
|
},
|
||
|
});
|
||
|
function buildQueryFromSelectionSet(document) {
|
||
|
var definition = getMainDefinition(document);
|
||
|
var definitionOperation = definition.operation;
|
||
|
if (definitionOperation === "query") {
|
||
|
return document;
|
||
|
}
|
||
|
var modifiedDoc = graphql.visit(document, {
|
||
|
OperationDefinition: {
|
||
|
enter: function (node) {
|
||
|
return tslib.__assign(tslib.__assign({}, node), { operation: "query" });
|
||
|
},
|
||
|
},
|
||
|
});
|
||
|
return modifiedDoc;
|
||
|
}
|
||
|
function removeClientSetsFromDocument(document) {
|
||
|
checkDocument(document);
|
||
|
var modifiedDoc = removeDirectivesFromDocument([
|
||
|
{
|
||
|
test: function (directive) { return directive.name.value === "client"; },
|
||
|
remove: true,
|
||
|
},
|
||
|
], document);
|
||
|
return modifiedDoc;
|
||
|
}
|
||
|
|
||
|
var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
|
||
|
function mergeDeep() {
|
||
|
var sources = [];
|
||
|
for (var _i = 0; _i < arguments.length; _i++) {
|
||
|
sources[_i] = arguments[_i];
|
||
|
}
|
||
|
return mergeDeepArray(sources);
|
||
|
}
|
||
|
function mergeDeepArray(sources) {
|
||
|
var target = sources[0] || {};
|
||
|
var count = sources.length;
|
||
|
if (count > 1) {
|
||
|
var merger = new DeepMerger();
|
||
|
for (var i = 1; i < count; ++i) {
|
||
|
target = merger.merge(target, sources[i]);
|
||
|
}
|
||
|
}
|
||
|
return target;
|
||
|
}
|
||
|
var defaultReconciler = function (target, source, property) {
|
||
|
return this.merge(target[property], source[property]);
|
||
|
};
|
||
|
var DeepMerger = (function () {
|
||
|
function DeepMerger(reconciler) {
|
||
|
if (reconciler === void 0) { reconciler = defaultReconciler; }
|
||
|
this.reconciler = reconciler;
|
||
|
this.isObject = isNonNullObject;
|
||
|
this.pastCopies = new Set();
|
||
|
}
|
||
|
DeepMerger.prototype.merge = function (target, source) {
|
||
|
var _this = this;
|
||
|
var context = [];
|
||
|
for (var _i = 2; _i < arguments.length; _i++) {
|
||
|
context[_i - 2] = arguments[_i];
|
||
|
}
|
||
|
if (isNonNullObject(source) && isNonNullObject(target)) {
|
||
|
Object.keys(source).forEach(function (sourceKey) {
|
||
|
if (hasOwnProperty$4.call(target, sourceKey)) {
|
||
|
var targetValue = target[sourceKey];
|
||
|
if (source[sourceKey] !== targetValue) {
|
||
|
var result = _this.reconciler.apply(_this, tslib.__spreadArray([target,
|
||
|
source,
|
||
|
sourceKey], context, false));
|
||
|
if (result !== targetValue) {
|
||
|
target = _this.shallowCopyForMerge(target);
|
||
|
target[sourceKey] = result;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
target = _this.shallowCopyForMerge(target);
|
||
|
target[sourceKey] = source[sourceKey];
|
||
|
}
|
||
|
});
|
||
|
return target;
|
||
|
}
|
||
|
return source;
|
||
|
};
|
||
|
DeepMerger.prototype.shallowCopyForMerge = function (value) {
|
||
|
if (isNonNullObject(value)) {
|
||
|
if (!this.pastCopies.has(value)) {
|
||
|
if (Array.isArray(value)) {
|
||
|
value = value.slice(0);
|
||
|
}
|
||
|
else {
|
||
|
value = tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
|
||
|
}
|
||
|
this.pastCopies.add(value);
|
||
|
}
|
||
|
}
|
||
|
return value;
|
||
|
};
|
||
|
return DeepMerger;
|
||
|
}());
|
||
|
|
||
|
function createFulfilledPromise(value) {
|
||
|
var promise = Promise.resolve(value);
|
||
|
promise.status = "fulfilled";
|
||
|
promise.value = value;
|
||
|
return promise;
|
||
|
}
|
||
|
function createRejectedPromise(reason) {
|
||
|
var promise = Promise.reject(reason);
|
||
|
promise.catch(function () { });
|
||
|
promise.status = "rejected";
|
||
|
promise.reason = reason;
|
||
|
return promise;
|
||
|
}
|
||
|
function isStatefulPromise(promise) {
|
||
|
return "status" in promise;
|
||
|
}
|
||
|
function wrapPromiseWithState(promise) {
|
||
|
if (isStatefulPromise(promise)) {
|
||
|
return promise;
|
||
|
}
|
||
|
var pendingPromise = promise;
|
||
|
pendingPromise.status = "pending";
|
||
|
pendingPromise.then(function (value) {
|
||
|
if (pendingPromise.status === "pending") {
|
||
|
var fulfilledPromise = pendingPromise;
|
||
|
fulfilledPromise.status = "fulfilled";
|
||
|
fulfilledPromise.value = value;
|
||
|
}
|
||
|
}, function (reason) {
|
||
|
if (pendingPromise.status === "pending") {
|
||
|
var rejectedPromise = pendingPromise;
|
||
|
rejectedPromise.status = "rejected";
|
||
|
rejectedPromise.reason = reason;
|
||
|
}
|
||
|
});
|
||
|
return promise;
|
||
|
}
|
||
|
|
||
|
var toString = Object.prototype.toString;
|
||
|
function cloneDeep(value) {
|
||
|
return cloneDeepHelper(value);
|
||
|
}
|
||
|
function cloneDeepHelper(val, seen) {
|
||
|
switch (toString.call(val)) {
|
||
|
case "[object Array]": {
|
||
|
seen = seen || new Map();
|
||
|
if (seen.has(val))
|
||
|
return seen.get(val);
|
||
|
var copy_1 = val.slice(0);
|
||
|
seen.set(val, copy_1);
|
||
|
copy_1.forEach(function (child, i) {
|
||
|
copy_1[i] = cloneDeepHelper(child, seen);
|
||
|
});
|
||
|
return copy_1;
|
||
|
}
|
||
|
case "[object Object]": {
|
||
|
seen = seen || new Map();
|
||
|
if (seen.has(val))
|
||
|
return seen.get(val);
|
||
|
var copy_2 = Object.create(Object.getPrototypeOf(val));
|
||
|
seen.set(val, copy_2);
|
||
|
Object.keys(val).forEach(function (key) {
|
||
|
copy_2[key] = cloneDeepHelper(val[key], seen);
|
||
|
});
|
||
|
return copy_2;
|
||
|
}
|
||
|
default:
|
||
|
return val;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function deepFreeze(value) {
|
||
|
var workSet = new Set([value]);
|
||
|
workSet.forEach(function (obj) {
|
||
|
if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {
|
||
|
Object.getOwnPropertyNames(obj).forEach(function (name) {
|
||
|
if (isNonNullObject(obj[name]))
|
||
|
workSet.add(obj[name]);
|
||
|
});
|
||
|
}
|
||
|
});
|
||
|
return value;
|
||
|
}
|
||
|
function shallowFreeze(obj) {
|
||
|
if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {
|
||
|
try {
|
||
|
Object.freeze(obj);
|
||
|
}
|
||
|
catch (e) {
|
||
|
if (e instanceof TypeError)
|
||
|
return null;
|
||
|
throw e;
|
||
|
}
|
||
|
}
|
||
|
return obj;
|
||
|
}
|
||
|
function maybeDeepFreeze(obj) {
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
deepFreeze(obj);
|
||
|
}
|
||
|
return obj;
|
||
|
}
|
||
|
|
||
|
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 asyncMap(observable, mapFn, catchFn) {
|
||
|
return new zenObservableTs.Observable(function (observer) {
|
||
|
var promiseQueue = {
|
||
|
then: function (callback) {
|
||
|
return new Promise(function (resolve) { return resolve(callback()); });
|
||
|
},
|
||
|
};
|
||
|
function makeCallback(examiner, key) {
|
||
|
return function (arg) {
|
||
|
if (examiner) {
|
||
|
var both = function () {
|
||
|
return observer.closed ?
|
||
|
0
|
||
|
: examiner(arg);
|
||
|
};
|
||
|
promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });
|
||
|
}
|
||
|
else {
|
||
|
observer[key](arg);
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
var handler = {
|
||
|
next: makeCallback(mapFn, "next"),
|
||
|
error: makeCallback(catchFn, "error"),
|
||
|
complete: function () {
|
||
|
promiseQueue.then(function () { return observer.complete(); });
|
||
|
},
|
||
|
};
|
||
|
var sub = observable.subscribe(handler);
|
||
|
return function () { return sub.unsubscribe(); };
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function fixObservableSubclass(subclass) {
|
||
|
function set(key) {
|
||
|
Object.defineProperty(subclass, key, { value: zenObservableTs.Observable });
|
||
|
}
|
||
|
if (canUseSymbol && Symbol.species) {
|
||
|
set(Symbol.species);
|
||
|
}
|
||
|
set("@@species");
|
||
|
return subclass;
|
||
|
}
|
||
|
|
||
|
function isPromiseLike(value) {
|
||
|
return value && typeof value.then === "function";
|
||
|
}
|
||
|
var Concast = (function (_super) {
|
||
|
tslib.__extends(Concast, _super);
|
||
|
function Concast(sources) {
|
||
|
var _this = _super.call(this, function (observer) {
|
||
|
_this.addObserver(observer);
|
||
|
return function () { return _this.removeObserver(observer); };
|
||
|
}) || this;
|
||
|
_this.observers = new Set();
|
||
|
_this.promise = new Promise(function (resolve, reject) {
|
||
|
_this.resolve = resolve;
|
||
|
_this.reject = reject;
|
||
|
});
|
||
|
_this.handlers = {
|
||
|
next: function (result) {
|
||
|
if (_this.sub !== null) {
|
||
|
_this.latest = ["next", result];
|
||
|
_this.notify("next", result);
|
||
|
iterateObserversSafely(_this.observers, "next", result);
|
||
|
}
|
||
|
},
|
||
|
error: function (error) {
|
||
|
var sub = _this.sub;
|
||
|
if (sub !== null) {
|
||
|
if (sub)
|
||
|
setTimeout(function () { return sub.unsubscribe(); });
|
||
|
_this.sub = null;
|
||
|
_this.latest = ["error", error];
|
||
|
_this.reject(error);
|
||
|
_this.notify("error", error);
|
||
|
iterateObserversSafely(_this.observers, "error", error);
|
||
|
}
|
||
|
},
|
||
|
complete: function () {
|
||
|
var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;
|
||
|
if (sub !== null) {
|
||
|
var value = sources.shift();
|
||
|
if (!value) {
|
||
|
if (sub)
|
||
|
setTimeout(function () { return sub.unsubscribe(); });
|
||
|
_this.sub = null;
|
||
|
if (_this.latest && _this.latest[0] === "next") {
|
||
|
_this.resolve(_this.latest[1]);
|
||
|
}
|
||
|
else {
|
||
|
_this.resolve();
|
||
|
}
|
||
|
_this.notify("complete");
|
||
|
iterateObserversSafely(_this.observers, "complete");
|
||
|
}
|
||
|
else if (isPromiseLike(value)) {
|
||
|
value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); }, _this.handlers.error);
|
||
|
}
|
||
|
else {
|
||
|
_this.sub = value.subscribe(_this.handlers);
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
_this.nextResultListeners = new Set();
|
||
|
_this.cancel = function (reason) {
|
||
|
_this.reject(reason);
|
||
|
_this.sources = [];
|
||
|
_this.handlers.complete();
|
||
|
};
|
||
|
_this.promise.catch(function (_) { });
|
||
|
if (typeof sources === "function") {
|
||
|
sources = [new zenObservableTs.Observable(sources)];
|
||
|
}
|
||
|
if (isPromiseLike(sources)) {
|
||
|
sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);
|
||
|
}
|
||
|
else {
|
||
|
_this.start(sources);
|
||
|
}
|
||
|
return _this;
|
||
|
}
|
||
|
Concast.prototype.start = function (sources) {
|
||
|
if (this.sub !== void 0)
|
||
|
return;
|
||
|
this.sources = Array.from(sources);
|
||
|
this.handlers.complete();
|
||
|
};
|
||
|
Concast.prototype.deliverLastMessage = function (observer) {
|
||
|
if (this.latest) {
|
||
|
var nextOrError = this.latest[0];
|
||
|
var method = observer[nextOrError];
|
||
|
if (method) {
|
||
|
method.call(observer, this.latest[1]);
|
||
|
}
|
||
|
if (this.sub === null && nextOrError === "next" && observer.complete) {
|
||
|
observer.complete();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
Concast.prototype.addObserver = function (observer) {
|
||
|
if (!this.observers.has(observer)) {
|
||
|
this.deliverLastMessage(observer);
|
||
|
this.observers.add(observer);
|
||
|
}
|
||
|
};
|
||
|
Concast.prototype.removeObserver = function (observer) {
|
||
|
if (this.observers.delete(observer) && this.observers.size < 1) {
|
||
|
this.handlers.complete();
|
||
|
}
|
||
|
};
|
||
|
Concast.prototype.notify = function (method, arg) {
|
||
|
var nextResultListeners = this.nextResultListeners;
|
||
|
if (nextResultListeners.size) {
|
||
|
this.nextResultListeners = new Set();
|
||
|
nextResultListeners.forEach(function (listener) { return listener(method, arg); });
|
||
|
}
|
||
|
};
|
||
|
Concast.prototype.beforeNext = function (callback) {
|
||
|
var called = false;
|
||
|
this.nextResultListeners.add(function (method, arg) {
|
||
|
if (!called) {
|
||
|
called = true;
|
||
|
callback(method, arg);
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
return Concast;
|
||
|
}(zenObservableTs.Observable));
|
||
|
fixObservableSubclass(Concast);
|
||
|
|
||
|
function isExecutionPatchIncrementalResult(value) {
|
||
|
return "incremental" in value;
|
||
|
}
|
||
|
function isExecutionPatchInitialResult(value) {
|
||
|
return "hasNext" in value && "data" in value;
|
||
|
}
|
||
|
function isExecutionPatchResult(value) {
|
||
|
return (isExecutionPatchIncrementalResult(value) ||
|
||
|
isExecutionPatchInitialResult(value));
|
||
|
}
|
||
|
function isApolloPayloadResult(value) {
|
||
|
return isNonNullObject(value) && "payload" in value;
|
||
|
}
|
||
|
function mergeIncrementalData(prevResult, result) {
|
||
|
var mergedData = prevResult;
|
||
|
var merger = new DeepMerger();
|
||
|
if (isExecutionPatchIncrementalResult(result) &&
|
||
|
isNonEmptyArray(result.incremental)) {
|
||
|
result.incremental.forEach(function (_a) {
|
||
|
var data = _a.data, path = _a.path;
|
||
|
for (var i = path.length - 1; i >= 0; --i) {
|
||
|
var key = path[i];
|
||
|
var isNumericKey = !isNaN(+key);
|
||
|
var parent_1 = isNumericKey ? [] : {};
|
||
|
parent_1[key] = data;
|
||
|
data = parent_1;
|
||
|
}
|
||
|
mergedData = merger.merge(mergedData, data);
|
||
|
});
|
||
|
}
|
||
|
return mergedData;
|
||
|
}
|
||
|
|
||
|
function graphQLResultHasError(result) {
|
||
|
var errors = getGraphQLErrorsFromResult(result);
|
||
|
return isNonEmptyArray(errors);
|
||
|
}
|
||
|
function getGraphQLErrorsFromResult(result) {
|
||
|
var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
|
||
|
if (isExecutionPatchIncrementalResult(result) &&
|
||
|
isNonEmptyArray(result.incremental)) {
|
||
|
result.incremental.forEach(function (incrementalResult) {
|
||
|
if (incrementalResult.errors) {
|
||
|
graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return graphQLErrors;
|
||
|
}
|
||
|
|
||
|
function compact() {
|
||
|
var objects = [];
|
||
|
for (var _i = 0; _i < arguments.length; _i++) {
|
||
|
objects[_i] = arguments[_i];
|
||
|
}
|
||
|
var result = Object.create(null);
|
||
|
objects.forEach(function (obj) {
|
||
|
if (!obj)
|
||
|
return;
|
||
|
Object.keys(obj).forEach(function (key) {
|
||
|
var value = obj[key];
|
||
|
if (value !== void 0) {
|
||
|
result[key] = value;
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
function mergeOptions(defaults, options) {
|
||
|
return compact(defaults, options, options.variables && {
|
||
|
variables: compact(tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables)),
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function fromError(errorValue) {
|
||
|
return new zenObservableTs.Observable(function (observer) {
|
||
|
observer.error(errorValue);
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function toPromise(observable) {
|
||
|
var completed = false;
|
||
|
return new Promise(function (resolve, reject) {
|
||
|
observable.subscribe({
|
||
|
next: function (data) {
|
||
|
if (completed) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(42);
|
||
|
}
|
||
|
else {
|
||
|
completed = true;
|
||
|
resolve(data);
|
||
|
}
|
||
|
},
|
||
|
error: reject,
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function fromPromise(promise) {
|
||
|
return new zenObservableTs.Observable(function (observer) {
|
||
|
promise
|
||
|
.then(function (value) {
|
||
|
observer.next(value);
|
||
|
observer.complete();
|
||
|
})
|
||
|
.catch(observer.error.bind(observer));
|
||
|
});
|
||
|
}
|
||
|
|
||
|
var throwServerError = function (response, result, message) {
|
||
|
var error = new Error(message);
|
||
|
error.name = "ServerError";
|
||
|
error.response = response;
|
||
|
error.statusCode = response.status;
|
||
|
error.result = result;
|
||
|
throw error;
|
||
|
};
|
||
|
|
||
|
function validateOperation(operation) {
|
||
|
var OPERATION_FIELDS = [
|
||
|
"query",
|
||
|
"operationName",
|
||
|
"variables",
|
||
|
"extensions",
|
||
|
"context",
|
||
|
];
|
||
|
for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {
|
||
|
var key = _a[_i];
|
||
|
if (OPERATION_FIELDS.indexOf(key) < 0) {
|
||
|
throw newInvariantError(43, key);
|
||
|
}
|
||
|
}
|
||
|
return operation;
|
||
|
}
|
||
|
|
||
|
function createOperation(starting, operation) {
|
||
|
var context = tslib.__assign({}, starting);
|
||
|
var setContext = function (next) {
|
||
|
if (typeof next === "function") {
|
||
|
context = tslib.__assign(tslib.__assign({}, context), next(context));
|
||
|
}
|
||
|
else {
|
||
|
context = tslib.__assign(tslib.__assign({}, context), next);
|
||
|
}
|
||
|
};
|
||
|
var getContext = function () { return (tslib.__assign({}, context)); };
|
||
|
Object.defineProperty(operation, "setContext", {
|
||
|
enumerable: false,
|
||
|
value: setContext,
|
||
|
});
|
||
|
Object.defineProperty(operation, "getContext", {
|
||
|
enumerable: false,
|
||
|
value: getContext,
|
||
|
});
|
||
|
return operation;
|
||
|
}
|
||
|
|
||
|
function transformOperation(operation) {
|
||
|
var transformedOperation = {
|
||
|
variables: operation.variables || {},
|
||
|
extensions: operation.extensions || {},
|
||
|
operationName: operation.operationName,
|
||
|
query: operation.query,
|
||
|
};
|
||
|
if (!transformedOperation.operationName) {
|
||
|
transformedOperation.operationName =
|
||
|
typeof transformedOperation.query !== "string" ?
|
||
|
getOperationName(transformedOperation.query) || undefined
|
||
|
: "";
|
||
|
}
|
||
|
return transformedOperation;
|
||
|
}
|
||
|
|
||
|
function filterOperationVariables(variables, query) {
|
||
|
var result = tslib.__assign({}, variables);
|
||
|
var unusedNames = new Set(Object.keys(variables));
|
||
|
graphql.visit(query, {
|
||
|
Variable: function (node, _key, parent) {
|
||
|
if (parent &&
|
||
|
parent.kind !== "VariableDefinition") {
|
||
|
unusedNames.delete(node.name.value);
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
unusedNames.forEach(function (name) {
|
||
|
delete result[name];
|
||
|
});
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
function passthrough(op, forward) {
|
||
|
return (forward ? forward(op) : zenObservableTs.Observable.of());
|
||
|
}
|
||
|
function toLink(handler) {
|
||
|
return typeof handler === "function" ? new ApolloLink(handler) : handler;
|
||
|
}
|
||
|
function isTerminating(link) {
|
||
|
return link.request.length <= 1;
|
||
|
}
|
||
|
var ApolloLink = (function () {
|
||
|
function ApolloLink(request) {
|
||
|
if (request)
|
||
|
this.request = request;
|
||
|
}
|
||
|
ApolloLink.empty = function () {
|
||
|
return new ApolloLink(function () { return zenObservableTs.Observable.of(); });
|
||
|
};
|
||
|
ApolloLink.from = function (links) {
|
||
|
if (links.length === 0)
|
||
|
return ApolloLink.empty();
|
||
|
return links.map(toLink).reduce(function (x, y) { return x.concat(y); });
|
||
|
};
|
||
|
ApolloLink.split = function (test, left, right) {
|
||
|
var leftLink = toLink(left);
|
||
|
var rightLink = toLink(right || new ApolloLink(passthrough));
|
||
|
var ret;
|
||
|
if (isTerminating(leftLink) && isTerminating(rightLink)) {
|
||
|
ret = new ApolloLink(function (operation) {
|
||
|
return test(operation) ?
|
||
|
leftLink.request(operation) || zenObservableTs.Observable.of()
|
||
|
: rightLink.request(operation) || zenObservableTs.Observable.of();
|
||
|
});
|
||
|
}
|
||
|
else {
|
||
|
ret = new ApolloLink(function (operation, forward) {
|
||
|
return test(operation) ?
|
||
|
leftLink.request(operation, forward) || zenObservableTs.Observable.of()
|
||
|
: rightLink.request(operation, forward) || zenObservableTs.Observable.of();
|
||
|
});
|
||
|
}
|
||
|
return Object.assign(ret, { left: leftLink, right: rightLink });
|
||
|
};
|
||
|
ApolloLink.execute = function (link, operation) {
|
||
|
return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || zenObservableTs.Observable.of());
|
||
|
};
|
||
|
ApolloLink.concat = function (first, second) {
|
||
|
var firstLink = toLink(first);
|
||
|
if (isTerminating(firstLink)) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(35, firstLink);
|
||
|
return firstLink;
|
||
|
}
|
||
|
var nextLink = toLink(second);
|
||
|
var ret;
|
||
|
if (isTerminating(nextLink)) {
|
||
|
ret = new ApolloLink(function (operation) {
|
||
|
return firstLink.request(operation, function (op) { return nextLink.request(op) || zenObservableTs.Observable.of(); }) || zenObservableTs.Observable.of();
|
||
|
});
|
||
|
}
|
||
|
else {
|
||
|
ret = new ApolloLink(function (operation, forward) {
|
||
|
return (firstLink.request(operation, function (op) {
|
||
|
return nextLink.request(op, forward) || zenObservableTs.Observable.of();
|
||
|
}) || zenObservableTs.Observable.of());
|
||
|
});
|
||
|
}
|
||
|
return Object.assign(ret, { left: firstLink, right: nextLink });
|
||
|
};
|
||
|
ApolloLink.prototype.split = function (test, left, right) {
|
||
|
return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));
|
||
|
};
|
||
|
ApolloLink.prototype.concat = function (next) {
|
||
|
return ApolloLink.concat(this, next);
|
||
|
};
|
||
|
ApolloLink.prototype.request = function (operation, forward) {
|
||
|
throw newInvariantError(36);
|
||
|
};
|
||
|
ApolloLink.prototype.onError = function (error, observer) {
|
||
|
if (observer && observer.error) {
|
||
|
observer.error(error);
|
||
|
return false;
|
||
|
}
|
||
|
throw error;
|
||
|
};
|
||
|
ApolloLink.prototype.setOnError = function (fn) {
|
||
|
this.onError = fn;
|
||
|
return this;
|
||
|
};
|
||
|
return ApolloLink;
|
||
|
}());
|
||
|
|
||
|
var empty = ApolloLink.empty;
|
||
|
|
||
|
var from = ApolloLink.from;
|
||
|
|
||
|
var split = ApolloLink.split;
|
||
|
|
||
|
var concat = ApolloLink.concat;
|
||
|
|
||
|
var execute = ApolloLink.execute;
|
||
|
|
||
|
function asyncIterator(source) {
|
||
|
var _a;
|
||
|
var iterator = source[Symbol.asyncIterator]();
|
||
|
return _a = {
|
||
|
next: function () {
|
||
|
return iterator.next();
|
||
|
}
|
||
|
},
|
||
|
_a[Symbol.asyncIterator] = function () {
|
||
|
return this;
|
||
|
},
|
||
|
_a;
|
||
|
}
|
||
|
|
||
|
function nodeStreamIterator(stream) {
|
||
|
var cleanup = null;
|
||
|
var error = null;
|
||
|
var done = false;
|
||
|
var data = [];
|
||
|
var waiting = [];
|
||
|
function onData(chunk) {
|
||
|
if (error)
|
||
|
return;
|
||
|
if (waiting.length) {
|
||
|
var shiftedArr = waiting.shift();
|
||
|
if (Array.isArray(shiftedArr) && shiftedArr[0]) {
|
||
|
return shiftedArr[0]({ value: chunk, done: false });
|
||
|
}
|
||
|
}
|
||
|
data.push(chunk);
|
||
|
}
|
||
|
function onError(err) {
|
||
|
error = err;
|
||
|
var all = waiting.slice();
|
||
|
all.forEach(function (pair) {
|
||
|
pair[1](err);
|
||
|
});
|
||
|
!cleanup || cleanup();
|
||
|
}
|
||
|
function onEnd() {
|
||
|
done = true;
|
||
|
var all = waiting.slice();
|
||
|
all.forEach(function (pair) {
|
||
|
pair[0]({ value: undefined, done: true });
|
||
|
});
|
||
|
!cleanup || cleanup();
|
||
|
}
|
||
|
cleanup = function () {
|
||
|
cleanup = null;
|
||
|
stream.removeListener("data", onData);
|
||
|
stream.removeListener("error", onError);
|
||
|
stream.removeListener("end", onEnd);
|
||
|
stream.removeListener("finish", onEnd);
|
||
|
stream.removeListener("close", onEnd);
|
||
|
};
|
||
|
stream.on("data", onData);
|
||
|
stream.on("error", onError);
|
||
|
stream.on("end", onEnd);
|
||
|
stream.on("finish", onEnd);
|
||
|
stream.on("close", onEnd);
|
||
|
function getNext() {
|
||
|
return new Promise(function (resolve, reject) {
|
||
|
if (error)
|
||
|
return reject(error);
|
||
|
if (data.length)
|
||
|
return resolve({ value: data.shift(), done: false });
|
||
|
if (done)
|
||
|
return resolve({ value: undefined, done: true });
|
||
|
waiting.push([resolve, reject]);
|
||
|
});
|
||
|
}
|
||
|
var iterator = {
|
||
|
next: function () {
|
||
|
return getNext();
|
||
|
},
|
||
|
};
|
||
|
if (canUseAsyncIteratorSymbol) {
|
||
|
iterator[Symbol.asyncIterator] = function () {
|
||
|
return this;
|
||
|
};
|
||
|
}
|
||
|
return iterator;
|
||
|
}
|
||
|
|
||
|
function promiseIterator(promise) {
|
||
|
var resolved = false;
|
||
|
var iterator = {
|
||
|
next: function () {
|
||
|
if (resolved)
|
||
|
return Promise.resolve({
|
||
|
value: undefined,
|
||
|
done: true,
|
||
|
});
|
||
|
resolved = true;
|
||
|
return new Promise(function (resolve, reject) {
|
||
|
promise
|
||
|
.then(function (value) {
|
||
|
resolve({ value: value, done: false });
|
||
|
})
|
||
|
.catch(reject);
|
||
|
});
|
||
|
},
|
||
|
};
|
||
|
if (canUseAsyncIteratorSymbol) {
|
||
|
iterator[Symbol.asyncIterator] = function () {
|
||
|
return this;
|
||
|
};
|
||
|
}
|
||
|
return iterator;
|
||
|
}
|
||
|
|
||
|
function readerIterator(reader) {
|
||
|
var iterator = {
|
||
|
next: function () {
|
||
|
return reader.read();
|
||
|
},
|
||
|
};
|
||
|
if (canUseAsyncIteratorSymbol) {
|
||
|
iterator[Symbol.asyncIterator] = function () {
|
||
|
return this;
|
||
|
};
|
||
|
}
|
||
|
return iterator;
|
||
|
}
|
||
|
|
||
|
function isNodeResponse(value) {
|
||
|
return !!value.body;
|
||
|
}
|
||
|
function isReadableStream(value) {
|
||
|
return !!value.getReader;
|
||
|
}
|
||
|
function isAsyncIterableIterator(value) {
|
||
|
return !!(canUseAsyncIteratorSymbol &&
|
||
|
value[Symbol.asyncIterator]);
|
||
|
}
|
||
|
function isStreamableBlob(value) {
|
||
|
return !!value.stream;
|
||
|
}
|
||
|
function isBlob(value) {
|
||
|
return !!value.arrayBuffer;
|
||
|
}
|
||
|
function isNodeReadableStream(value) {
|
||
|
return !!value.pipe;
|
||
|
}
|
||
|
function responseIterator(response) {
|
||
|
var body = response;
|
||
|
if (isNodeResponse(response))
|
||
|
body = response.body;
|
||
|
if (isAsyncIterableIterator(body))
|
||
|
return asyncIterator(body);
|
||
|
if (isReadableStream(body))
|
||
|
return readerIterator(body.getReader());
|
||
|
if (isStreamableBlob(body)) {
|
||
|
return readerIterator(body.stream().getReader());
|
||
|
}
|
||
|
if (isBlob(body))
|
||
|
return promiseIterator(body.arrayBuffer());
|
||
|
if (isNodeReadableStream(body))
|
||
|
return nodeStreamIterator(body);
|
||
|
throw new Error("Unknown body type for responseIterator. Please pass a streamable response.");
|
||
|
}
|
||
|
|
||
|
var PROTOCOL_ERRORS_SYMBOL = Symbol();
|
||
|
function graphQLResultHasProtocolErrors(result) {
|
||
|
if (result.extensions) {
|
||
|
return Array.isArray(result.extensions[PROTOCOL_ERRORS_SYMBOL]);
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
function isApolloError(err) {
|
||
|
return err.hasOwnProperty("graphQLErrors");
|
||
|
}
|
||
|
var generateErrorMessage = function (err) {
|
||
|
var errors = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], err.graphQLErrors, true), err.clientErrors, true), err.protocolErrors, true);
|
||
|
if (err.networkError)
|
||
|
errors.push(err.networkError);
|
||
|
return (errors
|
||
|
.map(function (err) {
|
||
|
return (isNonNullObject(err) && err.message) || "Error message not found.";
|
||
|
})
|
||
|
.join("\n"));
|
||
|
};
|
||
|
var ApolloError = (function (_super) {
|
||
|
tslib.__extends(ApolloError, _super);
|
||
|
function ApolloError(_a) {
|
||
|
var graphQLErrors = _a.graphQLErrors, protocolErrors = _a.protocolErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
|
||
|
var _this = _super.call(this, errorMessage) || this;
|
||
|
_this.name = "ApolloError";
|
||
|
_this.graphQLErrors = graphQLErrors || [];
|
||
|
_this.protocolErrors = protocolErrors || [];
|
||
|
_this.clientErrors = clientErrors || [];
|
||
|
_this.networkError = networkError || null;
|
||
|
_this.message = errorMessage || generateErrorMessage(_this);
|
||
|
_this.extraInfo = extraInfo;
|
||
|
_this.__proto__ = ApolloError.prototype;
|
||
|
return _this;
|
||
|
}
|
||
|
return ApolloError;
|
||
|
}(Error));
|
||
|
|
||
|
var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
|
||
|
function readMultipartBody(response, nextValue) {
|
||
|
var _a;
|
||
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
||
|
var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _b, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;
|
||
|
var _c, _d;
|
||
|
return tslib.__generator(this, function (_e) {
|
||
|
switch (_e.label) {
|
||
|
case 0:
|
||
|
if (TextDecoder === undefined) {
|
||
|
throw new Error("TextDecoder must be defined in the environment: please import a polyfill.");
|
||
|
}
|
||
|
decoder = new TextDecoder("utf-8");
|
||
|
contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
|
||
|
delimiter = "boundary=";
|
||
|
boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter)) ?
|
||
|
contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['"]/g, "").replace(/\;(.*)/gm, "").trim()
|
||
|
: "-";
|
||
|
boundary = "\r\n--".concat(boundaryVal);
|
||
|
buffer = "";
|
||
|
iterator = responseIterator(response);
|
||
|
running = true;
|
||
|
_e.label = 1;
|
||
|
case 1:
|
||
|
if (!running) return [3 , 3];
|
||
|
return [4 , iterator.next()];
|
||
|
case 2:
|
||
|
_b = _e.sent(), value = _b.value, done = _b.done;
|
||
|
chunk = typeof value === "string" ? value : decoder.decode(value);
|
||
|
searchFrom = buffer.length - boundary.length + 1;
|
||
|
running = !done;
|
||
|
buffer += chunk;
|
||
|
bi = buffer.indexOf(boundary, searchFrom);
|
||
|
while (bi > -1) {
|
||
|
message = void 0;
|
||
|
_c = [
|
||
|
buffer.slice(0, bi),
|
||
|
buffer.slice(bi + boundary.length),
|
||
|
], message = _c[0], buffer = _c[1];
|
||
|
i = message.indexOf("\r\n\r\n");
|
||
|
headers = parseHeaders(message.slice(0, i));
|
||
|
contentType_1 = headers["content-type"];
|
||
|
if (contentType_1 &&
|
||
|
contentType_1.toLowerCase().indexOf("application/json") === -1) {
|
||
|
throw new Error("Unsupported patch content type: application/json is required.");
|
||
|
}
|
||
|
body = message.slice(i);
|
||
|
if (body) {
|
||
|
result = parseJsonBody(response, body);
|
||
|
if (Object.keys(result).length > 1 ||
|
||
|
"data" in result ||
|
||
|
"incremental" in result ||
|
||
|
"errors" in result ||
|
||
|
"payload" in result) {
|
||
|
if (isApolloPayloadResult(result)) {
|
||
|
next = {};
|
||
|
if ("payload" in result) {
|
||
|
next = tslib.__assign({}, result.payload);
|
||
|
}
|
||
|
if ("errors" in result) {
|
||
|
next = tslib.__assign(tslib.__assign({}, next), { extensions: tslib.__assign(tslib.__assign({}, ("extensions" in next ? next.extensions : null)), (_d = {}, _d[PROTOCOL_ERRORS_SYMBOL] = result.errors, _d)) });
|
||
|
}
|
||
|
nextValue(next);
|
||
|
}
|
||
|
else {
|
||
|
nextValue(result);
|
||
|
}
|
||
|
}
|
||
|
else if (
|
||
|
Object.keys(result).length === 1 &&
|
||
|
"hasNext" in result &&
|
||
|
!result.hasNext) {
|
||
|
return [2 ];
|
||
|
}
|
||
|
}
|
||
|
bi = buffer.indexOf(boundary);
|
||
|
}
|
||
|
return [3 , 1];
|
||
|
case 3: return [2 ];
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
function parseHeaders(headerText) {
|
||
|
var headersInit = {};
|
||
|
headerText.split("\n").forEach(function (line) {
|
||
|
var i = line.indexOf(":");
|
||
|
if (i > -1) {
|
||
|
var name_1 = line.slice(0, i).trim().toLowerCase();
|
||
|
var value = line.slice(i + 1).trim();
|
||
|
headersInit[name_1] = value;
|
||
|
}
|
||
|
});
|
||
|
return headersInit;
|
||
|
}
|
||
|
function parseJsonBody(response, bodyText) {
|
||
|
if (response.status >= 300) {
|
||
|
var getResult = function () {
|
||
|
try {
|
||
|
return JSON.parse(bodyText);
|
||
|
}
|
||
|
catch (err) {
|
||
|
return bodyText;
|
||
|
}
|
||
|
};
|
||
|
throwServerError(response, getResult(), "Response not successful: Received status code ".concat(response.status));
|
||
|
}
|
||
|
try {
|
||
|
return JSON.parse(bodyText);
|
||
|
}
|
||
|
catch (err) {
|
||
|
var parseError = err;
|
||
|
parseError.name = "ServerParseError";
|
||
|
parseError.response = response;
|
||
|
parseError.statusCode = response.status;
|
||
|
parseError.bodyText = bodyText;
|
||
|
throw parseError;
|
||
|
}
|
||
|
}
|
||
|
function handleError(err, observer) {
|
||
|
if (err.result && err.result.errors && err.result.data) {
|
||
|
observer.next(err.result);
|
||
|
}
|
||
|
observer.error(err);
|
||
|
}
|
||
|
function parseAndCheckHttpResponse(operations) {
|
||
|
return function (response) {
|
||
|
return response
|
||
|
.text()
|
||
|
.then(function (bodyText) { return parseJsonBody(response, bodyText); })
|
||
|
.then(function (result) {
|
||
|
if (!Array.isArray(result) &&
|
||
|
!hasOwnProperty$3.call(result, "data") &&
|
||
|
!hasOwnProperty$3.call(result, "errors")) {
|
||
|
throwServerError(response, result, "Server response was missing for query '".concat(Array.isArray(operations) ?
|
||
|
operations.map(function (op) { return op.operationName; })
|
||
|
: operations.operationName, "'."));
|
||
|
}
|
||
|
return result;
|
||
|
});
|
||
|
};
|
||
|
}
|
||
|
|
||
|
var serializeFetchParameter = function (p, label) {
|
||
|
var serialized;
|
||
|
try {
|
||
|
serialized = JSON.stringify(p);
|
||
|
}
|
||
|
catch (e) {
|
||
|
var parseError = newInvariantError(39, label, e.message);
|
||
|
parseError.parseError = e;
|
||
|
throw parseError;
|
||
|
}
|
||
|
return serialized;
|
||
|
};
|
||
|
|
||
|
var defaultHttpOptions = {
|
||
|
includeQuery: true,
|
||
|
includeExtensions: false,
|
||
|
preserveHeaderCase: false,
|
||
|
};
|
||
|
var defaultHeaders = {
|
||
|
accept: "*/*",
|
||
|
"content-type": "application/json",
|
||
|
};
|
||
|
var defaultOptions = {
|
||
|
method: "POST",
|
||
|
};
|
||
|
var fallbackHttpConfig = {
|
||
|
http: defaultHttpOptions,
|
||
|
headers: defaultHeaders,
|
||
|
options: defaultOptions,
|
||
|
};
|
||
|
var defaultPrinter = function (ast, printer) { return printer(ast); };
|
||
|
function selectHttpOptionsAndBody(operation, fallbackConfig) {
|
||
|
var configs = [];
|
||
|
for (var _i = 2; _i < arguments.length; _i++) {
|
||
|
configs[_i - 2] = arguments[_i];
|
||
|
}
|
||
|
configs.unshift(fallbackConfig);
|
||
|
return selectHttpOptionsAndBodyInternal.apply(void 0, tslib.__spreadArray([operation,
|
||
|
defaultPrinter], configs, false));
|
||
|
}
|
||
|
function selectHttpOptionsAndBodyInternal(operation, printer) {
|
||
|
var configs = [];
|
||
|
for (var _i = 2; _i < arguments.length; _i++) {
|
||
|
configs[_i - 2] = arguments[_i];
|
||
|
}
|
||
|
var options = {};
|
||
|
var http = {};
|
||
|
configs.forEach(function (config) {
|
||
|
options = tslib.__assign(tslib.__assign(tslib.__assign({}, options), config.options), { headers: tslib.__assign(tslib.__assign({}, options.headers), config.headers) });
|
||
|
if (config.credentials) {
|
||
|
options.credentials = config.credentials;
|
||
|
}
|
||
|
http = tslib.__assign(tslib.__assign({}, http), config.http);
|
||
|
});
|
||
|
if (options.headers) {
|
||
|
options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
|
||
|
}
|
||
|
var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
|
||
|
var body = { operationName: operationName, variables: variables };
|
||
|
if (http.includeExtensions)
|
||
|
body.extensions = extensions;
|
||
|
if (http.includeQuery)
|
||
|
body.query = printer(query, print);
|
||
|
return {
|
||
|
options: options,
|
||
|
body: body,
|
||
|
};
|
||
|
}
|
||
|
function removeDuplicateHeaders(headers, preserveHeaderCase) {
|
||
|
if (!preserveHeaderCase) {
|
||
|
var normalizedHeaders_1 = Object.create(null);
|
||
|
Object.keys(Object(headers)).forEach(function (name) {
|
||
|
normalizedHeaders_1[name.toLowerCase()] = headers[name];
|
||
|
});
|
||
|
return normalizedHeaders_1;
|
||
|
}
|
||
|
var headerData = Object.create(null);
|
||
|
Object.keys(Object(headers)).forEach(function (name) {
|
||
|
headerData[name.toLowerCase()] = {
|
||
|
originalName: name,
|
||
|
value: headers[name],
|
||
|
};
|
||
|
});
|
||
|
var normalizedHeaders = Object.create(null);
|
||
|
Object.keys(headerData).forEach(function (name) {
|
||
|
normalizedHeaders[headerData[name].originalName] = headerData[name].value;
|
||
|
});
|
||
|
return normalizedHeaders;
|
||
|
}
|
||
|
|
||
|
var checkFetcher = function (fetcher) {
|
||
|
if (!fetcher && typeof fetch === "undefined") {
|
||
|
throw newInvariantError(37);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
var createSignalIfSupported = function () {
|
||
|
if (typeof AbortController === "undefined")
|
||
|
return { controller: false, signal: false };
|
||
|
var controller = new AbortController();
|
||
|
var signal = controller.signal;
|
||
|
return { controller: controller, signal: signal };
|
||
|
};
|
||
|
|
||
|
var selectURI = function (operation, fallbackURI) {
|
||
|
var context = operation.getContext();
|
||
|
var contextURI = context.uri;
|
||
|
if (contextURI) {
|
||
|
return contextURI;
|
||
|
}
|
||
|
else if (typeof fallbackURI === "function") {
|
||
|
return fallbackURI(operation);
|
||
|
}
|
||
|
else {
|
||
|
return fallbackURI || "/graphql";
|
||
|
}
|
||
|
};
|
||
|
|
||
|
function rewriteURIForGET(chosenURI, body) {
|
||
|
var queryParams = [];
|
||
|
var addQueryParam = function (key, value) {
|
||
|
queryParams.push("".concat(key, "=").concat(encodeURIComponent(value)));
|
||
|
};
|
||
|
if ("query" in body) {
|
||
|
addQueryParam("query", body.query);
|
||
|
}
|
||
|
if (body.operationName) {
|
||
|
addQueryParam("operationName", body.operationName);
|
||
|
}
|
||
|
if (body.variables) {
|
||
|
var serializedVariables = void 0;
|
||
|
try {
|
||
|
serializedVariables = serializeFetchParameter(body.variables, "Variables map");
|
||
|
}
|
||
|
catch (parseError) {
|
||
|
return { parseError: parseError };
|
||
|
}
|
||
|
addQueryParam("variables", serializedVariables);
|
||
|
}
|
||
|
if (body.extensions) {
|
||
|
var serializedExtensions = void 0;
|
||
|
try {
|
||
|
serializedExtensions = serializeFetchParameter(body.extensions, "Extensions map");
|
||
|
}
|
||
|
catch (parseError) {
|
||
|
return { parseError: parseError };
|
||
|
}
|
||
|
addQueryParam("extensions", serializedExtensions);
|
||
|
}
|
||
|
var fragment = "", preFragment = chosenURI;
|
||
|
var fragmentStart = chosenURI.indexOf("#");
|
||
|
if (fragmentStart !== -1) {
|
||
|
fragment = chosenURI.substr(fragmentStart);
|
||
|
preFragment = chosenURI.substr(0, fragmentStart);
|
||
|
}
|
||
|
var queryParamsPrefix = preFragment.indexOf("?") === -1 ? "?" : "&";
|
||
|
var newURI = preFragment + queryParamsPrefix + queryParams.join("&") + fragment;
|
||
|
return { newURI: newURI };
|
||
|
}
|
||
|
|
||
|
var backupFetch = maybe(function () { return fetch; });
|
||
|
var createHttpLink = function (linkOptions) {
|
||
|
if (linkOptions === void 0) { linkOptions = {}; }
|
||
|
var _a = linkOptions.uri, uri = _a === void 0 ? "/graphql" : _a,
|
||
|
preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "print", "includeExtensions", "preserveHeaderCase", "useGETForQueries", "includeUnusedVariables"]);
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
checkFetcher(preferredFetch || backupFetch);
|
||
|
}
|
||
|
var linkConfig = {
|
||
|
http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },
|
||
|
options: requestOptions.fetchOptions,
|
||
|
credentials: requestOptions.credentials,
|
||
|
headers: requestOptions.headers,
|
||
|
};
|
||
|
return new ApolloLink(function (operation) {
|
||
|
var chosenURI = selectURI(operation, uri);
|
||
|
var context = operation.getContext();
|
||
|
var clientAwarenessHeaders = {};
|
||
|
if (context.clientAwareness) {
|
||
|
var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;
|
||
|
if (name_1) {
|
||
|
clientAwarenessHeaders["apollographql-client-name"] = name_1;
|
||
|
}
|
||
|
if (version) {
|
||
|
clientAwarenessHeaders["apollographql-client-version"] = version;
|
||
|
}
|
||
|
}
|
||
|
var contextHeaders = tslib.__assign(tslib.__assign({}, clientAwarenessHeaders), context.headers);
|
||
|
var contextConfig = {
|
||
|
http: context.http,
|
||
|
options: context.fetchOptions,
|
||
|
credentials: context.credentials,
|
||
|
headers: contextHeaders,
|
||
|
};
|
||
|
if (hasDirectives(["client"], operation.query)) {
|
||
|
var transformedQuery = removeClientSetsFromDocument(operation.query);
|
||
|
if (!transformedQuery) {
|
||
|
return fromError(new Error("HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`."));
|
||
|
}
|
||
|
operation.query = transformedQuery;
|
||
|
}
|
||
|
var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;
|
||
|
if (body.variables && !includeUnusedVariables) {
|
||
|
body.variables = filterOperationVariables(body.variables, operation.query);
|
||
|
}
|
||
|
var controller;
|
||
|
if (!options.signal && typeof AbortController !== "undefined") {
|
||
|
controller = new AbortController();
|
||
|
options.signal = controller.signal;
|
||
|
}
|
||
|
var definitionIsMutation = function (d) {
|
||
|
return d.kind === "OperationDefinition" && d.operation === "mutation";
|
||
|
};
|
||
|
var definitionIsSubscription = function (d) {
|
||
|
return d.kind === "OperationDefinition" && d.operation === "subscription";
|
||
|
};
|
||
|
var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));
|
||
|
var hasDefer = hasDirectives(["defer"], operation.query);
|
||
|
if (useGETForQueries &&
|
||
|
!operation.query.definitions.some(definitionIsMutation)) {
|
||
|
options.method = "GET";
|
||
|
}
|
||
|
if (hasDefer || isSubscription) {
|
||
|
options.headers = options.headers || {};
|
||
|
var acceptHeader = "multipart/mixed;";
|
||
|
if (isSubscription && hasDefer) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(38);
|
||
|
}
|
||
|
if (isSubscription) {
|
||
|
acceptHeader +=
|
||
|
"boundary=graphql;subscriptionSpec=1.0,application/json";
|
||
|
}
|
||
|
else if (hasDefer) {
|
||
|
acceptHeader += "deferSpec=20220824,application/json";
|
||
|
}
|
||
|
options.headers.accept = acceptHeader;
|
||
|
}
|
||
|
if (options.method === "GET") {
|
||
|
var _c = rewriteURIForGET(chosenURI, body), newURI = _c.newURI, parseError = _c.parseError;
|
||
|
if (parseError) {
|
||
|
return fromError(parseError);
|
||
|
}
|
||
|
chosenURI = newURI;
|
||
|
}
|
||
|
else {
|
||
|
try {
|
||
|
options.body = serializeFetchParameter(body, "Payload");
|
||
|
}
|
||
|
catch (parseError) {
|
||
|
return fromError(parseError);
|
||
|
}
|
||
|
}
|
||
|
return new zenObservableTs.Observable(function (observer) {
|
||
|
var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;
|
||
|
var observerNext = observer.next.bind(observer);
|
||
|
currentFetch(chosenURI, options)
|
||
|
.then(function (response) {
|
||
|
var _a;
|
||
|
operation.setContext({ response: response });
|
||
|
var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
|
||
|
if (ctype !== null && /^multipart\/mixed/i.test(ctype)) {
|
||
|
return readMultipartBody(response, observerNext);
|
||
|
}
|
||
|
else {
|
||
|
return parseAndCheckHttpResponse(operation)(response).then(observerNext);
|
||
|
}
|
||
|
})
|
||
|
.then(function () {
|
||
|
controller = undefined;
|
||
|
observer.complete();
|
||
|
})
|
||
|
.catch(function (err) {
|
||
|
controller = undefined;
|
||
|
handleError(err, observer);
|
||
|
});
|
||
|
return function () {
|
||
|
if (controller)
|
||
|
controller.abort();
|
||
|
};
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
var HttpLink = (function (_super) {
|
||
|
tslib.__extends(HttpLink, _super);
|
||
|
function HttpLink(options) {
|
||
|
if (options === void 0) { options = {}; }
|
||
|
var _this = _super.call(this, createHttpLink(options).request) || this;
|
||
|
_this.options = options;
|
||
|
return _this;
|
||
|
}
|
||
|
return HttpLink;
|
||
|
}(ApolloLink));
|
||
|
|
||
|
var ApolloCache = (function () {
|
||
|
function ApolloCache() {
|
||
|
this.assumeImmutableResults = false;
|
||
|
this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument, {
|
||
|
max: cacheSizes["cache.fragmentQueryDocuments"] ||
|
||
|
1000 ,
|
||
|
cache: caches.WeakCache,
|
||
|
});
|
||
|
}
|
||
|
ApolloCache.prototype.batch = function (options) {
|
||
|
var _this = this;
|
||
|
var optimisticId = typeof options.optimistic === "string" ? options.optimistic
|
||
|
: options.optimistic === false ? null
|
||
|
: void 0;
|
||
|
var updateResult;
|
||
|
this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);
|
||
|
return updateResult;
|
||
|
};
|
||
|
ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
|
||
|
this.performTransaction(transaction, optimisticId);
|
||
|
};
|
||
|
ApolloCache.prototype.transformDocument = function (document) {
|
||
|
return document;
|
||
|
};
|
||
|
ApolloCache.prototype.transformForLink = function (document) {
|
||
|
return document;
|
||
|
};
|
||
|
ApolloCache.prototype.identify = function (object) {
|
||
|
return;
|
||
|
};
|
||
|
ApolloCache.prototype.gc = function () {
|
||
|
return [];
|
||
|
};
|
||
|
ApolloCache.prototype.modify = function (options) {
|
||
|
return false;
|
||
|
};
|
||
|
ApolloCache.prototype.readQuery = function (options, optimistic) {
|
||
|
if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
||
|
return this.read(tslib.__assign(tslib.__assign({}, options), { rootId: options.id || "ROOT_QUERY", optimistic: optimistic }));
|
||
|
};
|
||
|
ApolloCache.prototype.readFragment = function (options, optimistic) {
|
||
|
if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
||
|
return this.read(tslib.__assign(tslib.__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));
|
||
|
};
|
||
|
ApolloCache.prototype.writeQuery = function (_a) {
|
||
|
var id = _a.id, data = _a.data, options = tslib.__rest(_a, ["id", "data"]);
|
||
|
return this.write(Object.assign(options, {
|
||
|
dataId: id || "ROOT_QUERY",
|
||
|
result: data,
|
||
|
}));
|
||
|
};
|
||
|
ApolloCache.prototype.writeFragment = function (_a) {
|
||
|
var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = tslib.__rest(_a, ["id", "data", "fragment", "fragmentName"]);
|
||
|
return this.write(Object.assign(options, {
|
||
|
query: this.getFragmentDoc(fragment, fragmentName),
|
||
|
dataId: id,
|
||
|
result: data,
|
||
|
}));
|
||
|
};
|
||
|
ApolloCache.prototype.updateQuery = function (options, update) {
|
||
|
return this.batch({
|
||
|
update: function (cache) {
|
||
|
var value = cache.readQuery(options);
|
||
|
var data = update(value);
|
||
|
if (data === void 0 || data === null)
|
||
|
return value;
|
||
|
cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));
|
||
|
return data;
|
||
|
},
|
||
|
});
|
||
|
};
|
||
|
ApolloCache.prototype.updateFragment = function (options, update) {
|
||
|
return this.batch({
|
||
|
update: function (cache) {
|
||
|
var value = cache.readFragment(options);
|
||
|
var data = update(value);
|
||
|
if (data === void 0 || data === null)
|
||
|
return value;
|
||
|
cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));
|
||
|
return data;
|
||
|
},
|
||
|
});
|
||
|
};
|
||
|
return ApolloCache;
|
||
|
}());
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;
|
||
|
}
|
||
|
|
||
|
exports.Cache = void 0;
|
||
|
(function (Cache) {
|
||
|
})(exports.Cache || (exports.Cache = {}));
|
||
|
|
||
|
var MissingFieldError = (function (_super) {
|
||
|
tslib.__extends(MissingFieldError, _super);
|
||
|
function MissingFieldError(message, path, query, variables) {
|
||
|
var _a;
|
||
|
var _this = _super.call(this, message) || this;
|
||
|
_this.message = message;
|
||
|
_this.path = path;
|
||
|
_this.query = query;
|
||
|
_this.variables = variables;
|
||
|
if (Array.isArray(_this.path)) {
|
||
|
_this.missing = _this.message;
|
||
|
for (var i = _this.path.length - 1; i >= 0; --i) {
|
||
|
_this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
_this.missing = _this.path;
|
||
|
}
|
||
|
_this.__proto__ = MissingFieldError.prototype;
|
||
|
return _this;
|
||
|
}
|
||
|
return MissingFieldError;
|
||
|
}(Error));
|
||
|
|
||
|
var hasOwn = Object.prototype.hasOwnProperty;
|
||
|
function isNullish(value) {
|
||
|
return value === null || value === void 0;
|
||
|
}
|
||
|
function defaultDataIdFromObject(_a, context) {
|
||
|
var __typename = _a.__typename, id = _a.id, _id = _a._id;
|
||
|
if (typeof __typename === "string") {
|
||
|
if (context) {
|
||
|
context.keyObject =
|
||
|
!isNullish(id) ? { id: id }
|
||
|
: !isNullish(_id) ? { _id: _id }
|
||
|
: void 0;
|
||
|
}
|
||
|
if (isNullish(id) && !isNullish(_id)) {
|
||
|
id = _id;
|
||
|
}
|
||
|
if (!isNullish(id)) {
|
||
|
return "".concat(__typename, ":").concat(typeof id === "number" || typeof id === "string" ?
|
||
|
id
|
||
|
: JSON.stringify(id));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
var defaultConfig = {
|
||
|
dataIdFromObject: defaultDataIdFromObject,
|
||
|
addTypename: true,
|
||
|
resultCaching: true,
|
||
|
canonizeResults: false,
|
||
|
};
|
||
|
function normalizeConfig(config) {
|
||
|
return compact(defaultConfig, config);
|
||
|
}
|
||
|
function shouldCanonizeResults(config) {
|
||
|
var value = config.canonizeResults;
|
||
|
return value === void 0 ? defaultConfig.canonizeResults : value;
|
||
|
}
|
||
|
function getTypenameFromStoreObject(store, objectOrReference) {
|
||
|
return isReference(objectOrReference) ?
|
||
|
store.get(objectOrReference.__ref, "__typename")
|
||
|
: objectOrReference && objectOrReference.__typename;
|
||
|
}
|
||
|
var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
|
||
|
function fieldNameFromStoreName(storeFieldName) {
|
||
|
var match = storeFieldName.match(TypeOrFieldNameRegExp);
|
||
|
return match ? match[0] : storeFieldName;
|
||
|
}
|
||
|
function selectionSetMatchesResult(selectionSet, result, variables) {
|
||
|
if (isNonNullObject(result)) {
|
||
|
return isArray(result) ?
|
||
|
result.every(function (item) {
|
||
|
return selectionSetMatchesResult(selectionSet, item, variables);
|
||
|
})
|
||
|
: selectionSet.selections.every(function (field) {
|
||
|
if (isField(field) && shouldInclude(field, variables)) {
|
||
|
var key = resultKeyNameFromField(field);
|
||
|
return (hasOwn.call(result, key) &&
|
||
|
(!field.selectionSet ||
|
||
|
selectionSetMatchesResult(field.selectionSet, result[key], variables)));
|
||
|
}
|
||
|
return true;
|
||
|
});
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
function storeValueIsStoreObject(value) {
|
||
|
return isNonNullObject(value) && !isReference(value) && !isArray(value);
|
||
|
}
|
||
|
function makeProcessedFieldsMerger() {
|
||
|
return new DeepMerger();
|
||
|
}
|
||
|
function extractFragmentContext(document, fragments) {
|
||
|
var fragmentMap = createFragmentMap(getFragmentDefinitions(document));
|
||
|
return {
|
||
|
fragmentMap: fragmentMap,
|
||
|
lookupFragment: function (name) {
|
||
|
var def = fragmentMap[name];
|
||
|
if (!def && fragments) {
|
||
|
def = fragments.lookup(name);
|
||
|
}
|
||
|
return def || null;
|
||
|
},
|
||
|
};
|
||
|
}
|
||
|
|
||
|
var DELETE = Object.create(null);
|
||
|
var delModifier = function () { return DELETE; };
|
||
|
var INVALIDATE = Object.create(null);
|
||
|
var EntityStore = (function () {
|
||
|
function EntityStore(policies, group) {
|
||
|
var _this = this;
|
||
|
this.policies = policies;
|
||
|
this.group = group;
|
||
|
this.data = Object.create(null);
|
||
|
this.rootIds = Object.create(null);
|
||
|
this.refs = Object.create(null);
|
||
|
this.getFieldValue = function (objectOrReference, storeFieldName) {
|
||
|
return maybeDeepFreeze(isReference(objectOrReference) ?
|
||
|
_this.get(objectOrReference.__ref, storeFieldName)
|
||
|
: objectOrReference && objectOrReference[storeFieldName]);
|
||
|
};
|
||
|
this.canRead = function (objOrRef) {
|
||
|
return isReference(objOrRef) ?
|
||
|
_this.has(objOrRef.__ref)
|
||
|
: typeof objOrRef === "object";
|
||
|
};
|
||
|
this.toReference = function (objOrIdOrRef, mergeIntoStore) {
|
||
|
if (typeof objOrIdOrRef === "string") {
|
||
|
return makeReference(objOrIdOrRef);
|
||
|
}
|
||
|
if (isReference(objOrIdOrRef)) {
|
||
|
return objOrIdOrRef;
|
||
|
}
|
||
|
var id = _this.policies.identify(objOrIdOrRef)[0];
|
||
|
if (id) {
|
||
|
var ref = makeReference(id);
|
||
|
if (mergeIntoStore) {
|
||
|
_this.merge(id, objOrIdOrRef);
|
||
|
}
|
||
|
return ref;
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
EntityStore.prototype.toObject = function () {
|
||
|
return tslib.__assign({}, this.data);
|
||
|
};
|
||
|
EntityStore.prototype.has = function (dataId) {
|
||
|
return this.lookup(dataId, true) !== void 0;
|
||
|
};
|
||
|
EntityStore.prototype.get = function (dataId, fieldName) {
|
||
|
this.group.depend(dataId, fieldName);
|
||
|
if (hasOwn.call(this.data, dataId)) {
|
||
|
var storeObject = this.data[dataId];
|
||
|
if (storeObject && hasOwn.call(storeObject, fieldName)) {
|
||
|
return storeObject[fieldName];
|
||
|
}
|
||
|
}
|
||
|
if (fieldName === "__typename" &&
|
||
|
hasOwn.call(this.policies.rootTypenamesById, dataId)) {
|
||
|
return this.policies.rootTypenamesById[dataId];
|
||
|
}
|
||
|
if (this instanceof Layer) {
|
||
|
return this.parent.get(dataId, fieldName);
|
||
|
}
|
||
|
};
|
||
|
EntityStore.prototype.lookup = function (dataId, dependOnExistence) {
|
||
|
if (dependOnExistence)
|
||
|
this.group.depend(dataId, "__exists");
|
||
|
if (hasOwn.call(this.data, dataId)) {
|
||
|
return this.data[dataId];
|
||
|
}
|
||
|
if (this instanceof Layer) {
|
||
|
return this.parent.lookup(dataId, dependOnExistence);
|
||
|
}
|
||
|
if (this.policies.rootTypenamesById[dataId]) {
|
||
|
return Object.create(null);
|
||
|
}
|
||
|
};
|
||
|
EntityStore.prototype.merge = function (older, newer) {
|
||
|
var _this = this;
|
||
|
var dataId;
|
||
|
if (isReference(older))
|
||
|
older = older.__ref;
|
||
|
if (isReference(newer))
|
||
|
newer = newer.__ref;
|
||
|
var existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
|
||
|
var incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
|
||
|
if (!incoming)
|
||
|
return;
|
||
|
invariant(typeof dataId === "string", 1);
|
||
|
var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);
|
||
|
this.data[dataId] = merged;
|
||
|
if (merged !== existing) {
|
||
|
delete this.refs[dataId];
|
||
|
if (this.group.caching) {
|
||
|
var fieldsToDirty_1 = Object.create(null);
|
||
|
if (!existing)
|
||
|
fieldsToDirty_1.__exists = 1;
|
||
|
Object.keys(incoming).forEach(function (storeFieldName) {
|
||
|
if (!existing ||
|
||
|
existing[storeFieldName] !== merged[storeFieldName]) {
|
||
|
fieldsToDirty_1[storeFieldName] = 1;
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
if (fieldName !== storeFieldName &&
|
||
|
!_this.policies.hasKeyArgs(merged.__typename, fieldName)) {
|
||
|
fieldsToDirty_1[fieldName] = 1;
|
||
|
}
|
||
|
if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {
|
||
|
delete merged[storeFieldName];
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
if (fieldsToDirty_1.__typename &&
|
||
|
!(existing && existing.__typename) &&
|
||
|
this.policies.rootTypenamesById[dataId] === merged.__typename) {
|
||
|
delete fieldsToDirty_1.__typename;
|
||
|
}
|
||
|
Object.keys(fieldsToDirty_1).forEach(function (fieldName) {
|
||
|
return _this.group.dirty(dataId, fieldName);
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
EntityStore.prototype.modify = function (dataId, fields) {
|
||
|
var _this = this;
|
||
|
var storeObject = this.lookup(dataId);
|
||
|
if (storeObject) {
|
||
|
var changedFields_1 = Object.create(null);
|
||
|
var needToMerge_1 = false;
|
||
|
var allDeleted_1 = true;
|
||
|
var sharedDetails_1 = {
|
||
|
DELETE: DELETE,
|
||
|
INVALIDATE: INVALIDATE,
|
||
|
isReference: isReference,
|
||
|
toReference: this.toReference,
|
||
|
canRead: this.canRead,
|
||
|
readField: function (fieldNameOrOptions, from) {
|
||
|
return _this.policies.readField(typeof fieldNameOrOptions === "string" ?
|
||
|
{
|
||
|
fieldName: fieldNameOrOptions,
|
||
|
from: from || makeReference(dataId),
|
||
|
}
|
||
|
: fieldNameOrOptions, { store: _this });
|
||
|
},
|
||
|
};
|
||
|
Object.keys(storeObject).forEach(function (storeFieldName) {
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
var fieldValue = storeObject[storeFieldName];
|
||
|
if (fieldValue === void 0)
|
||
|
return;
|
||
|
var modify = typeof fields === "function" ? fields : (fields[storeFieldName] || fields[fieldName]);
|
||
|
if (modify) {
|
||
|
var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), tslib.__assign(tslib.__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));
|
||
|
if (newValue === INVALIDATE) {
|
||
|
_this.group.dirty(dataId, storeFieldName);
|
||
|
}
|
||
|
else {
|
||
|
if (newValue === DELETE)
|
||
|
newValue = void 0;
|
||
|
if (newValue !== fieldValue) {
|
||
|
changedFields_1[storeFieldName] = newValue;
|
||
|
needToMerge_1 = true;
|
||
|
fieldValue = newValue;
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
var checkReference = function (ref) {
|
||
|
if (_this.lookup(ref.__ref) === undefined) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(2, ref);
|
||
|
return true;
|
||
|
}
|
||
|
};
|
||
|
if (isReference(newValue)) {
|
||
|
checkReference(newValue);
|
||
|
}
|
||
|
else if (Array.isArray(newValue)) {
|
||
|
var seenReference = false;
|
||
|
var someNonReference = void 0;
|
||
|
for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {
|
||
|
var value = newValue_1[_i];
|
||
|
if (isReference(value)) {
|
||
|
seenReference = true;
|
||
|
if (checkReference(value))
|
||
|
break;
|
||
|
}
|
||
|
else {
|
||
|
if (typeof value === "object" && !!value) {
|
||
|
var id = _this.policies.identify(value)[0];
|
||
|
if (id) {
|
||
|
someNonReference = value;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (seenReference && someNonReference !== undefined) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(3, someNonReference);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (fieldValue !== void 0) {
|
||
|
allDeleted_1 = false;
|
||
|
}
|
||
|
});
|
||
|
if (needToMerge_1) {
|
||
|
this.merge(dataId, changedFields_1);
|
||
|
if (allDeleted_1) {
|
||
|
if (this instanceof Layer) {
|
||
|
this.data[dataId] = void 0;
|
||
|
}
|
||
|
else {
|
||
|
delete this.data[dataId];
|
||
|
}
|
||
|
this.group.dirty(dataId, "__exists");
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
};
|
||
|
EntityStore.prototype.delete = function (dataId, fieldName, args) {
|
||
|
var _a;
|
||
|
var storeObject = this.lookup(dataId);
|
||
|
if (storeObject) {
|
||
|
var typename = this.getFieldValue(storeObject, "__typename");
|
||
|
var storeFieldName = fieldName && args ?
|
||
|
this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })
|
||
|
: fieldName;
|
||
|
return this.modify(dataId, storeFieldName ? (_a = {},
|
||
|
_a[storeFieldName] = delModifier,
|
||
|
_a) : delModifier);
|
||
|
}
|
||
|
return false;
|
||
|
};
|
||
|
EntityStore.prototype.evict = function (options, limit) {
|
||
|
var evicted = false;
|
||
|
if (options.id) {
|
||
|
if (hasOwn.call(this.data, options.id)) {
|
||
|
evicted = this.delete(options.id, options.fieldName, options.args);
|
||
|
}
|
||
|
if (this instanceof Layer && this !== limit) {
|
||
|
evicted = this.parent.evict(options, limit) || evicted;
|
||
|
}
|
||
|
if (options.fieldName || evicted) {
|
||
|
this.group.dirty(options.id, options.fieldName || "__exists");
|
||
|
}
|
||
|
}
|
||
|
return evicted;
|
||
|
};
|
||
|
EntityStore.prototype.clear = function () {
|
||
|
this.replace(null);
|
||
|
};
|
||
|
EntityStore.prototype.extract = function () {
|
||
|
var _this = this;
|
||
|
var obj = this.toObject();
|
||
|
var extraRootIds = [];
|
||
|
this.getRootIdSet().forEach(function (id) {
|
||
|
if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {
|
||
|
extraRootIds.push(id);
|
||
|
}
|
||
|
});
|
||
|
if (extraRootIds.length) {
|
||
|
obj.__META = { extraRootIds: extraRootIds.sort() };
|
||
|
}
|
||
|
return obj;
|
||
|
};
|
||
|
EntityStore.prototype.replace = function (newData) {
|
||
|
var _this = this;
|
||
|
Object.keys(this.data).forEach(function (dataId) {
|
||
|
if (!(newData && hasOwn.call(newData, dataId))) {
|
||
|
_this.delete(dataId);
|
||
|
}
|
||
|
});
|
||
|
if (newData) {
|
||
|
var __META = newData.__META, rest_1 = tslib.__rest(newData, ["__META"]);
|
||
|
Object.keys(rest_1).forEach(function (dataId) {
|
||
|
_this.merge(dataId, rest_1[dataId]);
|
||
|
});
|
||
|
if (__META) {
|
||
|
__META.extraRootIds.forEach(this.retain, this);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
EntityStore.prototype.retain = function (rootId) {
|
||
|
return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);
|
||
|
};
|
||
|
EntityStore.prototype.release = function (rootId) {
|
||
|
if (this.rootIds[rootId] > 0) {
|
||
|
var count = --this.rootIds[rootId];
|
||
|
if (!count)
|
||
|
delete this.rootIds[rootId];
|
||
|
return count;
|
||
|
}
|
||
|
return 0;
|
||
|
};
|
||
|
EntityStore.prototype.getRootIdSet = function (ids) {
|
||
|
if (ids === void 0) { ids = new Set(); }
|
||
|
Object.keys(this.rootIds).forEach(ids.add, ids);
|
||
|
if (this instanceof Layer) {
|
||
|
this.parent.getRootIdSet(ids);
|
||
|
}
|
||
|
else {
|
||
|
Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
|
||
|
}
|
||
|
return ids;
|
||
|
};
|
||
|
EntityStore.prototype.gc = function () {
|
||
|
var _this = this;
|
||
|
var ids = this.getRootIdSet();
|
||
|
var snapshot = this.toObject();
|
||
|
ids.forEach(function (id) {
|
||
|
if (hasOwn.call(snapshot, id)) {
|
||
|
Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);
|
||
|
delete snapshot[id];
|
||
|
}
|
||
|
});
|
||
|
var idsToRemove = Object.keys(snapshot);
|
||
|
if (idsToRemove.length) {
|
||
|
var root_1 = this;
|
||
|
while (root_1 instanceof Layer)
|
||
|
root_1 = root_1.parent;
|
||
|
idsToRemove.forEach(function (id) { return root_1.delete(id); });
|
||
|
}
|
||
|
return idsToRemove;
|
||
|
};
|
||
|
EntityStore.prototype.findChildRefIds = function (dataId) {
|
||
|
if (!hasOwn.call(this.refs, dataId)) {
|
||
|
var found_1 = (this.refs[dataId] = Object.create(null));
|
||
|
var root = this.data[dataId];
|
||
|
if (!root)
|
||
|
return found_1;
|
||
|
var workSet_1 = new Set([root]);
|
||
|
workSet_1.forEach(function (obj) {
|
||
|
if (isReference(obj)) {
|
||
|
found_1[obj.__ref] = true;
|
||
|
}
|
||
|
if (isNonNullObject(obj)) {
|
||
|
Object.keys(obj).forEach(function (key) {
|
||
|
var child = obj[key];
|
||
|
if (isNonNullObject(child)) {
|
||
|
workSet_1.add(child);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return this.refs[dataId];
|
||
|
};
|
||
|
EntityStore.prototype.makeCacheKey = function () {
|
||
|
return this.group.keyMaker.lookupArray(arguments);
|
||
|
};
|
||
|
return EntityStore;
|
||
|
}());
|
||
|
var CacheGroup = (function () {
|
||
|
function CacheGroup(caching, parent) {
|
||
|
if (parent === void 0) { parent = null; }
|
||
|
this.caching = caching;
|
||
|
this.parent = parent;
|
||
|
this.d = null;
|
||
|
this.resetCaching();
|
||
|
}
|
||
|
CacheGroup.prototype.resetCaching = function () {
|
||
|
this.d = this.caching ? optimism.dep() : null;
|
||
|
this.keyMaker = new trie.Trie(canUseWeakMap);
|
||
|
};
|
||
|
CacheGroup.prototype.depend = function (dataId, storeFieldName) {
|
||
|
if (this.d) {
|
||
|
this.d(makeDepKey(dataId, storeFieldName));
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
if (fieldName !== storeFieldName) {
|
||
|
this.d(makeDepKey(dataId, fieldName));
|
||
|
}
|
||
|
if (this.parent) {
|
||
|
this.parent.depend(dataId, storeFieldName);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
CacheGroup.prototype.dirty = function (dataId, storeFieldName) {
|
||
|
if (this.d) {
|
||
|
this.d.dirty(makeDepKey(dataId, storeFieldName),
|
||
|
storeFieldName === "__exists" ? "forget" : "setDirty");
|
||
|
}
|
||
|
};
|
||
|
return CacheGroup;
|
||
|
}());
|
||
|
function makeDepKey(dataId, storeFieldName) {
|
||
|
return storeFieldName + "#" + dataId;
|
||
|
}
|
||
|
function maybeDependOnExistenceOfEntity(store, entityId) {
|
||
|
if (supportsResultCaching(store)) {
|
||
|
store.group.depend(entityId, "__exists");
|
||
|
}
|
||
|
}
|
||
|
(function (EntityStore) {
|
||
|
var Root = (function (_super) {
|
||
|
tslib.__extends(Root, _super);
|
||
|
function Root(_a) {
|
||
|
var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;
|
||
|
var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;
|
||
|
_this.stump = new Stump(_this);
|
||
|
_this.storageTrie = new trie.Trie(canUseWeakMap);
|
||
|
if (seed)
|
||
|
_this.replace(seed);
|
||
|
return _this;
|
||
|
}
|
||
|
Root.prototype.addLayer = function (layerId, replay) {
|
||
|
return this.stump.addLayer(layerId, replay);
|
||
|
};
|
||
|
Root.prototype.removeLayer = function () {
|
||
|
return this;
|
||
|
};
|
||
|
Root.prototype.getStorage = function () {
|
||
|
return this.storageTrie.lookupArray(arguments);
|
||
|
};
|
||
|
return Root;
|
||
|
}(EntityStore));
|
||
|
EntityStore.Root = Root;
|
||
|
})(EntityStore || (EntityStore = {}));
|
||
|
var Layer = (function (_super) {
|
||
|
tslib.__extends(Layer, _super);
|
||
|
function Layer(id, parent, replay, group) {
|
||
|
var _this = _super.call(this, parent.policies, group) || this;
|
||
|
_this.id = id;
|
||
|
_this.parent = parent;
|
||
|
_this.replay = replay;
|
||
|
_this.group = group;
|
||
|
replay(_this);
|
||
|
return _this;
|
||
|
}
|
||
|
Layer.prototype.addLayer = function (layerId, replay) {
|
||
|
return new Layer(layerId, this, replay, this.group);
|
||
|
};
|
||
|
Layer.prototype.removeLayer = function (layerId) {
|
||
|
var _this = this;
|
||
|
var parent = this.parent.removeLayer(layerId);
|
||
|
if (layerId === this.id) {
|
||
|
if (this.group.caching) {
|
||
|
Object.keys(this.data).forEach(function (dataId) {
|
||
|
var ownStoreObject = _this.data[dataId];
|
||
|
var parentStoreObject = parent["lookup"](dataId);
|
||
|
if (!parentStoreObject) {
|
||
|
_this.delete(dataId);
|
||
|
}
|
||
|
else if (!ownStoreObject) {
|
||
|
_this.group.dirty(dataId, "__exists");
|
||
|
Object.keys(parentStoreObject).forEach(function (storeFieldName) {
|
||
|
_this.group.dirty(dataId, storeFieldName);
|
||
|
});
|
||
|
}
|
||
|
else if (ownStoreObject !== parentStoreObject) {
|
||
|
Object.keys(ownStoreObject).forEach(function (storeFieldName) {
|
||
|
if (!equal.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
|
||
|
_this.group.dirty(dataId, storeFieldName);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return parent;
|
||
|
}
|
||
|
if (parent === this.parent)
|
||
|
return this;
|
||
|
return parent.addLayer(this.id, this.replay);
|
||
|
};
|
||
|
Layer.prototype.toObject = function () {
|
||
|
return tslib.__assign(tslib.__assign({}, this.parent.toObject()), this.data);
|
||
|
};
|
||
|
Layer.prototype.findChildRefIds = function (dataId) {
|
||
|
var fromParent = this.parent.findChildRefIds(dataId);
|
||
|
return hasOwn.call(this.data, dataId) ? tslib.__assign(tslib.__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;
|
||
|
};
|
||
|
Layer.prototype.getStorage = function () {
|
||
|
var p = this.parent;
|
||
|
while (p.parent)
|
||
|
p = p.parent;
|
||
|
return p.getStorage.apply(p,
|
||
|
arguments);
|
||
|
};
|
||
|
return Layer;
|
||
|
}(EntityStore));
|
||
|
var Stump = (function (_super) {
|
||
|
tslib.__extends(Stump, _super);
|
||
|
function Stump(root) {
|
||
|
return _super.call(this, "EntityStore.Stump", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;
|
||
|
}
|
||
|
Stump.prototype.removeLayer = function () {
|
||
|
return this;
|
||
|
};
|
||
|
Stump.prototype.merge = function (older, newer) {
|
||
|
return this.parent.merge(older, newer);
|
||
|
};
|
||
|
return Stump;
|
||
|
}(Layer));
|
||
|
function storeObjectReconciler(existingObject, incomingObject, property) {
|
||
|
var existingValue = existingObject[property];
|
||
|
var incomingValue = incomingObject[property];
|
||
|
return equal.equal(existingValue, incomingValue) ? existingValue : incomingValue;
|
||
|
}
|
||
|
function supportsResultCaching(store) {
|
||
|
return !!(store instanceof EntityStore && store.group.caching);
|
||
|
}
|
||
|
|
||
|
function shallowCopy(value) {
|
||
|
if (isNonNullObject(value)) {
|
||
|
return isArray(value) ?
|
||
|
value.slice(0)
|
||
|
: tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
var ObjectCanon = (function () {
|
||
|
function ObjectCanon() {
|
||
|
this.known = new (canUseWeakSet ? WeakSet : Set)();
|
||
|
this.pool = new trie.Trie(canUseWeakMap);
|
||
|
this.passes = new WeakMap();
|
||
|
this.keysByJSON = new Map();
|
||
|
this.empty = this.admit({});
|
||
|
}
|
||
|
ObjectCanon.prototype.isKnown = function (value) {
|
||
|
return isNonNullObject(value) && this.known.has(value);
|
||
|
};
|
||
|
ObjectCanon.prototype.pass = function (value) {
|
||
|
if (isNonNullObject(value)) {
|
||
|
var copy = shallowCopy(value);
|
||
|
this.passes.set(copy, value);
|
||
|
return copy;
|
||
|
}
|
||
|
return value;
|
||
|
};
|
||
|
ObjectCanon.prototype.admit = function (value) {
|
||
|
var _this = this;
|
||
|
if (isNonNullObject(value)) {
|
||
|
var original = this.passes.get(value);
|
||
|
if (original)
|
||
|
return original;
|
||
|
var proto = Object.getPrototypeOf(value);
|
||
|
switch (proto) {
|
||
|
case Array.prototype: {
|
||
|
if (this.known.has(value))
|
||
|
return value;
|
||
|
var array = value.map(this.admit, this);
|
||
|
var node = this.pool.lookupArray(array);
|
||
|
if (!node.array) {
|
||
|
this.known.add((node.array = array));
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
Object.freeze(array);
|
||
|
}
|
||
|
}
|
||
|
return node.array;
|
||
|
}
|
||
|
case null:
|
||
|
case Object.prototype: {
|
||
|
if (this.known.has(value))
|
||
|
return value;
|
||
|
var proto_1 = Object.getPrototypeOf(value);
|
||
|
var array_1 = [proto_1];
|
||
|
var keys = this.sortedKeys(value);
|
||
|
array_1.push(keys.json);
|
||
|
var firstValueIndex_1 = array_1.length;
|
||
|
keys.sorted.forEach(function (key) {
|
||
|
array_1.push(_this.admit(value[key]));
|
||
|
});
|
||
|
var node = this.pool.lookupArray(array_1);
|
||
|
if (!node.object) {
|
||
|
var obj_1 = (node.object = Object.create(proto_1));
|
||
|
this.known.add(obj_1);
|
||
|
keys.sorted.forEach(function (key, i) {
|
||
|
obj_1[key] = array_1[firstValueIndex_1 + i];
|
||
|
});
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
Object.freeze(obj_1);
|
||
|
}
|
||
|
}
|
||
|
return node.object;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return value;
|
||
|
};
|
||
|
ObjectCanon.prototype.sortedKeys = function (obj) {
|
||
|
var keys = Object.keys(obj);
|
||
|
var node = this.pool.lookupArray(keys);
|
||
|
if (!node.keys) {
|
||
|
keys.sort();
|
||
|
var json = JSON.stringify(keys);
|
||
|
if (!(node.keys = this.keysByJSON.get(json))) {
|
||
|
this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));
|
||
|
}
|
||
|
}
|
||
|
return node.keys;
|
||
|
};
|
||
|
return ObjectCanon;
|
||
|
}());
|
||
|
|
||
|
function execSelectionSetKeyArgs(options) {
|
||
|
return [
|
||
|
options.selectionSet,
|
||
|
options.objectOrReference,
|
||
|
options.context,
|
||
|
options.context.canonizeResults,
|
||
|
];
|
||
|
}
|
||
|
var StoreReader = (function () {
|
||
|
function StoreReader(config) {
|
||
|
var _this = this;
|
||
|
this.knownResults = new (canUseWeakMap ? WeakMap : Map)();
|
||
|
this.config = compact(config, {
|
||
|
addTypename: config.addTypename !== false,
|
||
|
canonizeResults: shouldCanonizeResults(config),
|
||
|
});
|
||
|
this.canon = config.canon || new ObjectCanon();
|
||
|
this.executeSelectionSet = optimism.wrap(function (options) {
|
||
|
var _a;
|
||
|
var canonizeResults = options.context.canonizeResults;
|
||
|
var peekArgs = execSelectionSetKeyArgs(options);
|
||
|
peekArgs[3] = !canonizeResults;
|
||
|
var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);
|
||
|
if (other) {
|
||
|
if (canonizeResults) {
|
||
|
return tslib.__assign(tslib.__assign({}, other), {
|
||
|
result: _this.canon.admit(other.result) });
|
||
|
}
|
||
|
return other;
|
||
|
}
|
||
|
maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
|
||
|
return _this.execSelectionSetImpl(options);
|
||
|
}, {
|
||
|
max: this.config.resultCacheMaxSize ||
|
||
|
cacheSizes["inMemoryCache.executeSelectionSet"] ||
|
||
|
50000 ,
|
||
|
keyArgs: execSelectionSetKeyArgs,
|
||
|
makeCacheKey: function (selectionSet, parent, context, canonizeResults) {
|
||
|
if (supportsResultCaching(context.store)) {
|
||
|
return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
this.executeSubSelectedArray = optimism.wrap(function (options) {
|
||
|
maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
|
||
|
return _this.execSubSelectedArrayImpl(options);
|
||
|
}, {
|
||
|
max: this.config.resultCacheMaxSize ||
|
||
|
cacheSizes["inMemoryCache.executeSubSelectedArray"] ||
|
||
|
10000 ,
|
||
|
makeCacheKey: function (_a) {
|
||
|
var field = _a.field, array = _a.array, context = _a.context;
|
||
|
if (supportsResultCaching(context.store)) {
|
||
|
return context.store.makeCacheKey(field, array, context.varString);
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
StoreReader.prototype.resetCanon = function () {
|
||
|
this.canon = new ObjectCanon();
|
||
|
};
|
||
|
StoreReader.prototype.diffQueryAgainstStore = function (_a) {
|
||
|
var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? "ROOT_QUERY" : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;
|
||
|
var policies = this.config.cache.policies;
|
||
|
variables = tslib.__assign(tslib.__assign({}, getDefaultValues(getQueryDefinition(query))), variables);
|
||
|
var rootRef = makeReference(rootId);
|
||
|
var execResult = this.executeSelectionSet({
|
||
|
selectionSet: getMainDefinition(query).selectionSet,
|
||
|
objectOrReference: rootRef,
|
||
|
enclosingRef: rootRef,
|
||
|
context: tslib.__assign({ store: store, query: query, policies: policies, variables: variables, varString: canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),
|
||
|
});
|
||
|
var missing;
|
||
|
if (execResult.missing) {
|
||
|
missing = [
|
||
|
new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),
|
||
|
];
|
||
|
if (!returnPartialData) {
|
||
|
throw missing[0];
|
||
|
}
|
||
|
}
|
||
|
return {
|
||
|
result: execResult.result,
|
||
|
complete: !missing,
|
||
|
missing: missing,
|
||
|
};
|
||
|
};
|
||
|
StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {
|
||
|
if (supportsResultCaching(context.store) &&
|
||
|
this.knownResults.get(result) === selectionSet) {
|
||
|
var latest = this.executeSelectionSet.peek(selectionSet, parent, context,
|
||
|
this.canon.isKnown(result));
|
||
|
if (latest && result === latest.result) {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
};
|
||
|
StoreReader.prototype.execSelectionSetImpl = function (_a) {
|
||
|
var _this = this;
|
||
|
var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;
|
||
|
if (isReference(objectOrReference) &&
|
||
|
!context.policies.rootTypenamesById[objectOrReference.__ref] &&
|
||
|
!context.store.has(objectOrReference.__ref)) {
|
||
|
return {
|
||
|
result: this.canon.empty,
|
||
|
missing: "Dangling reference to missing ".concat(objectOrReference.__ref, " object"),
|
||
|
};
|
||
|
}
|
||
|
var variables = context.variables, policies = context.policies, store = context.store;
|
||
|
var typename = store.getFieldValue(objectOrReference, "__typename");
|
||
|
var objectsToMerge = [];
|
||
|
var missing;
|
||
|
var missingMerger = new DeepMerger();
|
||
|
if (this.config.addTypename &&
|
||
|
typeof typename === "string" &&
|
||
|
!policies.rootIdsByTypename[typename]) {
|
||
|
objectsToMerge.push({ __typename: typename });
|
||
|
}
|
||
|
function handleMissing(result, resultName) {
|
||
|
var _a;
|
||
|
if (result.missing) {
|
||
|
missing = missingMerger.merge(missing, (_a = {},
|
||
|
_a[resultName] = result.missing,
|
||
|
_a));
|
||
|
}
|
||
|
return result.result;
|
||
|
}
|
||
|
var workSet = new Set(selectionSet.selections);
|
||
|
workSet.forEach(function (selection) {
|
||
|
var _a, _b;
|
||
|
if (!shouldInclude(selection, variables))
|
||
|
return;
|
||
|
if (isField(selection)) {
|
||
|
var fieldValue = policies.readField({
|
||
|
fieldName: selection.name.value,
|
||
|
field: selection,
|
||
|
variables: context.variables,
|
||
|
from: objectOrReference,
|
||
|
}, context);
|
||
|
var resultName = resultKeyNameFromField(selection);
|
||
|
if (fieldValue === void 0) {
|
||
|
if (!addTypenameToDocument.added(selection)) {
|
||
|
missing = missingMerger.merge(missing, (_a = {},
|
||
|
_a[resultName] = "Can't find field '".concat(selection.name.value, "' on ").concat(isReference(objectOrReference) ?
|
||
|
objectOrReference.__ref + " object"
|
||
|
: "object " + JSON.stringify(objectOrReference, null, 2)),
|
||
|
_a));
|
||
|
}
|
||
|
}
|
||
|
else if (isArray(fieldValue)) {
|
||
|
fieldValue = handleMissing(_this.executeSubSelectedArray({
|
||
|
field: selection,
|
||
|
array: fieldValue,
|
||
|
enclosingRef: enclosingRef,
|
||
|
context: context,
|
||
|
}), resultName);
|
||
|
}
|
||
|
else if (!selection.selectionSet) {
|
||
|
if (context.canonizeResults) {
|
||
|
fieldValue = _this.canon.pass(fieldValue);
|
||
|
}
|
||
|
}
|
||
|
else if (fieldValue != null) {
|
||
|
fieldValue = handleMissing(_this.executeSelectionSet({
|
||
|
selectionSet: selection.selectionSet,
|
||
|
objectOrReference: fieldValue,
|
||
|
enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,
|
||
|
context: context,
|
||
|
}), resultName);
|
||
|
}
|
||
|
if (fieldValue !== void 0) {
|
||
|
objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
var fragment = getFragmentFromSelection(selection, context.lookupFragment);
|
||
|
if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
|
||
|
throw newInvariantError(9, selection.name.value);
|
||
|
}
|
||
|
if (fragment && policies.fragmentMatches(fragment, typename)) {
|
||
|
fragment.selectionSet.selections.forEach(workSet.add, workSet);
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
var result = mergeDeepArray(objectsToMerge);
|
||
|
var finalResult = { result: result, missing: missing };
|
||
|
var frozen = context.canonizeResults ?
|
||
|
this.canon.admit(finalResult)
|
||
|
: maybeDeepFreeze(finalResult);
|
||
|
if (frozen.result) {
|
||
|
this.knownResults.set(frozen.result, selectionSet);
|
||
|
}
|
||
|
return frozen;
|
||
|
};
|
||
|
StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {
|
||
|
var _this = this;
|
||
|
var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;
|
||
|
var missing;
|
||
|
var missingMerger = new DeepMerger();
|
||
|
function handleMissing(childResult, i) {
|
||
|
var _a;
|
||
|
if (childResult.missing) {
|
||
|
missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));
|
||
|
}
|
||
|
return childResult.result;
|
||
|
}
|
||
|
if (field.selectionSet) {
|
||
|
array = array.filter(context.store.canRead);
|
||
|
}
|
||
|
array = array.map(function (item, i) {
|
||
|
if (item === null) {
|
||
|
return null;
|
||
|
}
|
||
|
if (isArray(item)) {
|
||
|
return handleMissing(_this.executeSubSelectedArray({
|
||
|
field: field,
|
||
|
array: item,
|
||
|
enclosingRef: enclosingRef,
|
||
|
context: context,
|
||
|
}), i);
|
||
|
}
|
||
|
if (field.selectionSet) {
|
||
|
return handleMissing(_this.executeSelectionSet({
|
||
|
selectionSet: field.selectionSet,
|
||
|
objectOrReference: item,
|
||
|
enclosingRef: isReference(item) ? item : enclosingRef,
|
||
|
context: context,
|
||
|
}), i);
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
assertSelectionSetForIdValue(context.store, field, item);
|
||
|
}
|
||
|
return item;
|
||
|
});
|
||
|
return {
|
||
|
result: context.canonizeResults ? this.canon.admit(array) : array,
|
||
|
missing: missing,
|
||
|
};
|
||
|
};
|
||
|
return StoreReader;
|
||
|
}());
|
||
|
function firstMissing(tree) {
|
||
|
try {
|
||
|
JSON.stringify(tree, function (_, value) {
|
||
|
if (typeof value === "string")
|
||
|
throw value;
|
||
|
return value;
|
||
|
});
|
||
|
}
|
||
|
catch (result) {
|
||
|
return result;
|
||
|
}
|
||
|
}
|
||
|
function assertSelectionSetForIdValue(store, field, fieldValue) {
|
||
|
if (!field.selectionSet) {
|
||
|
var workSet_1 = new Set([fieldValue]);
|
||
|
workSet_1.forEach(function (value) {
|
||
|
if (isNonNullObject(value)) {
|
||
|
invariant(
|
||
|
!isReference(value),
|
||
|
10,
|
||
|
getTypenameFromStoreObject(store, value),
|
||
|
field.name.value
|
||
|
);
|
||
|
Object.values(value).forEach(workSet_1.add, workSet_1);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var cacheSlot = new optimism.Slot();
|
||
|
var cacheInfoMap = new WeakMap();
|
||
|
function getCacheInfo(cache) {
|
||
|
var info = cacheInfoMap.get(cache);
|
||
|
if (!info) {
|
||
|
cacheInfoMap.set(cache, (info = {
|
||
|
vars: new Set(),
|
||
|
dep: optimism.dep(),
|
||
|
}));
|
||
|
}
|
||
|
return info;
|
||
|
}
|
||
|
function forgetCache(cache) {
|
||
|
getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
|
||
|
}
|
||
|
function recallCache(cache) {
|
||
|
getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
|
||
|
}
|
||
|
function makeVar(value) {
|
||
|
var caches = new Set();
|
||
|
var listeners = new Set();
|
||
|
var rv = function (newValue) {
|
||
|
if (arguments.length > 0) {
|
||
|
if (value !== newValue) {
|
||
|
value = newValue;
|
||
|
caches.forEach(function (cache) {
|
||
|
getCacheInfo(cache).dep.dirty(rv);
|
||
|
broadcast(cache);
|
||
|
});
|
||
|
var oldListeners = Array.from(listeners);
|
||
|
listeners.clear();
|
||
|
oldListeners.forEach(function (listener) { return listener(value); });
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
var cache = cacheSlot.getValue();
|
||
|
if (cache) {
|
||
|
attach(cache);
|
||
|
getCacheInfo(cache).dep(rv);
|
||
|
}
|
||
|
}
|
||
|
return value;
|
||
|
};
|
||
|
rv.onNextChange = function (listener) {
|
||
|
listeners.add(listener);
|
||
|
return function () {
|
||
|
listeners.delete(listener);
|
||
|
};
|
||
|
};
|
||
|
var attach = (rv.attachCache = function (cache) {
|
||
|
caches.add(cache);
|
||
|
getCacheInfo(cache).vars.add(rv);
|
||
|
return rv;
|
||
|
});
|
||
|
rv.forgetCache = function (cache) { return caches.delete(cache); };
|
||
|
return rv;
|
||
|
}
|
||
|
function broadcast(cache) {
|
||
|
if (cache.broadcastWatches) {
|
||
|
cache.broadcastWatches();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var specifierInfoCache = Object.create(null);
|
||
|
function lookupSpecifierInfo(spec) {
|
||
|
var cacheKey = JSON.stringify(spec);
|
||
|
return (specifierInfoCache[cacheKey] ||
|
||
|
(specifierInfoCache[cacheKey] = Object.create(null)));
|
||
|
}
|
||
|
function keyFieldsFnFromSpecifier(specifier) {
|
||
|
var info = lookupSpecifierInfo(specifier);
|
||
|
return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {
|
||
|
var extract = function (from, key) {
|
||
|
return context.readField(key, from);
|
||
|
};
|
||
|
var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {
|
||
|
var extracted = extractKeyPath(context.storeObject, schemaKeyPath,
|
||
|
extract);
|
||
|
if (extracted === void 0 &&
|
||
|
object !== context.storeObject &&
|
||
|
hasOwn.call(object, schemaKeyPath[0])) {
|
||
|
extracted = extractKeyPath(object, schemaKeyPath, extractKey);
|
||
|
}
|
||
|
invariant(extracted !== void 0, 4, schemaKeyPath.join("."), object);
|
||
|
return extracted;
|
||
|
}));
|
||
|
return "".concat(context.typename, ":").concat(JSON.stringify(keyObject));
|
||
|
}));
|
||
|
}
|
||
|
function keyArgsFnFromSpecifier(specifier) {
|
||
|
var info = lookupSpecifierInfo(specifier);
|
||
|
return (info.keyArgsFn ||
|
||
|
(info.keyArgsFn = function (args, _a) {
|
||
|
var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;
|
||
|
var collected = collectSpecifierPaths(specifier, function (keyPath) {
|
||
|
var firstKey = keyPath[0];
|
||
|
var firstChar = firstKey.charAt(0);
|
||
|
if (firstChar === "@") {
|
||
|
if (field && isNonEmptyArray(field.directives)) {
|
||
|
var directiveName_1 = firstKey.slice(1);
|
||
|
var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });
|
||
|
var directiveArgs = d && argumentsObjectFromField(d, variables);
|
||
|
return (directiveArgs &&
|
||
|
extractKeyPath(directiveArgs,
|
||
|
keyPath.slice(1)));
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
if (firstChar === "$") {
|
||
|
var variableName = firstKey.slice(1);
|
||
|
if (variables && hasOwn.call(variables, variableName)) {
|
||
|
var varKeyPath = keyPath.slice(0);
|
||
|
varKeyPath[0] = variableName;
|
||
|
return extractKeyPath(variables, varKeyPath);
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
if (args) {
|
||
|
return extractKeyPath(args, keyPath);
|
||
|
}
|
||
|
});
|
||
|
var suffix = JSON.stringify(collected);
|
||
|
if (args || suffix !== "{}") {
|
||
|
fieldName += ":" + suffix;
|
||
|
}
|
||
|
return fieldName;
|
||
|
}));
|
||
|
}
|
||
|
function collectSpecifierPaths(specifier, extractor) {
|
||
|
var merger = new DeepMerger();
|
||
|
return getSpecifierPaths(specifier).reduce(function (collected, path) {
|
||
|
var _a;
|
||
|
var toMerge = extractor(path);
|
||
|
if (toMerge !== void 0) {
|
||
|
for (var i = path.length - 1; i >= 0; --i) {
|
||
|
toMerge = (_a = {}, _a[path[i]] = toMerge, _a);
|
||
|
}
|
||
|
collected = merger.merge(collected, toMerge);
|
||
|
}
|
||
|
return collected;
|
||
|
}, Object.create(null));
|
||
|
}
|
||
|
function getSpecifierPaths(spec) {
|
||
|
var info = lookupSpecifierInfo(spec);
|
||
|
if (!info.paths) {
|
||
|
var paths_1 = (info.paths = []);
|
||
|
var currentPath_1 = [];
|
||
|
spec.forEach(function (s, i) {
|
||
|
if (isArray(s)) {
|
||
|
getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });
|
||
|
currentPath_1.length = 0;
|
||
|
}
|
||
|
else {
|
||
|
currentPath_1.push(s);
|
||
|
if (!isArray(spec[i + 1])) {
|
||
|
paths_1.push(currentPath_1.slice(0));
|
||
|
currentPath_1.length = 0;
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return info.paths;
|
||
|
}
|
||
|
function extractKey(object, key) {
|
||
|
return object[key];
|
||
|
}
|
||
|
function extractKeyPath(object, path, extract) {
|
||
|
extract = extract || extractKey;
|
||
|
return normalize(path.reduce(function reducer(obj, key) {
|
||
|
return isArray(obj) ?
|
||
|
obj.map(function (child) { return reducer(child, key); })
|
||
|
: obj && extract(obj, key);
|
||
|
}, object));
|
||
|
}
|
||
|
function normalize(value) {
|
||
|
if (isNonNullObject(value)) {
|
||
|
if (isArray(value)) {
|
||
|
return value.map(normalize);
|
||
|
}
|
||
|
return collectSpecifierPaths(Object.keys(value).sort(), function (path) {
|
||
|
return extractKeyPath(value, path);
|
||
|
});
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function argsFromFieldSpecifier(spec) {
|
||
|
return (spec.args !== void 0 ? spec.args
|
||
|
: spec.field ? argumentsObjectFromField(spec.field, spec.variables)
|
||
|
: null);
|
||
|
}
|
||
|
var nullKeyFieldsFn = function () { return void 0; };
|
||
|
var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
|
||
|
var mergeTrueFn = function (existing, incoming, _a) {
|
||
|
var mergeObjects = _a.mergeObjects;
|
||
|
return mergeObjects(existing, incoming);
|
||
|
};
|
||
|
var mergeFalseFn = function (_, incoming) { return incoming; };
|
||
|
var Policies = (function () {
|
||
|
function Policies(config) {
|
||
|
this.config = config;
|
||
|
this.typePolicies = Object.create(null);
|
||
|
this.toBeAdded = Object.create(null);
|
||
|
this.supertypeMap = new Map();
|
||
|
this.fuzzySubtypes = new Map();
|
||
|
this.rootIdsByTypename = Object.create(null);
|
||
|
this.rootTypenamesById = Object.create(null);
|
||
|
this.usingPossibleTypes = false;
|
||
|
this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);
|
||
|
this.cache = this.config.cache;
|
||
|
this.setRootTypename("Query");
|
||
|
this.setRootTypename("Mutation");
|
||
|
this.setRootTypename("Subscription");
|
||
|
if (config.possibleTypes) {
|
||
|
this.addPossibleTypes(config.possibleTypes);
|
||
|
}
|
||
|
if (config.typePolicies) {
|
||
|
this.addTypePolicies(config.typePolicies);
|
||
|
}
|
||
|
}
|
||
|
Policies.prototype.identify = function (object, partialContext) {
|
||
|
var _a;
|
||
|
var policies = this;
|
||
|
var typename = (partialContext &&
|
||
|
(partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||
|
||
|
object.__typename;
|
||
|
if (typename === this.rootTypenamesById.ROOT_QUERY) {
|
||
|
return ["ROOT_QUERY"];
|
||
|
}
|
||
|
var storeObject = (partialContext && partialContext.storeObject) || object;
|
||
|
var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||
|
||
|
function () {
|
||
|
var options = normalizeReadFieldOptions(arguments, storeObject);
|
||
|
return policies.readField(options, {
|
||
|
store: policies.cache["data"],
|
||
|
variables: options.variables,
|
||
|
});
|
||
|
} });
|
||
|
var id;
|
||
|
var policy = typename && this.getTypePolicy(typename);
|
||
|
var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
|
||
|
while (keyFn) {
|
||
|
var specifierOrId = keyFn(tslib.__assign(tslib.__assign({}, object), storeObject), context);
|
||
|
if (isArray(specifierOrId)) {
|
||
|
keyFn = keyFieldsFnFromSpecifier(specifierOrId);
|
||
|
}
|
||
|
else {
|
||
|
id = specifierOrId;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
id = id ? String(id) : void 0;
|
||
|
return context.keyObject ? [id, context.keyObject] : [id];
|
||
|
};
|
||
|
Policies.prototype.addTypePolicies = function (typePolicies) {
|
||
|
var _this = this;
|
||
|
Object.keys(typePolicies).forEach(function (typename) {
|
||
|
var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = tslib.__rest(_a, ["queryType", "mutationType", "subscriptionType"]);
|
||
|
if (queryType)
|
||
|
_this.setRootTypename("Query", typename);
|
||
|
if (mutationType)
|
||
|
_this.setRootTypename("Mutation", typename);
|
||
|
if (subscriptionType)
|
||
|
_this.setRootTypename("Subscription", typename);
|
||
|
if (hasOwn.call(_this.toBeAdded, typename)) {
|
||
|
_this.toBeAdded[typename].push(incoming);
|
||
|
}
|
||
|
else {
|
||
|
_this.toBeAdded[typename] = [incoming];
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
Policies.prototype.updateTypePolicy = function (typename, incoming) {
|
||
|
var _this = this;
|
||
|
var existing = this.getTypePolicy(typename);
|
||
|
var keyFields = incoming.keyFields, fields = incoming.fields;
|
||
|
function setMerge(existing, merge) {
|
||
|
existing.merge =
|
||
|
typeof merge === "function" ? merge
|
||
|
: merge === true ? mergeTrueFn
|
||
|
: merge === false ? mergeFalseFn
|
||
|
: existing.merge;
|
||
|
}
|
||
|
setMerge(existing, incoming.merge);
|
||
|
existing.keyFn =
|
||
|
keyFields === false ? nullKeyFieldsFn
|
||
|
: isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)
|
||
|
: typeof keyFields === "function" ? keyFields
|
||
|
: existing.keyFn;
|
||
|
if (fields) {
|
||
|
Object.keys(fields).forEach(function (fieldName) {
|
||
|
var existing = _this.getFieldPolicy(typename, fieldName, true);
|
||
|
var incoming = fields[fieldName];
|
||
|
if (typeof incoming === "function") {
|
||
|
existing.read = incoming;
|
||
|
}
|
||
|
else {
|
||
|
var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;
|
||
|
existing.keyFn =
|
||
|
keyArgs === false ? simpleKeyArgsFn
|
||
|
: isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)
|
||
|
: typeof keyArgs === "function" ? keyArgs
|
||
|
: existing.keyFn;
|
||
|
if (typeof read === "function") {
|
||
|
existing.read = read;
|
||
|
}
|
||
|
setMerge(existing, merge);
|
||
|
}
|
||
|
if (existing.read && existing.merge) {
|
||
|
existing.keyFn = existing.keyFn || simpleKeyArgsFn;
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
};
|
||
|
Policies.prototype.setRootTypename = function (which, typename) {
|
||
|
if (typename === void 0) { typename = which; }
|
||
|
var rootId = "ROOT_" + which.toUpperCase();
|
||
|
var old = this.rootTypenamesById[rootId];
|
||
|
if (typename !== old) {
|
||
|
invariant(!old || old === which, 5, which);
|
||
|
if (old)
|
||
|
delete this.rootIdsByTypename[old];
|
||
|
this.rootIdsByTypename[typename] = rootId;
|
||
|
this.rootTypenamesById[rootId] = typename;
|
||
|
}
|
||
|
};
|
||
|
Policies.prototype.addPossibleTypes = function (possibleTypes) {
|
||
|
var _this = this;
|
||
|
this.usingPossibleTypes = true;
|
||
|
Object.keys(possibleTypes).forEach(function (supertype) {
|
||
|
_this.getSupertypeSet(supertype, true);
|
||
|
possibleTypes[supertype].forEach(function (subtype) {
|
||
|
_this.getSupertypeSet(subtype, true).add(supertype);
|
||
|
var match = subtype.match(TypeOrFieldNameRegExp);
|
||
|
if (!match || match[0] !== subtype) {
|
||
|
_this.fuzzySubtypes.set(subtype, new RegExp(subtype));
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
Policies.prototype.getTypePolicy = function (typename) {
|
||
|
var _this = this;
|
||
|
if (!hasOwn.call(this.typePolicies, typename)) {
|
||
|
var policy_1 = (this.typePolicies[typename] = Object.create(null));
|
||
|
policy_1.fields = Object.create(null);
|
||
|
var supertypes_1 = this.supertypeMap.get(typename);
|
||
|
if (!supertypes_1 && this.fuzzySubtypes.size) {
|
||
|
supertypes_1 = this.getSupertypeSet(typename, true);
|
||
|
this.fuzzySubtypes.forEach(function (regExp, fuzzy) {
|
||
|
if (regExp.test(typename)) {
|
||
|
var fuzzySupertypes = _this.supertypeMap.get(fuzzy);
|
||
|
if (fuzzySupertypes) {
|
||
|
fuzzySupertypes.forEach(function (supertype) {
|
||
|
return supertypes_1.add(supertype);
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
if (supertypes_1 && supertypes_1.size) {
|
||
|
supertypes_1.forEach(function (supertype) {
|
||
|
var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = tslib.__rest(_a, ["fields"]);
|
||
|
Object.assign(policy_1, rest);
|
||
|
Object.assign(policy_1.fields, fields);
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
var inbox = this.toBeAdded[typename];
|
||
|
if (inbox && inbox.length) {
|
||
|
inbox.splice(0).forEach(function (policy) {
|
||
|
_this.updateTypePolicy(typename, policy);
|
||
|
});
|
||
|
}
|
||
|
return this.typePolicies[typename];
|
||
|
};
|
||
|
Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {
|
||
|
if (typename) {
|
||
|
var fieldPolicies = this.getTypePolicy(typename).fields;
|
||
|
return (fieldPolicies[fieldName] ||
|
||
|
(createIfMissing && (fieldPolicies[fieldName] = Object.create(null))));
|
||
|
}
|
||
|
};
|
||
|
Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {
|
||
|
var supertypeSet = this.supertypeMap.get(subtype);
|
||
|
if (!supertypeSet && createIfMissing) {
|
||
|
this.supertypeMap.set(subtype, (supertypeSet = new Set()));
|
||
|
}
|
||
|
return supertypeSet;
|
||
|
};
|
||
|
Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {
|
||
|
var _this = this;
|
||
|
if (!fragment.typeCondition)
|
||
|
return true;
|
||
|
if (!typename)
|
||
|
return false;
|
||
|
var supertype = fragment.typeCondition.name.value;
|
||
|
if (typename === supertype)
|
||
|
return true;
|
||
|
if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {
|
||
|
var typenameSupertypeSet = this.getSupertypeSet(typename, true);
|
||
|
var workQueue_1 = [typenameSupertypeSet];
|
||
|
var maybeEnqueue_1 = function (subtype) {
|
||
|
var supertypeSet = _this.getSupertypeSet(subtype, false);
|
||
|
if (supertypeSet &&
|
||
|
supertypeSet.size &&
|
||
|
workQueue_1.indexOf(supertypeSet) < 0) {
|
||
|
workQueue_1.push(supertypeSet);
|
||
|
}
|
||
|
};
|
||
|
var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
|
||
|
var checkingFuzzySubtypes = false;
|
||
|
for (var i = 0; i < workQueue_1.length; ++i) {
|
||
|
var supertypeSet = workQueue_1[i];
|
||
|
if (supertypeSet.has(supertype)) {
|
||
|
if (!typenameSupertypeSet.has(supertype)) {
|
||
|
if (checkingFuzzySubtypes) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(6, typename, supertype);
|
||
|
}
|
||
|
typenameSupertypeSet.add(supertype);
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
supertypeSet.forEach(maybeEnqueue_1);
|
||
|
if (needToCheckFuzzySubtypes &&
|
||
|
i === workQueue_1.length - 1 &&
|
||
|
selectionSetMatchesResult(fragment.selectionSet, result, variables)) {
|
||
|
needToCheckFuzzySubtypes = false;
|
||
|
checkingFuzzySubtypes = true;
|
||
|
this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {
|
||
|
var match = typename.match(regExp);
|
||
|
if (match && match[0] === typename) {
|
||
|
maybeEnqueue_1(fuzzyString);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
};
|
||
|
Policies.prototype.hasKeyArgs = function (typename, fieldName) {
|
||
|
var policy = this.getFieldPolicy(typename, fieldName, false);
|
||
|
return !!(policy && policy.keyFn);
|
||
|
};
|
||
|
Policies.prototype.getStoreFieldName = function (fieldSpec) {
|
||
|
var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;
|
||
|
var policy = this.getFieldPolicy(typename, fieldName, false);
|
||
|
var storeFieldName;
|
||
|
var keyFn = policy && policy.keyFn;
|
||
|
if (keyFn && typename) {
|
||
|
var context = {
|
||
|
typename: typename,
|
||
|
fieldName: fieldName,
|
||
|
field: fieldSpec.field || null,
|
||
|
variables: fieldSpec.variables,
|
||
|
};
|
||
|
var args = argsFromFieldSpecifier(fieldSpec);
|
||
|
while (keyFn) {
|
||
|
var specifierOrString = keyFn(args, context);
|
||
|
if (isArray(specifierOrString)) {
|
||
|
keyFn = keyArgsFnFromSpecifier(specifierOrString);
|
||
|
}
|
||
|
else {
|
||
|
storeFieldName = specifierOrString || fieldName;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (storeFieldName === void 0) {
|
||
|
storeFieldName =
|
||
|
fieldSpec.field ?
|
||
|
storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)
|
||
|
: getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));
|
||
|
}
|
||
|
if (storeFieldName === false) {
|
||
|
return fieldName;
|
||
|
}
|
||
|
return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName
|
||
|
: fieldName + ":" + storeFieldName;
|
||
|
};
|
||
|
Policies.prototype.readField = function (options, context) {
|
||
|
var objectOrReference = options.from;
|
||
|
if (!objectOrReference)
|
||
|
return;
|
||
|
var nameOrField = options.field || options.fieldName;
|
||
|
if (!nameOrField)
|
||
|
return;
|
||
|
if (options.typename === void 0) {
|
||
|
var typename = context.store.getFieldValue(objectOrReference, "__typename");
|
||
|
if (typename)
|
||
|
options.typename = typename;
|
||
|
}
|
||
|
var storeFieldName = this.getStoreFieldName(options);
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
var existing = context.store.getFieldValue(objectOrReference, storeFieldName);
|
||
|
var policy = this.getFieldPolicy(options.typename, fieldName, false);
|
||
|
var read = policy && policy.read;
|
||
|
if (read) {
|
||
|
var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?
|
||
|
objectOrReference.__ref
|
||
|
: objectOrReference, storeFieldName));
|
||
|
return cacheSlot.withValue(this.cache, read, [
|
||
|
existing,
|
||
|
readOptions,
|
||
|
]);
|
||
|
}
|
||
|
return existing;
|
||
|
};
|
||
|
Policies.prototype.getReadFunction = function (typename, fieldName) {
|
||
|
var policy = this.getFieldPolicy(typename, fieldName, false);
|
||
|
return policy && policy.read;
|
||
|
};
|
||
|
Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
|
||
|
var policy = this.getFieldPolicy(parentTypename, fieldName, false);
|
||
|
var merge = policy && policy.merge;
|
||
|
if (!merge && childTypename) {
|
||
|
policy = this.getTypePolicy(childTypename);
|
||
|
merge = policy && policy.merge;
|
||
|
}
|
||
|
return merge;
|
||
|
};
|
||
|
Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {
|
||
|
var field = _a.field, typename = _a.typename, merge = _a.merge;
|
||
|
if (merge === mergeTrueFn) {
|
||
|
return makeMergeObjectsFunction(context.store)(existing, incoming);
|
||
|
}
|
||
|
if (merge === mergeFalseFn) {
|
||
|
return incoming;
|
||
|
}
|
||
|
if (context.overwrite) {
|
||
|
existing = void 0;
|
||
|
}
|
||
|
return merge(existing, incoming, makeFieldFunctionOptions(this,
|
||
|
void 0, {
|
||
|
typename: typename,
|
||
|
fieldName: field.name.value,
|
||
|
field: field,
|
||
|
variables: context.variables,
|
||
|
}, context, storage || Object.create(null)));
|
||
|
};
|
||
|
return Policies;
|
||
|
}());
|
||
|
function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
|
||
|
var storeFieldName = policies.getStoreFieldName(fieldSpec);
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
var variables = fieldSpec.variables || context.variables;
|
||
|
var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;
|
||
|
return {
|
||
|
args: argsFromFieldSpecifier(fieldSpec),
|
||
|
field: fieldSpec.field || null,
|
||
|
fieldName: fieldName,
|
||
|
storeFieldName: storeFieldName,
|
||
|
variables: variables,
|
||
|
isReference: isReference,
|
||
|
toReference: toReference,
|
||
|
storage: storage,
|
||
|
cache: policies.cache,
|
||
|
canRead: canRead,
|
||
|
readField: function () {
|
||
|
return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);
|
||
|
},
|
||
|
mergeObjects: makeMergeObjectsFunction(context.store),
|
||
|
};
|
||
|
}
|
||
|
function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
|
||
|
var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
|
||
|
var options;
|
||
|
if (typeof fieldNameOrOptions === "string") {
|
||
|
options = {
|
||
|
fieldName: fieldNameOrOptions,
|
||
|
from: argc > 1 ? from : objectOrReference,
|
||
|
};
|
||
|
}
|
||
|
else {
|
||
|
options = tslib.__assign({}, fieldNameOrOptions);
|
||
|
if (!hasOwn.call(options, "from")) {
|
||
|
options.from = objectOrReference;
|
||
|
}
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false && options.from === void 0) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(7, stringifyForDisplay(Array.from(readFieldArgs)));
|
||
|
}
|
||
|
if (void 0 === options.variables) {
|
||
|
options.variables = variables;
|
||
|
}
|
||
|
return options;
|
||
|
}
|
||
|
function makeMergeObjectsFunction(store) {
|
||
|
return function mergeObjects(existing, incoming) {
|
||
|
if (isArray(existing) || isArray(incoming)) {
|
||
|
throw newInvariantError(8);
|
||
|
}
|
||
|
if (isNonNullObject(existing) && isNonNullObject(incoming)) {
|
||
|
var eType = store.getFieldValue(existing, "__typename");
|
||
|
var iType = store.getFieldValue(incoming, "__typename");
|
||
|
var typesDiffer = eType && iType && eType !== iType;
|
||
|
if (typesDiffer) {
|
||
|
return incoming;
|
||
|
}
|
||
|
if (isReference(existing) && storeValueIsStoreObject(incoming)) {
|
||
|
store.merge(existing.__ref, incoming);
|
||
|
return existing;
|
||
|
}
|
||
|
if (storeValueIsStoreObject(existing) && isReference(incoming)) {
|
||
|
store.merge(existing, incoming.__ref);
|
||
|
return incoming;
|
||
|
}
|
||
|
if (storeValueIsStoreObject(existing) &&
|
||
|
storeValueIsStoreObject(incoming)) {
|
||
|
return tslib.__assign(tslib.__assign({}, existing), incoming);
|
||
|
}
|
||
|
}
|
||
|
return incoming;
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function getContextFlavor(context, clientOnly, deferred) {
|
||
|
var key = "".concat(clientOnly).concat(deferred);
|
||
|
var flavored = context.flavors.get(key);
|
||
|
if (!flavored) {
|
||
|
context.flavors.set(key, (flavored =
|
||
|
context.clientOnly === clientOnly && context.deferred === deferred ?
|
||
|
context
|
||
|
: tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));
|
||
|
}
|
||
|
return flavored;
|
||
|
}
|
||
|
var StoreWriter = (function () {
|
||
|
function StoreWriter(cache, reader, fragments) {
|
||
|
this.cache = cache;
|
||
|
this.reader = reader;
|
||
|
this.fragments = fragments;
|
||
|
}
|
||
|
StoreWriter.prototype.writeToStore = function (store, _a) {
|
||
|
var _this = this;
|
||
|
var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
|
||
|
var operationDefinition = getOperationDefinition(query);
|
||
|
var merger = makeProcessedFieldsMerger();
|
||
|
variables = tslib.__assign(tslib.__assign({}, getDefaultValues(operationDefinition)), variables);
|
||
|
var context = tslib.__assign(tslib.__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {
|
||
|
return merger.merge(existing, incoming);
|
||
|
}, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });
|
||
|
var ref = this.processSelectionSet({
|
||
|
result: result || Object.create(null),
|
||
|
dataId: dataId,
|
||
|
selectionSet: operationDefinition.selectionSet,
|
||
|
mergeTree: { map: new Map() },
|
||
|
context: context,
|
||
|
});
|
||
|
if (!isReference(ref)) {
|
||
|
throw newInvariantError(11, result);
|
||
|
}
|
||
|
context.incomingById.forEach(function (_a, dataId) {
|
||
|
var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
|
||
|
var entityRef = makeReference(dataId);
|
||
|
if (mergeTree && mergeTree.map.size) {
|
||
|
var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
|
||
|
if (isReference(applied)) {
|
||
|
return;
|
||
|
}
|
||
|
storeObject = applied;
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false && !context.overwrite) {
|
||
|
var fieldsWithSelectionSets_1 = Object.create(null);
|
||
|
fieldNodeSet.forEach(function (field) {
|
||
|
if (field.selectionSet) {
|
||
|
fieldsWithSelectionSets_1[field.name.value] = true;
|
||
|
}
|
||
|
});
|
||
|
var hasSelectionSet_1 = function (storeFieldName) {
|
||
|
return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===
|
||
|
true;
|
||
|
};
|
||
|
var hasMergeFunction_1 = function (storeFieldName) {
|
||
|
var childTree = mergeTree && mergeTree.map.get(storeFieldName);
|
||
|
return Boolean(childTree && childTree.info && childTree.info.merge);
|
||
|
};
|
||
|
Object.keys(storeObject).forEach(function (storeFieldName) {
|
||
|
if (hasSelectionSet_1(storeFieldName) &&
|
||
|
!hasMergeFunction_1(storeFieldName)) {
|
||
|
warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
store.merge(dataId, storeObject);
|
||
|
});
|
||
|
store.retain(ref.__ref);
|
||
|
return ref;
|
||
|
};
|
||
|
StoreWriter.prototype.processSelectionSet = function (_a) {
|
||
|
var _this = this;
|
||
|
var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context,
|
||
|
mergeTree = _a.mergeTree;
|
||
|
var policies = this.cache.policies;
|
||
|
var incoming = Object.create(null);
|
||
|
var typename = (dataId && policies.rootTypenamesById[dataId]) ||
|
||
|
getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
|
||
|
(dataId && context.store.get(dataId, "__typename"));
|
||
|
if ("string" === typeof typename) {
|
||
|
incoming.__typename = typename;
|
||
|
}
|
||
|
var readField = function () {
|
||
|
var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
|
||
|
if (isReference(options.from)) {
|
||
|
var info = context.incomingById.get(options.from.__ref);
|
||
|
if (info) {
|
||
|
var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);
|
||
|
if (result_1 !== void 0) {
|
||
|
return result_1;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return policies.readField(options, context);
|
||
|
};
|
||
|
var fieldNodeSet = new Set();
|
||
|
this.flattenFields(selectionSet, result,
|
||
|
context, typename).forEach(function (context, field) {
|
||
|
var _a;
|
||
|
var resultFieldKey = resultKeyNameFromField(field);
|
||
|
var value = result[resultFieldKey];
|
||
|
fieldNodeSet.add(field);
|
||
|
if (value !== void 0) {
|
||
|
var storeFieldName = policies.getStoreFieldName({
|
||
|
typename: typename,
|
||
|
fieldName: field.name.value,
|
||
|
field: field,
|
||
|
variables: context.variables,
|
||
|
});
|
||
|
var childTree = getChildMergeTree(mergeTree, storeFieldName);
|
||
|
var incomingValue = _this.processFieldValue(value, field,
|
||
|
field.selectionSet ?
|
||
|
getContextFlavor(context, false, false)
|
||
|
: context, childTree);
|
||
|
var childTypename = void 0;
|
||
|
if (field.selectionSet &&
|
||
|
(isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {
|
||
|
childTypename = readField("__typename", incomingValue);
|
||
|
}
|
||
|
var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
|
||
|
if (merge) {
|
||
|
childTree.info = {
|
||
|
field: field,
|
||
|
typename: typename,
|
||
|
merge: merge,
|
||
|
};
|
||
|
}
|
||
|
else {
|
||
|
maybeRecycleChildMergeTree(mergeTree, storeFieldName);
|
||
|
}
|
||
|
incoming = context.merge(incoming, (_a = {},
|
||
|
_a[storeFieldName] = incomingValue,
|
||
|
_a));
|
||
|
}
|
||
|
else if (globalThis.__DEV__ !== false &&
|
||
|
!context.clientOnly &&
|
||
|
!context.deferred &&
|
||
|
!addTypenameToDocument.added(field) &&
|
||
|
!policies.getReadFunction(typename, field.name.value)) {
|
||
|
globalThis.__DEV__ !== false && invariant.error(12, resultKeyNameFromField(field), result);
|
||
|
}
|
||
|
});
|
||
|
try {
|
||
|
var _b = policies.identify(result, {
|
||
|
typename: typename,
|
||
|
selectionSet: selectionSet,
|
||
|
fragmentMap: context.fragmentMap,
|
||
|
storeObject: incoming,
|
||
|
readField: readField,
|
||
|
}), id = _b[0], keyObject = _b[1];
|
||
|
dataId = dataId || id;
|
||
|
if (keyObject) {
|
||
|
incoming = context.merge(incoming, keyObject);
|
||
|
}
|
||
|
}
|
||
|
catch (e) {
|
||
|
if (!dataId)
|
||
|
throw e;
|
||
|
}
|
||
|
if ("string" === typeof dataId) {
|
||
|
var dataRef = makeReference(dataId);
|
||
|
var sets = context.written[dataId] || (context.written[dataId] = []);
|
||
|
if (sets.indexOf(selectionSet) >= 0)
|
||
|
return dataRef;
|
||
|
sets.push(selectionSet);
|
||
|
if (this.reader &&
|
||
|
this.reader.isFresh(result, dataRef, selectionSet, context)) {
|
||
|
return dataRef;
|
||
|
}
|
||
|
var previous_1 = context.incomingById.get(dataId);
|
||
|
if (previous_1) {
|
||
|
previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
|
||
|
previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
|
||
|
fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
|
||
|
}
|
||
|
else {
|
||
|
context.incomingById.set(dataId, {
|
||
|
storeObject: incoming,
|
||
|
mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
|
||
|
fieldNodeSet: fieldNodeSet,
|
||
|
});
|
||
|
}
|
||
|
return dataRef;
|
||
|
}
|
||
|
return incoming;
|
||
|
};
|
||
|
StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
|
||
|
var _this = this;
|
||
|
if (!field.selectionSet || value === null) {
|
||
|
return globalThis.__DEV__ !== false ? cloneDeep(value) : value;
|
||
|
}
|
||
|
if (isArray(value)) {
|
||
|
return value.map(function (item, i) {
|
||
|
var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
|
||
|
maybeRecycleChildMergeTree(mergeTree, i);
|
||
|
return value;
|
||
|
});
|
||
|
}
|
||
|
return this.processSelectionSet({
|
||
|
result: value,
|
||
|
selectionSet: field.selectionSet,
|
||
|
context: context,
|
||
|
mergeTree: mergeTree,
|
||
|
});
|
||
|
};
|
||
|
StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
|
||
|
if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }
|
||
|
var fieldMap = new Map();
|
||
|
var policies = this.cache.policies;
|
||
|
var limitingTrie = new trie.Trie(false);
|
||
|
(function flatten(selectionSet, inheritedContext) {
|
||
|
var visitedNode = limitingTrie.lookup(selectionSet,
|
||
|
inheritedContext.clientOnly, inheritedContext.deferred);
|
||
|
if (visitedNode.visited)
|
||
|
return;
|
||
|
visitedNode.visited = true;
|
||
|
selectionSet.selections.forEach(function (selection) {
|
||
|
if (!shouldInclude(selection, context.variables))
|
||
|
return;
|
||
|
var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
|
||
|
if (
|
||
|
!(clientOnly && deferred) &&
|
||
|
isNonEmptyArray(selection.directives)) {
|
||
|
selection.directives.forEach(function (dir) {
|
||
|
var name = dir.name.value;
|
||
|
if (name === "client")
|
||
|
clientOnly = true;
|
||
|
if (name === "defer") {
|
||
|
var args = argumentsObjectFromField(dir, context.variables);
|
||
|
if (!args || args.if !== false) {
|
||
|
deferred = true;
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
if (isField(selection)) {
|
||
|
var existing = fieldMap.get(selection);
|
||
|
if (existing) {
|
||
|
clientOnly = clientOnly && existing.clientOnly;
|
||
|
deferred = deferred && existing.deferred;
|
||
|
}
|
||
|
fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
|
||
|
}
|
||
|
else {
|
||
|
var fragment = getFragmentFromSelection(selection, context.lookupFragment);
|
||
|
if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
|
||
|
throw newInvariantError(13, selection.name.value);
|
||
|
}
|
||
|
if (fragment &&
|
||
|
policies.fragmentMatches(fragment, typename, result, context.variables)) {
|
||
|
flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
})(selectionSet, context);
|
||
|
return fieldMap;
|
||
|
};
|
||
|
StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
|
||
|
var _a;
|
||
|
var _this = this;
|
||
|
if (mergeTree.map.size && !isReference(incoming)) {
|
||
|
var e_1 =
|
||
|
(!isArray(incoming) &&
|
||
|
(isReference(existing) || storeValueIsStoreObject(existing))) ?
|
||
|
existing
|
||
|
: void 0;
|
||
|
var i_1 = incoming;
|
||
|
if (e_1 && !getStorageArgs) {
|
||
|
getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];
|
||
|
}
|
||
|
var changedFields_1;
|
||
|
var getValue_1 = function (from, name) {
|
||
|
return (isArray(from) ?
|
||
|
typeof name === "number" ?
|
||
|
from[name]
|
||
|
: void 0
|
||
|
: context.store.getFieldValue(from, String(name)));
|
||
|
};
|
||
|
mergeTree.map.forEach(function (childTree, storeFieldName) {
|
||
|
var eVal = getValue_1(e_1, storeFieldName);
|
||
|
var iVal = getValue_1(i_1, storeFieldName);
|
||
|
if (void 0 === iVal)
|
||
|
return;
|
||
|
if (getStorageArgs) {
|
||
|
getStorageArgs.push(storeFieldName);
|
||
|
}
|
||
|
var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
|
||
|
if (aVal !== iVal) {
|
||
|
changedFields_1 = changedFields_1 || new Map();
|
||
|
changedFields_1.set(storeFieldName, aVal);
|
||
|
}
|
||
|
if (getStorageArgs) {
|
||
|
invariant(getStorageArgs.pop() === storeFieldName);
|
||
|
}
|
||
|
});
|
||
|
if (changedFields_1) {
|
||
|
incoming = (isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
|
||
|
changedFields_1.forEach(function (value, name) {
|
||
|
incoming[name] = value;
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
if (mergeTree.info) {
|
||
|
return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
|
||
|
}
|
||
|
return incoming;
|
||
|
};
|
||
|
return StoreWriter;
|
||
|
}());
|
||
|
var emptyMergeTreePool = [];
|
||
|
function getChildMergeTree(_a, name) {
|
||
|
var map = _a.map;
|
||
|
if (!map.has(name)) {
|
||
|
map.set(name, emptyMergeTreePool.pop() || { map: new Map() });
|
||
|
}
|
||
|
return map.get(name);
|
||
|
}
|
||
|
function mergeMergeTrees(left, right) {
|
||
|
if (left === right || !right || mergeTreeIsEmpty(right))
|
||
|
return left;
|
||
|
if (!left || mergeTreeIsEmpty(left))
|
||
|
return right;
|
||
|
var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
|
||
|
var needToMergeMaps = left.map.size && right.map.size;
|
||
|
var map = needToMergeMaps ? new Map()
|
||
|
: left.map.size ? left.map
|
||
|
: right.map;
|
||
|
var merged = { info: info, map: map };
|
||
|
if (needToMergeMaps) {
|
||
|
var remainingRightKeys_1 = new Set(right.map.keys());
|
||
|
left.map.forEach(function (leftTree, key) {
|
||
|
merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
|
||
|
remainingRightKeys_1.delete(key);
|
||
|
});
|
||
|
remainingRightKeys_1.forEach(function (key) {
|
||
|
merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
|
||
|
});
|
||
|
}
|
||
|
return merged;
|
||
|
}
|
||
|
function mergeTreeIsEmpty(tree) {
|
||
|
return !tree || !(tree.info || tree.map.size);
|
||
|
}
|
||
|
function maybeRecycleChildMergeTree(_a, name) {
|
||
|
var map = _a.map;
|
||
|
var childTree = map.get(name);
|
||
|
if (childTree && mergeTreeIsEmpty(childTree)) {
|
||
|
emptyMergeTreePool.push(childTree);
|
||
|
map.delete(name);
|
||
|
}
|
||
|
}
|
||
|
var warnings = new Set();
|
||
|
function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
|
||
|
var getChild = function (objOrRef) {
|
||
|
var child = store.getFieldValue(objOrRef, storeFieldName);
|
||
|
return typeof child === "object" && child;
|
||
|
};
|
||
|
var existing = getChild(existingRef);
|
||
|
if (!existing)
|
||
|
return;
|
||
|
var incoming = getChild(incomingObj);
|
||
|
if (!incoming)
|
||
|
return;
|
||
|
if (isReference(existing))
|
||
|
return;
|
||
|
if (equal.equal(existing, incoming))
|
||
|
return;
|
||
|
if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
|
||
|
return;
|
||
|
}
|
||
|
var parentType = store.getFieldValue(existingRef, "__typename") ||
|
||
|
store.getFieldValue(incomingObj, "__typename");
|
||
|
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||
|
var typeDotName = "".concat(parentType, ".").concat(fieldName);
|
||
|
if (warnings.has(typeDotName))
|
||
|
return;
|
||
|
warnings.add(typeDotName);
|
||
|
var childTypenames = [];
|
||
|
if (!isArray(existing) && !isArray(incoming)) {
|
||
|
[existing, incoming].forEach(function (child) {
|
||
|
var typename = store.getFieldValue(child, "__typename");
|
||
|
if (typeof typename === "string" && !childTypenames.includes(typename)) {
|
||
|
childTypenames.push(typename);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
globalThis.__DEV__ !== false && invariant.warn(14, fieldName, parentType, childTypenames.length ?
|
||
|
"either ensure all objects of type " +
|
||
|
childTypenames.join(" and ") +
|
||
|
" have an ID or a custom merge function, or "
|
||
|
: "", typeDotName, existing, incoming);
|
||
|
}
|
||
|
|
||
|
var InMemoryCache = (function (_super) {
|
||
|
tslib.__extends(InMemoryCache, _super);
|
||
|
function InMemoryCache(config) {
|
||
|
if (config === void 0) { config = {}; }
|
||
|
var _this = _super.call(this) || this;
|
||
|
_this.watches = new Set();
|
||
|
_this.addTypenameTransform = new DocumentTransform(addTypenameToDocument);
|
||
|
_this.assumeImmutableResults = true;
|
||
|
_this.makeVar = makeVar;
|
||
|
_this.txCount = 0;
|
||
|
_this.config = normalizeConfig(config);
|
||
|
_this.addTypename = !!_this.config.addTypename;
|
||
|
_this.policies = new Policies({
|
||
|
cache: _this,
|
||
|
dataIdFromObject: _this.config.dataIdFromObject,
|
||
|
possibleTypes: _this.config.possibleTypes,
|
||
|
typePolicies: _this.config.typePolicies,
|
||
|
});
|
||
|
_this.init();
|
||
|
return _this;
|
||
|
}
|
||
|
InMemoryCache.prototype.init = function () {
|
||
|
var rootStore = (this.data = new EntityStore.Root({
|
||
|
policies: this.policies,
|
||
|
resultCaching: this.config.resultCaching,
|
||
|
}));
|
||
|
this.optimisticData = rootStore.stump;
|
||
|
this.resetResultCache();
|
||
|
};
|
||
|
InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
|
||
|
var _this = this;
|
||
|
var previousReader = this.storeReader;
|
||
|
var fragments = this.config.fragments;
|
||
|
this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({
|
||
|
cache: this,
|
||
|
addTypename: this.addTypename,
|
||
|
resultCacheMaxSize: this.config.resultCacheMaxSize,
|
||
|
canonizeResults: shouldCanonizeResults(this.config),
|
||
|
canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),
|
||
|
fragments: fragments,
|
||
|
})), fragments);
|
||
|
this.maybeBroadcastWatch = optimism.wrap(function (c, options) {
|
||
|
return _this.broadcastWatch(c, options);
|
||
|
}, {
|
||
|
max: this.config.resultCacheMaxSize ||
|
||
|
cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
|
||
|
5000 ,
|
||
|
makeCacheKey: function (c) {
|
||
|
var store = c.optimistic ? _this.optimisticData : _this.data;
|
||
|
if (supportsResultCaching(store)) {
|
||
|
var optimistic = c.optimistic, id = c.id, variables = c.variables;
|
||
|
return store.makeCacheKey(c.query,
|
||
|
c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {
|
||
|
return group.resetCaching();
|
||
|
});
|
||
|
};
|
||
|
InMemoryCache.prototype.restore = function (data) {
|
||
|
this.init();
|
||
|
if (data)
|
||
|
this.data.replace(data);
|
||
|
return this;
|
||
|
};
|
||
|
InMemoryCache.prototype.extract = function (optimistic) {
|
||
|
if (optimistic === void 0) { optimistic = false; }
|
||
|
return (optimistic ? this.optimisticData : this.data).extract();
|
||
|
};
|
||
|
InMemoryCache.prototype.read = function (options) {
|
||
|
var
|
||
|
_a = options.returnPartialData,
|
||
|
returnPartialData = _a === void 0 ? false : _a;
|
||
|
try {
|
||
|
return (this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);
|
||
|
}
|
||
|
catch (e) {
|
||
|
if (e instanceof MissingFieldError) {
|
||
|
return null;
|
||
|
}
|
||
|
throw e;
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.write = function (options) {
|
||
|
try {
|
||
|
++this.txCount;
|
||
|
return this.storeWriter.writeToStore(this.data, options);
|
||
|
}
|
||
|
finally {
|
||
|
if (!--this.txCount && options.broadcast !== false) {
|
||
|
this.broadcastWatches();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.modify = function (options) {
|
||
|
if (hasOwn.call(options, "id") && !options.id) {
|
||
|
return false;
|
||
|
}
|
||
|
var store = ((options.optimistic)
|
||
|
) ?
|
||
|
this.optimisticData
|
||
|
: this.data;
|
||
|
try {
|
||
|
++this.txCount;
|
||
|
return store.modify(options.id || "ROOT_QUERY", options.fields);
|
||
|
}
|
||
|
finally {
|
||
|
if (!--this.txCount && options.broadcast !== false) {
|
||
|
this.broadcastWatches();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.diff = function (options) {
|
||
|
return this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || "ROOT_QUERY", config: this.config }));
|
||
|
};
|
||
|
InMemoryCache.prototype.watch = function (watch) {
|
||
|
var _this = this;
|
||
|
if (!this.watches.size) {
|
||
|
recallCache(this);
|
||
|
}
|
||
|
this.watches.add(watch);
|
||
|
if (watch.immediate) {
|
||
|
this.maybeBroadcastWatch(watch);
|
||
|
}
|
||
|
return function () {
|
||
|
if (_this.watches.delete(watch) && !_this.watches.size) {
|
||
|
forgetCache(_this);
|
||
|
}
|
||
|
_this.maybeBroadcastWatch.forget(watch);
|
||
|
};
|
||
|
};
|
||
|
InMemoryCache.prototype.gc = function (options) {
|
||
|
var _a;
|
||
|
canonicalStringify.reset();
|
||
|
print.reset();
|
||
|
this.addTypenameTransform.resetCache();
|
||
|
(_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();
|
||
|
var ids = this.optimisticData.gc();
|
||
|
if (options && !this.txCount) {
|
||
|
if (options.resetResultCache) {
|
||
|
this.resetResultCache(options.resetResultIdentities);
|
||
|
}
|
||
|
else if (options.resetResultIdentities) {
|
||
|
this.storeReader.resetCanon();
|
||
|
}
|
||
|
}
|
||
|
return ids;
|
||
|
};
|
||
|
InMemoryCache.prototype.retain = function (rootId, optimistic) {
|
||
|
return (optimistic ? this.optimisticData : this.data).retain(rootId);
|
||
|
};
|
||
|
InMemoryCache.prototype.release = function (rootId, optimistic) {
|
||
|
return (optimistic ? this.optimisticData : this.data).release(rootId);
|
||
|
};
|
||
|
InMemoryCache.prototype.identify = function (object) {
|
||
|
if (isReference(object))
|
||
|
return object.__ref;
|
||
|
try {
|
||
|
return this.policies.identify(object)[0];
|
||
|
}
|
||
|
catch (e) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(e);
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.evict = function (options) {
|
||
|
if (!options.id) {
|
||
|
if (hasOwn.call(options, "id")) {
|
||
|
return false;
|
||
|
}
|
||
|
options = tslib.__assign(tslib.__assign({}, options), { id: "ROOT_QUERY" });
|
||
|
}
|
||
|
try {
|
||
|
++this.txCount;
|
||
|
return this.optimisticData.evict(options, this.data);
|
||
|
}
|
||
|
finally {
|
||
|
if (!--this.txCount && options.broadcast !== false) {
|
||
|
this.broadcastWatches();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.reset = function (options) {
|
||
|
var _this = this;
|
||
|
this.init();
|
||
|
canonicalStringify.reset();
|
||
|
if (options && options.discardWatches) {
|
||
|
this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
|
||
|
this.watches.clear();
|
||
|
forgetCache(this);
|
||
|
}
|
||
|
else {
|
||
|
this.broadcastWatches();
|
||
|
}
|
||
|
return Promise.resolve();
|
||
|
};
|
||
|
InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
|
||
|
var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
|
||
|
if (newOptimisticData !== this.optimisticData) {
|
||
|
this.optimisticData = newOptimisticData;
|
||
|
this.broadcastWatches();
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.batch = function (options) {
|
||
|
var _this = this;
|
||
|
var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
|
||
|
var updateResult;
|
||
|
var perform = function (layer) {
|
||
|
var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
|
||
|
++_this.txCount;
|
||
|
if (layer) {
|
||
|
_this.data = _this.optimisticData = layer;
|
||
|
}
|
||
|
try {
|
||
|
return (updateResult = update(_this));
|
||
|
}
|
||
|
finally {
|
||
|
--_this.txCount;
|
||
|
_this.data = data;
|
||
|
_this.optimisticData = optimisticData;
|
||
|
}
|
||
|
};
|
||
|
var alreadyDirty = new Set();
|
||
|
if (onWatchUpdated && !this.txCount) {
|
||
|
this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch) {
|
||
|
alreadyDirty.add(watch);
|
||
|
return false;
|
||
|
} }));
|
||
|
}
|
||
|
if (typeof optimistic === "string") {
|
||
|
this.optimisticData = this.optimisticData.addLayer(optimistic, perform);
|
||
|
}
|
||
|
else if (optimistic === false) {
|
||
|
perform(this.data);
|
||
|
}
|
||
|
else {
|
||
|
perform();
|
||
|
}
|
||
|
if (typeof removeOptimistic === "string") {
|
||
|
this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);
|
||
|
}
|
||
|
if (onWatchUpdated && alreadyDirty.size) {
|
||
|
this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch, diff) {
|
||
|
var result = onWatchUpdated.call(this, watch, diff);
|
||
|
if (result !== false) {
|
||
|
alreadyDirty.delete(watch);
|
||
|
}
|
||
|
return result;
|
||
|
} }));
|
||
|
if (alreadyDirty.size) {
|
||
|
alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
this.broadcastWatches(options);
|
||
|
}
|
||
|
return updateResult;
|
||
|
};
|
||
|
InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
|
||
|
return this.batch({
|
||
|
update: update,
|
||
|
optimistic: optimisticId || optimisticId !== null,
|
||
|
});
|
||
|
};
|
||
|
InMemoryCache.prototype.transformDocument = function (document) {
|
||
|
return this.addTypenameToDocument(this.addFragmentsToDocument(document));
|
||
|
};
|
||
|
InMemoryCache.prototype.broadcastWatches = function (options) {
|
||
|
var _this = this;
|
||
|
if (!this.txCount) {
|
||
|
this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
|
||
|
}
|
||
|
};
|
||
|
InMemoryCache.prototype.addFragmentsToDocument = function (document) {
|
||
|
var fragments = this.config.fragments;
|
||
|
return fragments ? fragments.transform(document) : document;
|
||
|
};
|
||
|
InMemoryCache.prototype.addTypenameToDocument = function (document) {
|
||
|
if (this.addTypename) {
|
||
|
return this.addTypenameTransform.transformDocument(document);
|
||
|
}
|
||
|
return document;
|
||
|
};
|
||
|
InMemoryCache.prototype.broadcastWatch = function (c, options) {
|
||
|
var lastDiff = c.lastDiff;
|
||
|
var diff = this.diff(c);
|
||
|
if (options) {
|
||
|
if (c.optimistic && typeof options.optimistic === "string") {
|
||
|
diff.fromOptimisticTransaction = true;
|
||
|
}
|
||
|
if (options.onWatchUpdated &&
|
||
|
options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
if (!lastDiff || !equal.equal(lastDiff.result, diff.result)) {
|
||
|
c.callback((c.lastDiff = diff), lastDiff);
|
||
|
}
|
||
|
};
|
||
|
return InMemoryCache;
|
||
|
}(ApolloCache));
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;
|
||
|
}
|
||
|
|
||
|
exports.NetworkStatus = void 0;
|
||
|
(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";
|
||
|
})(exports.NetworkStatus || (exports.NetworkStatus = {}));
|
||
|
function isNetworkRequestInFlight(networkStatus) {
|
||
|
return networkStatus ? networkStatus < 7 : false;
|
||
|
}
|
||
|
function isNetworkRequestSettled(networkStatus) {
|
||
|
return networkStatus === 7 || networkStatus === 8;
|
||
|
}
|
||
|
|
||
|
function equalByQuery(query, _a, _b, variables) {
|
||
|
var aData = _a.data, aRest = tslib.__rest(_a, ["data"]);
|
||
|
var bData = _b.data, bRest = tslib.__rest(_b, ["data"]);
|
||
|
return (equal__default(aRest, bRest) &&
|
||
|
equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {
|
||
|
fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
|
||
|
variables: variables,
|
||
|
}));
|
||
|
}
|
||
|
function equalBySelectionSet(selectionSet, aResult, bResult, context) {
|
||
|
if (aResult === bResult) {
|
||
|
return true;
|
||
|
}
|
||
|
var seenSelections = new Set();
|
||
|
return selectionSet.selections.every(function (selection) {
|
||
|
if (seenSelections.has(selection))
|
||
|
return true;
|
||
|
seenSelections.add(selection);
|
||
|
if (!shouldInclude(selection, context.variables))
|
||
|
return true;
|
||
|
if (selectionHasNonreactiveDirective(selection))
|
||
|
return true;
|
||
|
if (isField(selection)) {
|
||
|
var resultKey = resultKeyNameFromField(selection);
|
||
|
var aResultChild = aResult && aResult[resultKey];
|
||
|
var bResultChild = bResult && bResult[resultKey];
|
||
|
var childSelectionSet = selection.selectionSet;
|
||
|
if (!childSelectionSet) {
|
||
|
return equal__default(aResultChild, bResultChild);
|
||
|
}
|
||
|
var aChildIsArray = Array.isArray(aResultChild);
|
||
|
var bChildIsArray = Array.isArray(bResultChild);
|
||
|
if (aChildIsArray !== bChildIsArray)
|
||
|
return false;
|
||
|
if (aChildIsArray && bChildIsArray) {
|
||
|
var length_1 = aResultChild.length;
|
||
|
if (bResultChild.length !== length_1) {
|
||
|
return false;
|
||
|
}
|
||
|
for (var i = 0; i < length_1; ++i) {
|
||
|
if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);
|
||
|
}
|
||
|
else {
|
||
|
var fragment = getFragmentFromSelection(selection, context.fragmentMap);
|
||
|
if (fragment) {
|
||
|
if (selectionHasNonreactiveDirective(fragment))
|
||
|
return true;
|
||
|
return equalBySelectionSet(fragment.selectionSet,
|
||
|
aResult, bResult, context);
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
function selectionHasNonreactiveDirective(selection) {
|
||
|
return (!!selection.directives && selection.directives.some(directiveIsNonreactive));
|
||
|
}
|
||
|
function directiveIsNonreactive(dir) {
|
||
|
return dir.name.value === "nonreactive";
|
||
|
}
|
||
|
|
||
|
var assign = Object.assign, hasOwnProperty$2 = Object.hasOwnProperty;
|
||
|
var ObservableQuery = (function (_super) {
|
||
|
tslib.__extends(ObservableQuery, _super);
|
||
|
function ObservableQuery(_a) {
|
||
|
var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;
|
||
|
var _this = _super.call(this, function (observer) {
|
||
|
try {
|
||
|
var subObserver = observer._subscription._observer;
|
||
|
if (subObserver && !subObserver.error) {
|
||
|
subObserver.error = defaultSubscriptionObserverErrorCallback;
|
||
|
}
|
||
|
}
|
||
|
catch (_a) { }
|
||
|
var first = !_this.observers.size;
|
||
|
_this.observers.add(observer);
|
||
|
var last = _this.last;
|
||
|
if (last && last.error) {
|
||
|
observer.error && observer.error(last.error);
|
||
|
}
|
||
|
else if (last && last.result) {
|
||
|
observer.next && observer.next(last.result);
|
||
|
}
|
||
|
if (first) {
|
||
|
_this.reobserve().catch(function () { });
|
||
|
}
|
||
|
return function () {
|
||
|
if (_this.observers.delete(observer) && !_this.observers.size) {
|
||
|
_this.tearDownQuery();
|
||
|
}
|
||
|
};
|
||
|
}) || this;
|
||
|
_this.observers = new Set();
|
||
|
_this.subscriptions = new Set();
|
||
|
_this.queryInfo = queryInfo;
|
||
|
_this.queryManager = queryManager;
|
||
|
_this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
|
||
|
_this.isTornDown = false;
|
||
|
var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? "cache-first" : _d;
|
||
|
var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e,
|
||
|
_f = options.initialFetchPolicy,
|
||
|
initialFetchPolicy = _f === void 0 ? fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy) : _f;
|
||
|
_this.options = tslib.__assign(tslib.__assign({}, options), {
|
||
|
initialFetchPolicy: initialFetchPolicy,
|
||
|
fetchPolicy: fetchPolicy });
|
||
|
_this.queryId = queryInfo.queryId || queryManager.generateQueryId();
|
||
|
var opDef = getOperationDefinition(_this.query);
|
||
|
_this.queryName = opDef && opDef.name && opDef.name.value;
|
||
|
return _this;
|
||
|
}
|
||
|
Object.defineProperty(ObservableQuery.prototype, "query", {
|
||
|
get: function () {
|
||
|
return this.lastQuery || this.options.query;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
Object.defineProperty(ObservableQuery.prototype, "variables", {
|
||
|
get: function () {
|
||
|
return this.options.variables;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
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.resetDiff = function () {
|
||
|
this.queryInfo.resetDiff();
|
||
|
};
|
||
|
ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {
|
||
|
if (saveAsLastResult === void 0) { saveAsLastResult = true; }
|
||
|
var lastResult = this.getLastResult(true);
|
||
|
var networkStatus = this.queryInfo.networkStatus ||
|
||
|
(lastResult && lastResult.networkStatus) ||
|
||
|
exports.NetworkStatus.ready;
|
||
|
var result = tslib.__assign(tslib.__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
|
||
|
var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
|
||
|
if (
|
||
|
skipCacheDataFor(fetchPolicy) ||
|
||
|
this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) ;
|
||
|
else if (this.waitForOwnResult) {
|
||
|
this.queryInfo["updateWatch"]();
|
||
|
}
|
||
|
else {
|
||
|
var diff = this.queryInfo.getDiff();
|
||
|
if (diff.complete || this.options.returnPartialData) {
|
||
|
result.data = diff.result;
|
||
|
}
|
||
|
if (equal.equal(result.data, {})) {
|
||
|
result.data = void 0;
|
||
|
}
|
||
|
if (diff.complete) {
|
||
|
delete result.partial;
|
||
|
if (diff.complete &&
|
||
|
result.networkStatus === exports.NetworkStatus.loading &&
|
||
|
(fetchPolicy === "cache-first" || fetchPolicy === "cache-only")) {
|
||
|
result.networkStatus = exports.NetworkStatus.ready;
|
||
|
result.loading = false;
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
result.partial = true;
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false &&
|
||
|
!diff.complete &&
|
||
|
!this.options.partialRefetch &&
|
||
|
!result.loading &&
|
||
|
!result.data &&
|
||
|
!result.error) {
|
||
|
logMissingFieldErrors(diff.missing);
|
||
|
}
|
||
|
}
|
||
|
if (saveAsLastResult) {
|
||
|
this.updateLastResult(result);
|
||
|
}
|
||
|
return result;
|
||
|
};
|
||
|
ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
|
||
|
if (!this.last) {
|
||
|
return true;
|
||
|
}
|
||
|
var resultIsDifferent = this.queryManager.getDocumentInfo(this.query).hasNonreactiveDirective ?
|
||
|
!equalByQuery(this.query, this.last.result, newResult, this.variables)
|
||
|
: !equal.equal(this.last.result, newResult);
|
||
|
return (resultIsDifferent || (variables && !equal.equal(this.last.variables, variables)));
|
||
|
};
|
||
|
ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
|
||
|
var last = this.last;
|
||
|
if (last &&
|
||
|
last[key] &&
|
||
|
(!variablesMustMatch || equal.equal(last.variables, this.variables))) {
|
||
|
return last[key];
|
||
|
}
|
||
|
};
|
||
|
ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {
|
||
|
return this.getLast("result", variablesMustMatch);
|
||
|
};
|
||
|
ObservableQuery.prototype.getLastError = function (variablesMustMatch) {
|
||
|
return this.getLast("error", variablesMustMatch);
|
||
|
};
|
||
|
ObservableQuery.prototype.resetLastResults = function () {
|
||
|
delete this.last;
|
||
|
this.isTornDown = false;
|
||
|
};
|
||
|
ObservableQuery.prototype.resetQueryStoreErrors = function () {
|
||
|
this.queryManager.resetErrors(this.queryId);
|
||
|
};
|
||
|
ObservableQuery.prototype.refetch = function (variables) {
|
||
|
var _a;
|
||
|
var reobserveOptions = {
|
||
|
pollInterval: 0,
|
||
|
};
|
||
|
var fetchPolicy = this.options.fetchPolicy;
|
||
|
if (fetchPolicy === "cache-and-network") {
|
||
|
reobserveOptions.fetchPolicy = fetchPolicy;
|
||
|
}
|
||
|
else if (fetchPolicy === "no-cache") {
|
||
|
reobserveOptions.fetchPolicy = "no-cache";
|
||
|
}
|
||
|
else {
|
||
|
reobserveOptions.fetchPolicy = "network-only";
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false && variables && hasOwnProperty$2.call(variables, "variables")) {
|
||
|
var queryDef = getQueryDefinition(this.query);
|
||
|
var vars = queryDef.variableDefinitions;
|
||
|
if (!vars || !vars.some(function (v) { return v.variable.name.value === "variables"; })) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(
|
||
|
20,
|
||
|
variables,
|
||
|
((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
if (variables && !equal.equal(this.options.variables, variables)) {
|
||
|
reobserveOptions.variables = this.options.variables = tslib.__assign(tslib.__assign({}, this.options.variables), variables);
|
||
|
}
|
||
|
this.queryInfo.resetLastWrite();
|
||
|
return this.reobserve(reobserveOptions, exports.NetworkStatus.refetch);
|
||
|
};
|
||
|
ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {
|
||
|
var _this = this;
|
||
|
var combinedOptions = tslib.__assign(tslib.__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: tslib.__assign(tslib.__assign({}, this.options.variables), fetchMoreOptions.variables) })))), {
|
||
|
fetchPolicy: "no-cache" });
|
||
|
combinedOptions.query = this.transformDocument(combinedOptions.query);
|
||
|
var qid = this.queryManager.generateQueryId();
|
||
|
this.lastQuery =
|
||
|
fetchMoreOptions.query ?
|
||
|
this.transformDocument(this.options.query)
|
||
|
: combinedOptions.query;
|
||
|
var queryInfo = this.queryInfo;
|
||
|
var originalNetworkStatus = queryInfo.networkStatus;
|
||
|
queryInfo.networkStatus = exports.NetworkStatus.fetchMore;
|
||
|
if (combinedOptions.notifyOnNetworkStatusChange) {
|
||
|
this.observe();
|
||
|
}
|
||
|
var updatedQuerySet = new Set();
|
||
|
return this.queryManager
|
||
|
.fetchQuery(qid, combinedOptions, exports.NetworkStatus.fetchMore)
|
||
|
.then(function (fetchMoreResult) {
|
||
|
_this.queryManager.removeQuery(qid);
|
||
|
if (queryInfo.networkStatus === exports.NetworkStatus.fetchMore) {
|
||
|
queryInfo.networkStatus = originalNetworkStatus;
|
||
|
}
|
||
|
_this.queryManager.cache.batch({
|
||
|
update: function (cache) {
|
||
|
var updateQuery = fetchMoreOptions.updateQuery;
|
||
|
if (updateQuery) {
|
||
|
cache.updateQuery({
|
||
|
query: _this.query,
|
||
|
variables: _this.variables,
|
||
|
returnPartialData: true,
|
||
|
optimistic: false,
|
||
|
}, function (previous) {
|
||
|
return updateQuery(previous, {
|
||
|
fetchMoreResult: fetchMoreResult.data,
|
||
|
variables: combinedOptions.variables,
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
else {
|
||
|
cache.writeQuery({
|
||
|
query: combinedOptions.query,
|
||
|
variables: combinedOptions.variables,
|
||
|
data: fetchMoreResult.data,
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
onWatchUpdated: function (watch) {
|
||
|
updatedQuerySet.add(watch.query);
|
||
|
},
|
||
|
});
|
||
|
return fetchMoreResult;
|
||
|
})
|
||
|
.finally(function () {
|
||
|
if (!updatedQuerySet.has(_this.query)) {
|
||
|
reobserveCacheFirst(_this);
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
ObservableQuery.prototype.subscribeToMore = function (options) {
|
||
|
var _this = this;
|
||
|
var subscription = this.queryManager
|
||
|
.startGraphQLSubscription({
|
||
|
query: options.document,
|
||
|
variables: options.variables,
|
||
|
context: options.context,
|
||
|
})
|
||
|
.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;
|
||
|
}
|
||
|
globalThis.__DEV__ !== false && invariant.error(21, err);
|
||
|
},
|
||
|
});
|
||
|
this.subscriptions.add(subscription);
|
||
|
return function () {
|
||
|
if (_this.subscriptions.delete(subscription)) {
|
||
|
subscription.unsubscribe();
|
||
|
}
|
||
|
};
|
||
|
};
|
||
|
ObservableQuery.prototype.setOptions = function (newOptions) {
|
||
|
return this.reobserve(newOptions);
|
||
|
};
|
||
|
ObservableQuery.prototype.silentSetOptions = function (newOptions) {
|
||
|
var mergedOptions = compact(this.options, newOptions || {});
|
||
|
assign(this.options, mergedOptions);
|
||
|
};
|
||
|
ObservableQuery.prototype.setVariables = function (variables) {
|
||
|
if (equal.equal(this.variables, variables)) {
|
||
|
return this.observers.size ? this.result() : Promise.resolve();
|
||
|
}
|
||
|
this.options.variables = variables;
|
||
|
if (!this.observers.size) {
|
||
|
return Promise.resolve();
|
||
|
}
|
||
|
return this.reobserve({
|
||
|
fetchPolicy: this.options.initialFetchPolicy,
|
||
|
variables: variables,
|
||
|
}, exports.NetworkStatus.setVariables);
|
||
|
};
|
||
|
ObservableQuery.prototype.updateQuery = function (mapFn) {
|
||
|
var queryManager = this.queryManager;
|
||
|
var result = queryManager.cache.diff({
|
||
|
query: this.options.query,
|
||
|
variables: this.variables,
|
||
|
returnPartialData: true,
|
||
|
optimistic: false,
|
||
|
}).result;
|
||
|
var newResult = mapFn(result, {
|
||
|
variables: this.variables,
|
||
|
});
|
||
|
if (newResult) {
|
||
|
queryManager.cache.writeQuery({
|
||
|
query: this.options.query,
|
||
|
data: newResult,
|
||
|
variables: this.variables,
|
||
|
});
|
||
|
queryManager.broadcastQueries();
|
||
|
}
|
||
|
};
|
||
|
ObservableQuery.prototype.startPolling = function (pollInterval) {
|
||
|
this.options.pollInterval = pollInterval;
|
||
|
this.updatePolling();
|
||
|
};
|
||
|
ObservableQuery.prototype.stopPolling = function () {
|
||
|
this.options.pollInterval = 0;
|
||
|
this.updatePolling();
|
||
|
};
|
||
|
ObservableQuery.prototype.applyNextFetchPolicy = function (reason,
|
||
|
options) {
|
||
|
if (options.nextFetchPolicy) {
|
||
|
var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;
|
||
|
if (fetchPolicy === "standby") ;
|
||
|
else if (typeof options.nextFetchPolicy === "function") {
|
||
|
options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
|
||
|
reason: reason,
|
||
|
options: options,
|
||
|
observable: this,
|
||
|
initialFetchPolicy: initialFetchPolicy,
|
||
|
});
|
||
|
}
|
||
|
else if (reason === "variables-changed") {
|
||
|
options.fetchPolicy = initialFetchPolicy;
|
||
|
}
|
||
|
else {
|
||
|
options.fetchPolicy = options.nextFetchPolicy;
|
||
|
}
|
||
|
}
|
||
|
return options.fetchPolicy;
|
||
|
};
|
||
|
ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {
|
||
|
this.queryManager.setObservableQuery(this);
|
||
|
return this.queryManager["fetchConcastWithInfo"](this.queryId, options, newNetworkStatus, query);
|
||
|
};
|
||
|
ObservableQuery.prototype.updatePolling = function () {
|
||
|
var _this = this;
|
||
|
if (this.queryManager.ssrMode) {
|
||
|
return;
|
||
|
}
|
||
|
var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;
|
||
|
if (!pollInterval) {
|
||
|
if (pollingInfo) {
|
||
|
clearTimeout(pollingInfo.timeout);
|
||
|
delete this.pollingInfo;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
if (pollingInfo && pollingInfo.interval === pollInterval) {
|
||
|
return;
|
||
|
}
|
||
|
invariant(pollInterval, 22);
|
||
|
var info = pollingInfo || (this.pollingInfo = {});
|
||
|
info.interval = pollInterval;
|
||
|
var maybeFetch = function () {
|
||
|
var _a, _b;
|
||
|
if (_this.pollingInfo) {
|
||
|
if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&
|
||
|
!((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {
|
||
|
_this.reobserve({
|
||
|
fetchPolicy: _this.options.initialFetchPolicy === "no-cache" ?
|
||
|
"no-cache"
|
||
|
: "network-only",
|
||
|
}, exports.NetworkStatus.poll).then(poll, poll);
|
||
|
}
|
||
|
else {
|
||
|
poll();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
var poll = function () {
|
||
|
var info = _this.pollingInfo;
|
||
|
if (info) {
|
||
|
clearTimeout(info.timeout);
|
||
|
info.timeout = setTimeout(maybeFetch, info.interval);
|
||
|
}
|
||
|
};
|
||
|
poll();
|
||
|
};
|
||
|
ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
|
||
|
if (variables === void 0) { variables = this.variables; }
|
||
|
var error = this.getLastError();
|
||
|
if (error && this.last && !equal.equal(variables, this.last.variables)) {
|
||
|
error = void 0;
|
||
|
}
|
||
|
return (this.last = tslib.__assign({ result: this.queryManager.assumeImmutableResults ?
|
||
|
newResult
|
||
|
: cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));
|
||
|
};
|
||
|
ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
|
||
|
var _this = this;
|
||
|
this.isTornDown = false;
|
||
|
var useDisposableConcast =
|
||
|
newNetworkStatus === exports.NetworkStatus.refetch ||
|
||
|
newNetworkStatus === exports.NetworkStatus.fetchMore ||
|
||
|
newNetworkStatus === exports.NetworkStatus.poll;
|
||
|
var oldVariables = this.options.variables;
|
||
|
var oldFetchPolicy = this.options.fetchPolicy;
|
||
|
var mergedOptions = compact(this.options, newOptions || {});
|
||
|
var options = useDisposableConcast ?
|
||
|
mergedOptions
|
||
|
: assign(this.options, mergedOptions);
|
||
|
var query = this.transformDocument(options.query);
|
||
|
this.lastQuery = query;
|
||
|
if (!useDisposableConcast) {
|
||
|
this.updatePolling();
|
||
|
if (newOptions &&
|
||
|
newOptions.variables &&
|
||
|
!equal.equal(newOptions.variables, oldVariables) &&
|
||
|
options.fetchPolicy !== "standby" &&
|
||
|
options.fetchPolicy === oldFetchPolicy) {
|
||
|
this.applyNextFetchPolicy("variables-changed", options);
|
||
|
if (newNetworkStatus === void 0) {
|
||
|
newNetworkStatus = exports.NetworkStatus.setVariables;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));
|
||
|
var finishWaitingForOwnResult = function () {
|
||
|
if (_this.concast === concast) {
|
||
|
_this.waitForOwnResult = false;
|
||
|
}
|
||
|
};
|
||
|
var variables = options.variables && tslib.__assign({}, options.variables);
|
||
|
var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;
|
||
|
var observer = {
|
||
|
next: function (result) {
|
||
|
if (equal.equal(_this.variables, variables)) {
|
||
|
finishWaitingForOwnResult();
|
||
|
_this.reportResult(result, variables);
|
||
|
}
|
||
|
},
|
||
|
error: function (error) {
|
||
|
if (equal.equal(_this.variables, variables)) {
|
||
|
finishWaitingForOwnResult();
|
||
|
_this.reportError(error, variables);
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
if (!useDisposableConcast && (fromLink || !this.concast)) {
|
||
|
if (this.concast && this.observer) {
|
||
|
this.concast.removeObserver(this.observer);
|
||
|
}
|
||
|
this.concast = concast;
|
||
|
this.observer = observer;
|
||
|
}
|
||
|
concast.addObserver(observer);
|
||
|
return concast;
|
||
|
};
|
||
|
ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
|
||
|
return this.reobserveAsConcast(newOptions, newNetworkStatus)
|
||
|
.promise;
|
||
|
};
|
||
|
ObservableQuery.prototype.resubscribeAfterError = function () {
|
||
|
var args = [];
|
||
|
for (var _i = 0; _i < arguments.length; _i++) {
|
||
|
args[_i] = arguments[_i];
|
||
|
}
|
||
|
var last = this.last;
|
||
|
this.resetLastResults();
|
||
|
var subscription = this.subscribe.apply(this, args);
|
||
|
this.last = last;
|
||
|
return subscription;
|
||
|
};
|
||
|
ObservableQuery.prototype.observe = function () {
|
||
|
this.reportResult(
|
||
|
this.getCurrentResult(false), this.variables);
|
||
|
};
|
||
|
ObservableQuery.prototype.reportResult = function (result, variables) {
|
||
|
var lastError = this.getLastError();
|
||
|
var isDifferent = this.isDifferentFromLastResult(result, variables);
|
||
|
if (lastError || !result.partial || this.options.returnPartialData) {
|
||
|
this.updateLastResult(result, variables);
|
||
|
}
|
||
|
if (lastError || isDifferent) {
|
||
|
iterateObserversSafely(this.observers, "next", result);
|
||
|
}
|
||
|
};
|
||
|
ObservableQuery.prototype.reportError = function (error, variables) {
|
||
|
var errorResult = tslib.__assign(tslib.__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: exports.NetworkStatus.error, loading: false });
|
||
|
this.updateLastResult(errorResult, variables);
|
||
|
iterateObserversSafely(this.observers, "error", (this.last.error = error));
|
||
|
};
|
||
|
ObservableQuery.prototype.hasObservers = function () {
|
||
|
return this.observers.size > 0;
|
||
|
};
|
||
|
ObservableQuery.prototype.tearDownQuery = function () {
|
||
|
if (this.isTornDown)
|
||
|
return;
|
||
|
if (this.concast && this.observer) {
|
||
|
this.concast.removeObserver(this.observer);
|
||
|
delete this.concast;
|
||
|
delete this.observer;
|
||
|
}
|
||
|
this.stopPolling();
|
||
|
this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
|
||
|
this.subscriptions.clear();
|
||
|
this.queryManager.stopQuery(this.queryId);
|
||
|
this.observers.clear();
|
||
|
this.isTornDown = true;
|
||
|
};
|
||
|
ObservableQuery.prototype.transformDocument = function (document) {
|
||
|
return this.queryManager.transform(document);
|
||
|
};
|
||
|
return ObservableQuery;
|
||
|
}(zenObservableTs.Observable));
|
||
|
fixObservableSubclass(ObservableQuery);
|
||
|
function reobserveCacheFirst(obsQuery) {
|
||
|
var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;
|
||
|
if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
|
||
|
return obsQuery.reobserve({
|
||
|
fetchPolicy: "cache-first",
|
||
|
nextFetchPolicy: function (currentFetchPolicy, context) {
|
||
|
this.nextFetchPolicy = nextFetchPolicy;
|
||
|
if (typeof this.nextFetchPolicy === "function") {
|
||
|
return this.nextFetchPolicy(currentFetchPolicy, context);
|
||
|
}
|
||
|
return fetchPolicy;
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
return obsQuery.reobserve();
|
||
|
}
|
||
|
function defaultSubscriptionObserverErrorCallback(error) {
|
||
|
globalThis.__DEV__ !== false && invariant.error(23, error.message, error.stack);
|
||
|
}
|
||
|
function logMissingFieldErrors(missing) {
|
||
|
if (globalThis.__DEV__ !== false && missing) {
|
||
|
globalThis.__DEV__ !== false && invariant.debug(24, missing);
|
||
|
}
|
||
|
}
|
||
|
function skipCacheDataFor(fetchPolicy ) {
|
||
|
return (fetchPolicy === "network-only" ||
|
||
|
fetchPolicy === "no-cache" ||
|
||
|
fetchPolicy === "standby");
|
||
|
}
|
||
|
|
||
|
var LocalState = (function () {
|
||
|
function LocalState(_a) {
|
||
|
var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
|
||
|
this.selectionsToResolveCache = new WeakMap();
|
||
|
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 = mergeDeep(_this.resolvers, resolverGroup);
|
||
|
});
|
||
|
}
|
||
|
else {
|
||
|
this.resolvers = 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.__awaiter(this, void 0, void 0, function () {
|
||
|
return tslib.__generator(this, function (_c) {
|
||
|
if (document) {
|
||
|
return [2 , this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib.__assign(tslib.__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 (hasDirectives(["client"], document)) {
|
||
|
if (this.resolvers) {
|
||
|
return document;
|
||
|
}
|
||
|
}
|
||
|
return null;
|
||
|
};
|
||
|
LocalState.prototype.serverQuery = function (document) {
|
||
|
return removeClientSetsFromDocument(document);
|
||
|
};
|
||
|
LocalState.prototype.prepareContext = function (context) {
|
||
|
var cache = this.cache;
|
||
|
return tslib.__assign(tslib.__assign({}, context), { cache: cache,
|
||
|
getCacheKey: function (obj) {
|
||
|
return cache.identify(obj);
|
||
|
} });
|
||
|
};
|
||
|
LocalState.prototype.addExportedVariables = function (document, variables, context) {
|
||
|
if (variables === void 0) { variables = {}; }
|
||
|
if (context === void 0) { context = {}; }
|
||
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
||
|
return tslib.__generator(this, function (_a) {
|
||
|
if (document) {
|
||
|
return [2 , this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib.__assign(tslib.__assign({}, variables), data.exportedVariables)); })];
|
||
|
}
|
||
|
return [2 , tslib.__assign({}, variables)];
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
LocalState.prototype.shouldForceResolvers = function (document) {
|
||
|
var forceResolvers = false;
|
||
|
graphql.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 graphql.BREAK;
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
},
|
||
|
});
|
||
|
return forceResolvers;
|
||
|
};
|
||
|
LocalState.prototype.buildRootValueFromCache = function (document, variables) {
|
||
|
return this.cache.diff({
|
||
|
query: 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.__awaiter(this, void 0, void 0, function () {
|
||
|
var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;
|
||
|
return tslib.__generator(this, function (_b) {
|
||
|
mainDefinition = getMainDefinition(document);
|
||
|
fragments = getFragmentDefinitions(document);
|
||
|
fragmentMap = createFragmentMap(fragments);
|
||
|
selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);
|
||
|
definitionOperation = mainDefinition.operation;
|
||
|
defaultOperationType = definitionOperation ?
|
||
|
definitionOperation.charAt(0).toUpperCase() +
|
||
|
definitionOperation.slice(1)
|
||
|
: "Query";
|
||
|
_a = this, cache = _a.cache, client = _a.client;
|
||
|
execContext = {
|
||
|
fragmentMap: fragmentMap,
|
||
|
context: tslib.__assign(tslib.__assign({}, context), { cache: cache, client: client }),
|
||
|
variables: variables,
|
||
|
fragmentMatcher: fragmentMatcher,
|
||
|
defaultOperationType: defaultOperationType,
|
||
|
exportedVariables: {},
|
||
|
selectionsToResolve: selectionsToResolve,
|
||
|
onlyRunForcedResolvers: onlyRunForcedResolvers,
|
||
|
};
|
||
|
isClientFieldDescendant = false;
|
||
|
return [2 , this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({
|
||
|
result: result,
|
||
|
exportedVariables: execContext.exportedVariables,
|
||
|
}); })];
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {
|
||
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
||
|
var fragmentMap, context, variables, resultsToMerge, execute;
|
||
|
var _this = this;
|
||
|
return tslib.__generator(this, function (_a) {
|
||
|
fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
|
||
|
resultsToMerge = [rootValue];
|
||
|
execute = function (selection) { return tslib.__awaiter(_this, void 0, void 0, function () {
|
||
|
var fragment, typeCondition;
|
||
|
return tslib.__generator(this, function (_a) {
|
||
|
if (!isClientFieldDescendant &&
|
||
|
!execContext.selectionsToResolve.has(selection)) {
|
||
|
return [2 ];
|
||
|
}
|
||
|
if (!shouldInclude(selection, variables)) {
|
||
|
return [2 ];
|
||
|
}
|
||
|
if (isField(selection)) {
|
||
|
return [2 , this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {
|
||
|
var _a;
|
||
|
if (typeof fieldResult !== "undefined") {
|
||
|
resultsToMerge.push((_a = {},
|
||
|
_a[resultKeyNameFromField(selection)] = fieldResult,
|
||
|
_a));
|
||
|
}
|
||
|
})];
|
||
|
}
|
||
|
if (isInlineFragment(selection)) {
|
||
|
fragment = selection;
|
||
|
}
|
||
|
else {
|
||
|
fragment = fragmentMap[selection.name.value];
|
||
|
invariant(fragment, 18, selection.name.value);
|
||
|
}
|
||
|
if (fragment && fragment.typeCondition) {
|
||
|
typeCondition = fragment.typeCondition.name.value;
|
||
|
if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
|
||
|
return [2 , this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {
|
||
|
resultsToMerge.push(fragmentResult);
|
||
|
})];
|
||
|
}
|
||
|
}
|
||
|
return [2 ];
|
||
|
});
|
||
|
}); };
|
||
|
return [2 , Promise.all(selectionSet.selections.map(execute)).then(function () {
|
||
|
return mergeDeepArray(resultsToMerge);
|
||
|
})];
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {
|
||
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
||
|
var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
|
||
|
var _this = this;
|
||
|
return tslib.__generator(this, function (_a) {
|
||
|
if (!rootValue) {
|
||
|
return [2 , null];
|
||
|
}
|
||
|
variables = execContext.variables;
|
||
|
fieldName = field.name.value;
|
||
|
aliasedFieldName = 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(
|
||
|
cacheSlot.withValue(this.cache, resolve, [
|
||
|
rootValue,
|
||
|
argumentsObjectFromField(field, variables),
|
||
|
execContext.context,
|
||
|
{ field: field, fragmentMap: execContext.fragmentMap },
|
||
|
]));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return [2 , resultPromise.then(function (result) {
|
||
|
var _a, _b;
|
||
|
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;
|
||
|
}
|
||
|
var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === "client"; })) !== null && _b !== void 0 ? _b : false;
|
||
|
if (Array.isArray(result)) {
|
||
|
return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);
|
||
|
}
|
||
|
if (field.selectionSet) {
|
||
|
return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);
|
||
|
}
|
||
|
})];
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, 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, isClientFieldDescendant, item, execContext);
|
||
|
}
|
||
|
if (field.selectionSet) {
|
||
|
return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);
|
||
|
}
|
||
|
}));
|
||
|
};
|
||
|
LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {
|
||
|
var isSingleASTNode = function (node) { return !Array.isArray(node); };
|
||
|
var selectionsToResolveCache = this.selectionsToResolveCache;
|
||
|
function collectByDefinition(definitionNode) {
|
||
|
if (!selectionsToResolveCache.has(definitionNode)) {
|
||
|
var matches_1 = new Set();
|
||
|
selectionsToResolveCache.set(definitionNode, matches_1);
|
||
|
graphql.visit(definitionNode, {
|
||
|
Directive: function (node, _, __, ___, ancestors) {
|
||
|
if (node.name.value === "client") {
|
||
|
ancestors.forEach(function (node) {
|
||
|
if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
|
||
|
matches_1.add(node);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
FragmentSpread: function (spread, _, __, ___, ancestors) {
|
||
|
var fragment = fragmentMap[spread.name.value];
|
||
|
invariant(fragment, 19, spread.name.value);
|
||
|
var fragmentSelections = collectByDefinition(fragment);
|
||
|
if (fragmentSelections.size > 0) {
|
||
|
ancestors.forEach(function (node) {
|
||
|
if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
|
||
|
matches_1.add(node);
|
||
|
}
|
||
|
});
|
||
|
matches_1.add(spread);
|
||
|
fragmentSelections.forEach(function (selection) {
|
||
|
matches_1.add(selection);
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
return selectionsToResolveCache.get(definitionNode);
|
||
|
}
|
||
|
return collectByDefinition(mainDefinition);
|
||
|
};
|
||
|
return LocalState;
|
||
|
}());
|
||
|
|
||
|
var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
|
||
|
function wrapDestructiveCacheMethod(cache, methodName) {
|
||
|
var original = cache[methodName];
|
||
|
if (typeof original === "function") {
|
||
|
cache[methodName] = function () {
|
||
|
destructiveMethodCounts.set(cache,
|
||
|
(destructiveMethodCounts.get(cache) + 1) % 1e15);
|
||
|
return original.apply(this, arguments);
|
||
|
};
|
||
|
}
|
||
|
}
|
||
|
function cancelNotifyTimeout(info) {
|
||
|
if (info["notifyTimeout"]) {
|
||
|
clearTimeout(info["notifyTimeout"]);
|
||
|
info["notifyTimeout"] = void 0;
|
||
|
}
|
||
|
}
|
||
|
var QueryInfo = (function () {
|
||
|
function QueryInfo(queryManager, queryId) {
|
||
|
if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
|
||
|
this.queryId = queryId;
|
||
|
this.listeners = new Set();
|
||
|
this.document = null;
|
||
|
this.lastRequestId = 1;
|
||
|
this.stopped = false;
|
||
|
this.dirty = false;
|
||
|
this.observableQuery = null;
|
||
|
var cache = (this.cache = queryManager.cache);
|
||
|
if (!destructiveMethodCounts.has(cache)) {
|
||
|
destructiveMethodCounts.set(cache, 0);
|
||
|
wrapDestructiveCacheMethod(cache, "evict");
|
||
|
wrapDestructiveCacheMethod(cache, "modify");
|
||
|
wrapDestructiveCacheMethod(cache, "reset");
|
||
|
}
|
||
|
}
|
||
|
QueryInfo.prototype.init = function (query) {
|
||
|
var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
|
||
|
if (this.variables &&
|
||
|
this.networkStatus !== exports.NetworkStatus.loading &&
|
||
|
!equal.equal(this.variables, query.variables)) {
|
||
|
networkStatus = exports.NetworkStatus.setVariables;
|
||
|
}
|
||
|
if (!equal.equal(query.variables, this.variables)) {
|
||
|
this.lastDiff = void 0;
|
||
|
}
|
||
|
Object.assign(this, {
|
||
|
document: query.document,
|
||
|
variables: query.variables,
|
||
|
networkError: null,
|
||
|
graphQLErrors: this.graphQLErrors || [],
|
||
|
networkStatus: networkStatus,
|
||
|
});
|
||
|
if (query.observableQuery) {
|
||
|
this.setObservableQuery(query.observableQuery);
|
||
|
}
|
||
|
if (query.lastRequestId) {
|
||
|
this.lastRequestId = query.lastRequestId;
|
||
|
}
|
||
|
return this;
|
||
|
};
|
||
|
QueryInfo.prototype.reset = function () {
|
||
|
cancelNotifyTimeout(this);
|
||
|
this.dirty = false;
|
||
|
};
|
||
|
QueryInfo.prototype.resetDiff = function () {
|
||
|
this.lastDiff = void 0;
|
||
|
};
|
||
|
QueryInfo.prototype.getDiff = function () {
|
||
|
var options = this.getDiffOptions();
|
||
|
if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
|
||
|
return this.lastDiff.diff;
|
||
|
}
|
||
|
this.updateWatch(this.variables);
|
||
|
var oq = this.observableQuery;
|
||
|
if (oq && oq.options.fetchPolicy === "no-cache") {
|
||
|
return { complete: false };
|
||
|
}
|
||
|
var diff = this.cache.diff(options);
|
||
|
this.updateLastDiff(diff, options);
|
||
|
return diff;
|
||
|
};
|
||
|
QueryInfo.prototype.updateLastDiff = function (diff, options) {
|
||
|
this.lastDiff =
|
||
|
diff ?
|
||
|
{
|
||
|
diff: diff,
|
||
|
options: options || this.getDiffOptions(),
|
||
|
}
|
||
|
: void 0;
|
||
|
};
|
||
|
QueryInfo.prototype.getDiffOptions = function (variables) {
|
||
|
var _a;
|
||
|
if (variables === void 0) { variables = this.variables; }
|
||
|
return {
|
||
|
query: this.document,
|
||
|
variables: variables,
|
||
|
returnPartialData: true,
|
||
|
optimistic: true,
|
||
|
canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
|
||
|
};
|
||
|
};
|
||
|
QueryInfo.prototype.setDiff = function (diff) {
|
||
|
var _this = this;
|
||
|
var _a;
|
||
|
var oldDiff = this.lastDiff && this.lastDiff.diff;
|
||
|
if (diff &&
|
||
|
!diff.complete &&
|
||
|
!((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.returnPartialData) &&
|
||
|
!(oldDiff && oldDiff.complete)) {
|
||
|
return;
|
||
|
}
|
||
|
this.updateLastDiff(diff);
|
||
|
if (!this.dirty && !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
|
||
|
this.dirty = true;
|
||
|
if (!this.notifyTimeout) {
|
||
|
this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
QueryInfo.prototype.setObservableQuery = function (oq) {
|
||
|
var _this = this;
|
||
|
if (oq === this.observableQuery)
|
||
|
return;
|
||
|
if (this.oqListener) {
|
||
|
this.listeners.delete(this.oqListener);
|
||
|
}
|
||
|
this.observableQuery = oq;
|
||
|
if (oq) {
|
||
|
oq["queryInfo"] = this;
|
||
|
this.listeners.add((this.oqListener = function () {
|
||
|
var diff = _this.getDiff();
|
||
|
if (diff.fromOptimisticTransaction) {
|
||
|
oq["observe"]();
|
||
|
}
|
||
|
else {
|
||
|
reobserveCacheFirst(oq);
|
||
|
}
|
||
|
}));
|
||
|
}
|
||
|
else {
|
||
|
delete this.oqListener;
|
||
|
}
|
||
|
};
|
||
|
QueryInfo.prototype.notify = function () {
|
||
|
var _this = this;
|
||
|
cancelNotifyTimeout(this);
|
||
|
if (this.shouldNotify()) {
|
||
|
this.listeners.forEach(function (listener) { return listener(_this); });
|
||
|
}
|
||
|
this.dirty = false;
|
||
|
};
|
||
|
QueryInfo.prototype.shouldNotify = function () {
|
||
|
if (!this.dirty || !this.listeners.size) {
|
||
|
return false;
|
||
|
}
|
||
|
if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {
|
||
|
var fetchPolicy = this.observableQuery.options.fetchPolicy;
|
||
|
if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
};
|
||
|
QueryInfo.prototype.stop = function () {
|
||
|
if (!this.stopped) {
|
||
|
this.stopped = true;
|
||
|
this.reset();
|
||
|
this.cancel();
|
||
|
this.cancel = QueryInfo.prototype.cancel;
|
||
|
var oq = this.observableQuery;
|
||
|
if (oq)
|
||
|
oq.stopPolling();
|
||
|
}
|
||
|
};
|
||
|
QueryInfo.prototype.cancel = function () { };
|
||
|
QueryInfo.prototype.updateWatch = function (variables) {
|
||
|
var _this = this;
|
||
|
if (variables === void 0) { variables = this.variables; }
|
||
|
var oq = this.observableQuery;
|
||
|
if (oq && oq.options.fetchPolicy === "no-cache") {
|
||
|
return;
|
||
|
}
|
||
|
var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
|
||
|
if (!this.lastWatch || !equal.equal(watchOptions, this.lastWatch)) {
|
||
|
this.cancel();
|
||
|
this.cancel = this.cache.watch((this.lastWatch = watchOptions));
|
||
|
}
|
||
|
};
|
||
|
QueryInfo.prototype.resetLastWrite = function () {
|
||
|
this.lastWrite = void 0;
|
||
|
};
|
||
|
QueryInfo.prototype.shouldWrite = function (result, variables) {
|
||
|
var lastWrite = this.lastWrite;
|
||
|
return !(lastWrite &&
|
||
|
lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
|
||
|
equal.equal(variables, lastWrite.variables) &&
|
||
|
equal.equal(result.data, lastWrite.result.data));
|
||
|
};
|
||
|
QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
|
||
|
var _this = this;
|
||
|
var merger = new DeepMerger();
|
||
|
var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
|
||
|
this.reset();
|
||
|
if ("incremental" in result && isNonEmptyArray(result.incremental)) {
|
||
|
var mergedData = mergeIncrementalData(this.getDiff().result, result);
|
||
|
result.data = mergedData;
|
||
|
}
|
||
|
else if ("hasNext" in result && result.hasNext) {
|
||
|
var diff = this.getDiff();
|
||
|
result.data = merger.merge(diff.result, result.data);
|
||
|
}
|
||
|
this.graphQLErrors = graphQLErrors;
|
||
|
if (options.fetchPolicy === "no-cache") {
|
||
|
this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
|
||
|
}
|
||
|
else if (cacheWriteBehavior !== 0 ) {
|
||
|
if (shouldWriteResult(result, options.errorPolicy)) {
|
||
|
this.cache.performTransaction(function (cache) {
|
||
|
if (_this.shouldWrite(result, options.variables)) {
|
||
|
cache.writeQuery({
|
||
|
query: document,
|
||
|
data: result.data,
|
||
|
variables: options.variables,
|
||
|
overwrite: cacheWriteBehavior === 1 ,
|
||
|
});
|
||
|
_this.lastWrite = {
|
||
|
result: result,
|
||
|
variables: options.variables,
|
||
|
dmCount: destructiveMethodCounts.get(_this.cache),
|
||
|
};
|
||
|
}
|
||
|
else {
|
||
|
if (_this.lastDiff && _this.lastDiff.diff.complete) {
|
||
|
result.data = _this.lastDiff.diff.result;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
var diffOptions = _this.getDiffOptions(options.variables);
|
||
|
var diff = cache.diff(diffOptions);
|
||
|
if (!_this.stopped && equal.equal(_this.variables, options.variables)) {
|
||
|
_this.updateWatch(options.variables);
|
||
|
}
|
||
|
_this.updateLastDiff(diff, diffOptions);
|
||
|
if (diff.complete) {
|
||
|
result.data = diff.result;
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
else {
|
||
|
this.lastWrite = void 0;
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
QueryInfo.prototype.markReady = function () {
|
||
|
this.networkError = null;
|
||
|
return (this.networkStatus = exports.NetworkStatus.ready);
|
||
|
};
|
||
|
QueryInfo.prototype.markError = function (error) {
|
||
|
this.networkStatus = exports.NetworkStatus.error;
|
||
|
this.lastWrite = void 0;
|
||
|
this.reset();
|
||
|
if (error.graphQLErrors) {
|
||
|
this.graphQLErrors = error.graphQLErrors;
|
||
|
}
|
||
|
if (error.networkError) {
|
||
|
this.networkError = error.networkError;
|
||
|
}
|
||
|
return error;
|
||
|
};
|
||
|
return QueryInfo;
|
||
|
}());
|
||
|
function shouldWriteResult(result, errorPolicy) {
|
||
|
if (errorPolicy === void 0) { errorPolicy = "none"; }
|
||
|
var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
|
||
|
var writeWithErrors = !graphQLResultHasError(result);
|
||
|
if (!writeWithErrors && ignoreErrors && result.data) {
|
||
|
writeWithErrors = true;
|
||
|
}
|
||
|
return writeWithErrors;
|
||
|
}
|
||
|
|
||
|
var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
|
||
|
var IGNORE = Object.create(null);
|
||
|
var QueryManager = (function () {
|
||
|
function QueryManager(_a) {
|
||
|
var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, documentTransform = _a.documentTransform, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, _e = _a.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? !!cache.assumeImmutableResults : _e, defaultContext = _a.defaultContext;
|
||
|
var _this = this;
|
||
|
this.clientAwareness = {};
|
||
|
this.queries = new Map();
|
||
|
this.fetchCancelFns = new Map();
|
||
|
this.transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
|
||
|
2000 );
|
||
|
this.queryIdCounter = 1;
|
||
|
this.requestIdCounter = 1;
|
||
|
this.mutationIdCounter = 1;
|
||
|
this.inFlightLinkObservables = new trie.Trie(false);
|
||
|
var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); },
|
||
|
{ cache: false });
|
||
|
this.cache = cache;
|
||
|
this.link = link;
|
||
|
this.defaultOptions = defaultOptions || Object.create(null);
|
||
|
this.queryDeduplication = queryDeduplication;
|
||
|
this.clientAwareness = clientAwareness;
|
||
|
this.localState = localState || new LocalState({ cache: cache });
|
||
|
this.ssrMode = ssrMode;
|
||
|
this.assumeImmutableResults = assumeImmutableResults;
|
||
|
this.documentTransform =
|
||
|
documentTransform ?
|
||
|
defaultDocumentTransform
|
||
|
.concat(documentTransform)
|
||
|
.concat(defaultDocumentTransform)
|
||
|
: defaultDocumentTransform;
|
||
|
this.defaultContext = defaultContext || Object.create(null);
|
||
|
if ((this.onBroadcast = onBroadcast)) {
|
||
|
this.mutationStore = Object.create(null);
|
||
|
}
|
||
|
}
|
||
|
QueryManager.prototype.stop = function () {
|
||
|
var _this = this;
|
||
|
this.queries.forEach(function (_info, queryId) {
|
||
|
_this.stopQueryNoBroadcast(queryId);
|
||
|
});
|
||
|
this.cancelPendingFetches(newInvariantError(25));
|
||
|
};
|
||
|
QueryManager.prototype.cancelPendingFetches = function (error) {
|
||
|
this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
|
||
|
this.fetchCancelFns.clear();
|
||
|
};
|
||
|
QueryManager.prototype.mutate = function (_a) {
|
||
|
var _b, _c;
|
||
|
var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _d = _a.refetchQueries, refetchQueries = _d === void 0 ? [] : _d, _e = _a.awaitRefetchQueries, awaitRefetchQueries = _e === void 0 ? false : _e, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _f = _a.fetchPolicy, fetchPolicy = _f === void 0 ? ((_b = this.defaultOptions.mutate) === null || _b === void 0 ? void 0 : _b.fetchPolicy) || "network-only" : _f, _g = _a.errorPolicy, errorPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.errorPolicy) || "none" : _g, keepRootFields = _a.keepRootFields, context = _a.context;
|
||
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
||
|
var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;
|
||
|
return tslib.__generator(this, function (_h) {
|
||
|
switch (_h.label) {
|
||
|
case 0:
|
||
|
invariant(mutation, 26);
|
||
|
invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 27);
|
||
|
mutationId = this.generateMutationId();
|
||
|
mutation = this.cache.transformForLink(this.transform(mutation));
|
||
|
hasClientExports = this.getDocumentInfo(mutation).hasClientExports;
|
||
|
variables = this.getVariables(mutation, variables);
|
||
|
if (!hasClientExports) return [3 , 2];
|
||
|
return [4 , this.localState.addExportedVariables(mutation, variables, context)];
|
||
|
case 1:
|
||
|
variables = (_h.sent());
|
||
|
_h.label = 2;
|
||
|
case 2:
|
||
|
mutationStoreValue = this.mutationStore &&
|
||
|
(this.mutationStore[mutationId] = {
|
||
|
mutation: mutation,
|
||
|
variables: variables,
|
||
|
loading: true,
|
||
|
error: null,
|
||
|
});
|
||
|
isOptimistic = optimisticResponse &&
|
||
|
this.markMutationOptimistic(optimisticResponse, {
|
||
|
mutationId: mutationId,
|
||
|
document: mutation,
|
||
|
variables: variables,
|
||
|
fetchPolicy: fetchPolicy,
|
||
|
errorPolicy: errorPolicy,
|
||
|
context: context,
|
||
|
updateQueries: updateQueries,
|
||
|
update: updateWithProxyFn,
|
||
|
keepRootFields: keepRootFields,
|
||
|
});
|
||
|
this.broadcastQueries();
|
||
|
self = this;
|
||
|
return [2 , new Promise(function (resolve, reject) {
|
||
|
return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, false), function (result) {
|
||
|
if (graphQLResultHasError(result) && errorPolicy === "none") {
|
||
|
throw new ApolloError({
|
||
|
graphQLErrors: getGraphQLErrorsFromResult(result),
|
||
|
});
|
||
|
}
|
||
|
if (mutationStoreValue) {
|
||
|
mutationStoreValue.loading = false;
|
||
|
mutationStoreValue.error = null;
|
||
|
}
|
||
|
var storeResult = tslib.__assign({}, result);
|
||
|
if (typeof refetchQueries === "function") {
|
||
|
refetchQueries = refetchQueries(storeResult);
|
||
|
}
|
||
|
if (errorPolicy === "ignore" && graphQLResultHasError(storeResult)) {
|
||
|
delete storeResult.errors;
|
||
|
}
|
||
|
return self.markMutationResult({
|
||
|
mutationId: mutationId,
|
||
|
result: storeResult,
|
||
|
document: mutation,
|
||
|
variables: variables,
|
||
|
fetchPolicy: fetchPolicy,
|
||
|
errorPolicy: errorPolicy,
|
||
|
context: context,
|
||
|
update: updateWithProxyFn,
|
||
|
updateQueries: updateQueries,
|
||
|
awaitRefetchQueries: awaitRefetchQueries,
|
||
|
refetchQueries: refetchQueries,
|
||
|
removeOptimistic: isOptimistic ? mutationId : void 0,
|
||
|
onQueryUpdated: onQueryUpdated,
|
||
|
keepRootFields: keepRootFields,
|
||
|
});
|
||
|
}).subscribe({
|
||
|
next: function (storeResult) {
|
||
|
self.broadcastQueries();
|
||
|
if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
|
||
|
resolve(storeResult);
|
||
|
}
|
||
|
},
|
||
|
error: function (err) {
|
||
|
if (mutationStoreValue) {
|
||
|
mutationStoreValue.loading = false;
|
||
|
mutationStoreValue.error = err;
|
||
|
}
|
||
|
if (isOptimistic) {
|
||
|
self.cache.removeOptimistic(mutationId);
|
||
|
}
|
||
|
self.broadcastQueries();
|
||
|
reject(err instanceof ApolloError ? err : (new ApolloError({
|
||
|
networkError: err,
|
||
|
})));
|
||
|
},
|
||
|
});
|
||
|
})];
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
QueryManager.prototype.markMutationResult = function (mutation, cache) {
|
||
|
var _this = this;
|
||
|
if (cache === void 0) { cache = this.cache; }
|
||
|
var result = mutation.result;
|
||
|
var cacheWrites = [];
|
||
|
var skipCache = mutation.fetchPolicy === "no-cache";
|
||
|
if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
|
||
|
if (!isExecutionPatchIncrementalResult(result)) {
|
||
|
cacheWrites.push({
|
||
|
result: result.data,
|
||
|
dataId: "ROOT_MUTATION",
|
||
|
query: mutation.document,
|
||
|
variables: mutation.variables,
|
||
|
});
|
||
|
}
|
||
|
if (isExecutionPatchIncrementalResult(result) &&
|
||
|
isNonEmptyArray(result.incremental)) {
|
||
|
var diff = cache.diff({
|
||
|
id: "ROOT_MUTATION",
|
||
|
query: this.getDocumentInfo(mutation.document).asQuery,
|
||
|
variables: mutation.variables,
|
||
|
optimistic: false,
|
||
|
returnPartialData: true,
|
||
|
});
|
||
|
var mergedData = void 0;
|
||
|
if (diff.result) {
|
||
|
mergedData = mergeIncrementalData(diff.result, result);
|
||
|
}
|
||
|
if (typeof mergedData !== "undefined") {
|
||
|
result.data = mergedData;
|
||
|
cacheWrites.push({
|
||
|
result: mergedData,
|
||
|
dataId: "ROOT_MUTATION",
|
||
|
query: mutation.document,
|
||
|
variables: mutation.variables,
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
var updateQueries_1 = mutation.updateQueries;
|
||
|
if (updateQueries_1) {
|
||
|
this.queries.forEach(function (_a, queryId) {
|
||
|
var observableQuery = _a.observableQuery;
|
||
|
var queryName = observableQuery && observableQuery.queryName;
|
||
|
if (!queryName || !hasOwnProperty$1.call(updateQueries_1, queryName)) {
|
||
|
return;
|
||
|
}
|
||
|
var updater = updateQueries_1[queryName];
|
||
|
var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;
|
||
|
var _c = cache.diff({
|
||
|
query: document,
|
||
|
variables: variables,
|
||
|
returnPartialData: true,
|
||
|
optimistic: false,
|
||
|
}), currentQueryResult = _c.result, complete = _c.complete;
|
||
|
if (complete && currentQueryResult) {
|
||
|
var nextQueryResult = updater(currentQueryResult, {
|
||
|
mutationResult: result,
|
||
|
queryName: (document && getOperationName(document)) || void 0,
|
||
|
queryVariables: variables,
|
||
|
});
|
||
|
if (nextQueryResult) {
|
||
|
cacheWrites.push({
|
||
|
result: nextQueryResult,
|
||
|
dataId: "ROOT_QUERY",
|
||
|
query: document,
|
||
|
variables: variables,
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
if (cacheWrites.length > 0 ||
|
||
|
(mutation.refetchQueries || "").length > 0 ||
|
||
|
mutation.update ||
|
||
|
mutation.onQueryUpdated ||
|
||
|
mutation.removeOptimistic) {
|
||
|
var results_1 = [];
|
||
|
this.refetchQueries({
|
||
|
updateCache: function (cache) {
|
||
|
if (!skipCache) {
|
||
|
cacheWrites.forEach(function (write) { return cache.write(write); });
|
||
|
}
|
||
|
var update = mutation.update;
|
||
|
var isFinalResult = !isExecutionPatchResult(result) ||
|
||
|
(isExecutionPatchIncrementalResult(result) && !result.hasNext);
|
||
|
if (update) {
|
||
|
if (!skipCache) {
|
||
|
var diff = cache.diff({
|
||
|
id: "ROOT_MUTATION",
|
||
|
query: _this.getDocumentInfo(mutation.document).asQuery,
|
||
|
variables: mutation.variables,
|
||
|
optimistic: false,
|
||
|
returnPartialData: true,
|
||
|
});
|
||
|
if (diff.complete) {
|
||
|
result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });
|
||
|
if ("incremental" in result) {
|
||
|
delete result.incremental;
|
||
|
}
|
||
|
if ("hasNext" in result) {
|
||
|
delete result.hasNext;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (isFinalResult) {
|
||
|
update(cache, result, {
|
||
|
context: mutation.context,
|
||
|
variables: mutation.variables,
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
if (!skipCache && !mutation.keepRootFields && isFinalResult) {
|
||
|
cache.modify({
|
||
|
id: "ROOT_MUTATION",
|
||
|
fields: function (value, _a) {
|
||
|
var fieldName = _a.fieldName, DELETE = _a.DELETE;
|
||
|
return fieldName === "__typename" ? value : DELETE;
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
include: mutation.refetchQueries,
|
||
|
optimistic: false,
|
||
|
removeOptimistic: mutation.removeOptimistic,
|
||
|
onQueryUpdated: mutation.onQueryUpdated || null,
|
||
|
}).forEach(function (result) { return results_1.push(result); });
|
||
|
if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
|
||
|
return Promise.all(results_1).then(function () { return result; });
|
||
|
}
|
||
|
}
|
||
|
return Promise.resolve(result);
|
||
|
};
|
||
|
QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {
|
||
|
var _this = this;
|
||
|
var data = typeof optimisticResponse === "function" ?
|
||
|
optimisticResponse(mutation.variables, { IGNORE: IGNORE })
|
||
|
: optimisticResponse;
|
||
|
if (data === IGNORE) {
|
||
|
return false;
|
||
|
}
|
||
|
this.cache.recordOptimisticTransaction(function (cache) {
|
||
|
try {
|
||
|
_this.markMutationResult(tslib.__assign(tslib.__assign({}, mutation), { result: { data: data } }), cache);
|
||
|
}
|
||
|
catch (error) {
|
||
|
globalThis.__DEV__ !== false && invariant.error(error);
|
||
|
}
|
||
|
}, mutation.mutationId);
|
||
|
return true;
|
||
|
};
|
||
|
QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {
|
||
|
return this.fetchConcastWithInfo(queryId, options, networkStatus).concast
|
||
|
.promise;
|
||
|
};
|
||
|
QueryManager.prototype.getQueryStore = function () {
|
||
|
var store = Object.create(null);
|
||
|
this.queries.forEach(function (info, queryId) {
|
||
|
store[queryId] = {
|
||
|
variables: info.variables,
|
||
|
networkStatus: info.networkStatus,
|
||
|
networkError: info.networkError,
|
||
|
graphQLErrors: info.graphQLErrors,
|
||
|
};
|
||
|
});
|
||
|
return store;
|
||
|
};
|
||
|
QueryManager.prototype.resetErrors = function (queryId) {
|
||
|
var queryInfo = this.queries.get(queryId);
|
||
|
if (queryInfo) {
|
||
|
queryInfo.networkError = undefined;
|
||
|
queryInfo.graphQLErrors = [];
|
||
|
}
|
||
|
};
|
||
|
QueryManager.prototype.transform = function (document) {
|
||
|
return this.documentTransform.transformDocument(document);
|
||
|
};
|
||
|
QueryManager.prototype.getDocumentInfo = function (document) {
|
||
|
var transformCache = this.transformCache;
|
||
|
if (!transformCache.has(document)) {
|
||
|
var cacheEntry = {
|
||
|
hasClientExports: hasClientExports(document),
|
||
|
hasForcedResolvers: this.localState.shouldForceResolvers(document),
|
||
|
hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
|
||
|
clientQuery: this.localState.clientQuery(document),
|
||
|
serverQuery: removeDirectivesFromDocument([
|
||
|
{ name: "client", remove: true },
|
||
|
{ name: "connection" },
|
||
|
{ name: "nonreactive" },
|
||
|
], document),
|
||
|
defaultVars: getDefaultValues(getOperationDefinition(document)),
|
||
|
asQuery: tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.map(function (def) {
|
||
|
if (def.kind === "OperationDefinition" &&
|
||
|
def.operation !== "query") {
|
||
|
return tslib.__assign(tslib.__assign({}, def), { operation: "query" });
|
||
|
}
|
||
|
return def;
|
||
|
}) }),
|
||
|
};
|
||
|
transformCache.set(document, cacheEntry);
|
||
|
}
|
||
|
return transformCache.get(document);
|
||
|
};
|
||
|
QueryManager.prototype.getVariables = function (document, variables) {
|
||
|
return tslib.__assign(tslib.__assign({}, this.getDocumentInfo(document).defaultVars), variables);
|
||
|
};
|
||
|
QueryManager.prototype.watchQuery = function (options) {
|
||
|
var query = this.transform(options.query);
|
||
|
options = tslib.__assign(tslib.__assign({}, options), { variables: this.getVariables(query, options.variables) });
|
||
|
if (typeof options.notifyOnNetworkStatusChange === "undefined") {
|
||
|
options.notifyOnNetworkStatusChange = false;
|
||
|
}
|
||
|
var queryInfo = new QueryInfo(this);
|
||
|
var observable = new ObservableQuery({
|
||
|
queryManager: this,
|
||
|
queryInfo: queryInfo,
|
||
|
options: options,
|
||
|
});
|
||
|
observable["lastQuery"] = query;
|
||
|
this.queries.set(observable.queryId, queryInfo);
|
||
|
queryInfo.init({
|
||
|
document: query,
|
||
|
observableQuery: observable,
|
||
|
variables: observable.variables,
|
||
|
});
|
||
|
return observable;
|
||
|
};
|
||
|
QueryManager.prototype.query = function (options, queryId) {
|
||
|
var _this = this;
|
||
|
if (queryId === void 0) { queryId = this.generateQueryId(); }
|
||
|
invariant(options.query, 28);
|
||
|
invariant(options.query.kind === "Document", 29);
|
||
|
invariant(!options.returnPartialData, 30);
|
||
|
invariant(!options.pollInterval, 31);
|
||
|
return this.fetchQuery(queryId, tslib.__assign(tslib.__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });
|
||
|
};
|
||
|
QueryManager.prototype.generateQueryId = function () {
|
||
|
return String(this.queryIdCounter++);
|
||
|
};
|
||
|
QueryManager.prototype.generateRequestId = function () {
|
||
|
return this.requestIdCounter++;
|
||
|
};
|
||
|
QueryManager.prototype.generateMutationId = function () {
|
||
|
return String(this.mutationIdCounter++);
|
||
|
};
|
||
|
QueryManager.prototype.stopQueryInStore = function (queryId) {
|
||
|
this.stopQueryInStoreNoBroadcast(queryId);
|
||
|
this.broadcastQueries();
|
||
|
};
|
||
|
QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
|
||
|
var queryInfo = this.queries.get(queryId);
|
||
|
if (queryInfo)
|
||
|
queryInfo.stop();
|
||
|
};
|
||
|
QueryManager.prototype.clearStore = function (options) {
|
||
|
if (options === void 0) { options = {
|
||
|
discardWatches: true,
|
||
|
}; }
|
||
|
this.cancelPendingFetches(newInvariantError(32));
|
||
|
this.queries.forEach(function (queryInfo) {
|
||
|
if (queryInfo.observableQuery) {
|
||
|
queryInfo.networkStatus = exports.NetworkStatus.loading;
|
||
|
}
|
||
|
else {
|
||
|
queryInfo.stop();
|
||
|
}
|
||
|
});
|
||
|
if (this.mutationStore) {
|
||
|
this.mutationStore = Object.create(null);
|
||
|
}
|
||
|
return this.cache.reset(options);
|
||
|
};
|
||
|
QueryManager.prototype.getObservableQueries = function (include) {
|
||
|
var _this = this;
|
||
|
if (include === void 0) { include = "active"; }
|
||
|
var queries = new Map();
|
||
|
var queryNamesAndDocs = new Map();
|
||
|
var legacyQueryOptions = new Set();
|
||
|
if (Array.isArray(include)) {
|
||
|
include.forEach(function (desc) {
|
||
|
if (typeof desc === "string") {
|
||
|
queryNamesAndDocs.set(desc, false);
|
||
|
}
|
||
|
else if (isDocumentNode(desc)) {
|
||
|
queryNamesAndDocs.set(_this.transform(desc), false);
|
||
|
}
|
||
|
else if (isNonNullObject(desc) && desc.query) {
|
||
|
legacyQueryOptions.add(desc);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
this.queries.forEach(function (_a, queryId) {
|
||
|
var oq = _a.observableQuery, document = _a.document;
|
||
|
if (oq) {
|
||
|
if (include === "all") {
|
||
|
queries.set(queryId, oq);
|
||
|
return;
|
||
|
}
|
||
|
var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;
|
||
|
if (fetchPolicy === "standby" ||
|
||
|
(include === "active" && !oq.hasObservers())) {
|
||
|
return;
|
||
|
}
|
||
|
if (include === "active" ||
|
||
|
(queryName && queryNamesAndDocs.has(queryName)) ||
|
||
|
(document && queryNamesAndDocs.has(document))) {
|
||
|
queries.set(queryId, oq);
|
||
|
if (queryName)
|
||
|
queryNamesAndDocs.set(queryName, true);
|
||
|
if (document)
|
||
|
queryNamesAndDocs.set(document, true);
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
if (legacyQueryOptions.size) {
|
||
|
legacyQueryOptions.forEach(function (options) {
|
||
|
var queryId = makeUniqueId("legacyOneTimeQuery");
|
||
|
var queryInfo = _this.getQuery(queryId).init({
|
||
|
document: options.query,
|
||
|
variables: options.variables,
|
||
|
});
|
||
|
var oq = new ObservableQuery({
|
||
|
queryManager: _this,
|
||
|
queryInfo: queryInfo,
|
||
|
options: tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "network-only" }),
|
||
|
});
|
||
|
invariant(oq.queryId === queryId);
|
||
|
queryInfo.setObservableQuery(oq);
|
||
|
queries.set(queryId, oq);
|
||
|
});
|
||
|
}
|
||
|
if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {
|
||
|
queryNamesAndDocs.forEach(function (included, nameOrDoc) {
|
||
|
if (!included) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === "string" ? 33 : 34, nameOrDoc);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return queries;
|
||
|
};
|
||
|
QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
|
||
|
var _this = this;
|
||
|
if (includeStandby === void 0) { includeStandby = false; }
|
||
|
var observableQueryPromises = [];
|
||
|
this.getObservableQueries(includeStandby ? "all" : "active").forEach(function (observableQuery, queryId) {
|
||
|
var fetchPolicy = observableQuery.options.fetchPolicy;
|
||
|
observableQuery.resetLastResults();
|
||
|
if (includeStandby ||
|
||
|
(fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
|
||
|
observableQueryPromises.push(observableQuery.refetch());
|
||
|
}
|
||
|
_this.getQuery(queryId).setDiff(null);
|
||
|
});
|
||
|
this.broadcastQueries();
|
||
|
return Promise.all(observableQueryPromises);
|
||
|
};
|
||
|
QueryManager.prototype.setObservableQuery = function (observableQuery) {
|
||
|
this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);
|
||
|
};
|
||
|
QueryManager.prototype.startGraphQLSubscription = function (_a) {
|
||
|
var _this = this;
|
||
|
var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? "none" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c;
|
||
|
query = this.transform(query);
|
||
|
variables = this.getVariables(query, variables);
|
||
|
var makeObservable = function (variables) {
|
||
|
return _this.getObservableFromLink(query, context, variables).map(function (result) {
|
||
|
if (fetchPolicy !== "no-cache") {
|
||
|
if (shouldWriteResult(result, errorPolicy)) {
|
||
|
_this.cache.write({
|
||
|
query: query,
|
||
|
result: result.data,
|
||
|
dataId: "ROOT_SUBSCRIPTION",
|
||
|
variables: variables,
|
||
|
});
|
||
|
}
|
||
|
_this.broadcastQueries();
|
||
|
}
|
||
|
var hasErrors = graphQLResultHasError(result);
|
||
|
var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
|
||
|
if (hasErrors || hasProtocolErrors) {
|
||
|
var errors = {};
|
||
|
if (hasErrors) {
|
||
|
errors.graphQLErrors = result.errors;
|
||
|
}
|
||
|
if (hasProtocolErrors) {
|
||
|
errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
|
||
|
}
|
||
|
if (errorPolicy === "none" || hasProtocolErrors) {
|
||
|
throw new ApolloError(errors);
|
||
|
}
|
||
|
}
|
||
|
if (errorPolicy === "ignore") {
|
||
|
delete result.errors;
|
||
|
}
|
||
|
return result;
|
||
|
});
|
||
|
};
|
||
|
if (this.getDocumentInfo(query).hasClientExports) {
|
||
|
var observablePromise_1 = this.localState
|
||
|
.addExportedVariables(query, variables, context)
|
||
|
.then(makeObservable);
|
||
|
return new zenObservableTs.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.fetchCancelFns.delete(queryId);
|
||
|
if (this.queries.has(queryId)) {
|
||
|
this.getQuery(queryId).stop();
|
||
|
this.queries.delete(queryId);
|
||
|
}
|
||
|
};
|
||
|
QueryManager.prototype.broadcastQueries = function () {
|
||
|
if (this.onBroadcast)
|
||
|
this.onBroadcast();
|
||
|
this.queries.forEach(function (info) { return info.notify(); });
|
||
|
};
|
||
|
QueryManager.prototype.getLocalState = function () {
|
||
|
return this.localState;
|
||
|
};
|
||
|
QueryManager.prototype.getObservableFromLink = function (query, context, variables,
|
||
|
deduplication) {
|
||
|
var _this = this;
|
||
|
var _a;
|
||
|
if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }
|
||
|
var observable;
|
||
|
var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;
|
||
|
if (serverQuery) {
|
||
|
var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;
|
||
|
var operation = {
|
||
|
query: serverQuery,
|
||
|
variables: variables,
|
||
|
operationName: getOperationName(serverQuery) || void 0,
|
||
|
context: this.prepareContext(tslib.__assign(tslib.__assign({}, context), { forceFetch: !deduplication })),
|
||
|
};
|
||
|
context = operation.context;
|
||
|
if (deduplication) {
|
||
|
var printedServerQuery_1 = print(serverQuery);
|
||
|
var varJson_1 = canonicalStringify(variables);
|
||
|
var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);
|
||
|
observable = entry.observable;
|
||
|
if (!observable) {
|
||
|
var concast = new Concast([
|
||
|
execute(link, operation),
|
||
|
]);
|
||
|
observable = entry.observable = concast;
|
||
|
concast.beforeNext(function () {
|
||
|
inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
observable = new Concast([
|
||
|
execute(link, operation),
|
||
|
]);
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
observable = new Concast([zenObservableTs.Observable.of({ data: {} })]);
|
||
|
context = this.prepareContext(context);
|
||
|
}
|
||
|
if (clientQuery) {
|
||
|
observable = asyncMap(observable, function (result) {
|
||
|
return _this.localState.runResolvers({
|
||
|
document: clientQuery,
|
||
|
remoteResult: result,
|
||
|
context: context,
|
||
|
variables: variables,
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
return observable;
|
||
|
};
|
||
|
QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {
|
||
|
var requestId = (queryInfo.lastRequestId = this.generateRequestId());
|
||
|
var linkDocument = this.cache.transformForLink(options.query);
|
||
|
return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
|
||
|
var graphQLErrors = getGraphQLErrorsFromResult(result);
|
||
|
var hasErrors = graphQLErrors.length > 0;
|
||
|
if (requestId >= queryInfo.lastRequestId) {
|
||
|
if (hasErrors && options.errorPolicy === "none") {
|
||
|
throw queryInfo.markError(new ApolloError({
|
||
|
graphQLErrors: graphQLErrors,
|
||
|
}));
|
||
|
}
|
||
|
queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
|
||
|
queryInfo.markReady();
|
||
|
}
|
||
|
var aqr = {
|
||
|
data: result.data,
|
||
|
loading: false,
|
||
|
networkStatus: exports.NetworkStatus.ready,
|
||
|
};
|
||
|
if (hasErrors && options.errorPolicy !== "ignore") {
|
||
|
aqr.errors = graphQLErrors;
|
||
|
aqr.networkStatus = exports.NetworkStatus.error;
|
||
|
}
|
||
|
return aqr;
|
||
|
}, function (networkError) {
|
||
|
var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));
|
||
|
if (requestId >= queryInfo.lastRequestId) {
|
||
|
queryInfo.markError(error);
|
||
|
}
|
||
|
throw error;
|
||
|
});
|
||
|
};
|
||
|
QueryManager.prototype.fetchConcastWithInfo = function (queryId, options,
|
||
|
networkStatus, query) {
|
||
|
var _this = this;
|
||
|
if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
|
||
|
if (query === void 0) { query = options.query; }
|
||
|
var variables = this.getVariables(query, options.variables);
|
||
|
var queryInfo = this.getQuery(queryId);
|
||
|
var defaults = this.defaultOptions.watchQuery;
|
||
|
var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || "cache-first" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || "none" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;
|
||
|
var normalized = Object.assign({}, options, {
|
||
|
query: query,
|
||
|
variables: variables,
|
||
|
fetchPolicy: fetchPolicy,
|
||
|
errorPolicy: errorPolicy,
|
||
|
returnPartialData: returnPartialData,
|
||
|
notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,
|
||
|
context: context,
|
||
|
});
|
||
|
var fromVariables = function (variables) {
|
||
|
normalized.variables = variables;
|
||
|
var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
|
||
|
if (
|
||
|
normalized.fetchPolicy !== "standby" &&
|
||
|
sourcesWithInfo.sources.length > 0 &&
|
||
|
queryInfo.observableQuery) {
|
||
|
queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
|
||
|
}
|
||
|
return sourcesWithInfo;
|
||
|
};
|
||
|
var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
|
||
|
this.fetchCancelFns.set(queryId, function (reason) {
|
||
|
cleanupCancelFn();
|
||
|
setTimeout(function () { return concast.cancel(reason); });
|
||
|
});
|
||
|
var concast, containsDataFromLink;
|
||
|
if (this.getDocumentInfo(normalized.query).hasClientExports) {
|
||
|
concast = new Concast(this.localState
|
||
|
.addExportedVariables(normalized.query, normalized.variables, normalized.context)
|
||
|
.then(fromVariables)
|
||
|
.then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
|
||
|
containsDataFromLink = true;
|
||
|
}
|
||
|
else {
|
||
|
var sourcesWithInfo = fromVariables(normalized.variables);
|
||
|
containsDataFromLink = sourcesWithInfo.fromLink;
|
||
|
concast = new Concast(sourcesWithInfo.sources);
|
||
|
}
|
||
|
concast.promise.then(cleanupCancelFn, cleanupCancelFn);
|
||
|
return {
|
||
|
concast: concast,
|
||
|
fromLink: containsDataFromLink,
|
||
|
};
|
||
|
};
|
||
|
QueryManager.prototype.refetchQueries = function (_a) {
|
||
|
var _this = this;
|
||
|
var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId("refetchQueries") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;
|
||
|
var includedQueriesById = new Map();
|
||
|
if (include) {
|
||
|
this.getObservableQueries(include).forEach(function (oq, queryId) {
|
||
|
includedQueriesById.set(queryId, {
|
||
|
oq: oq,
|
||
|
lastDiff: _this.getQuery(queryId).getDiff(),
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
var results = new Map();
|
||
|
if (updateCache) {
|
||
|
this.cache.batch({
|
||
|
update: updateCache,
|
||
|
optimistic: (optimistic && removeOptimistic) || false,
|
||
|
removeOptimistic: removeOptimistic,
|
||
|
onWatchUpdated: function (watch, diff, lastDiff) {
|
||
|
var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
|
||
|
if (oq) {
|
||
|
if (onQueryUpdated) {
|
||
|
includedQueriesById.delete(oq.queryId);
|
||
|
var result = onQueryUpdated(oq, diff, lastDiff);
|
||
|
if (result === true) {
|
||
|
result = oq.refetch();
|
||
|
}
|
||
|
if (result !== false) {
|
||
|
results.set(oq, result);
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
if (onQueryUpdated !== null) {
|
||
|
includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
if (includedQueriesById.size) {
|
||
|
includedQueriesById.forEach(function (_a, queryId) {
|
||
|
var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;
|
||
|
var result;
|
||
|
if (onQueryUpdated) {
|
||
|
if (!diff) {
|
||
|
var info = oq["queryInfo"];
|
||
|
info.reset();
|
||
|
diff = info.getDiff();
|
||
|
}
|
||
|
result = onQueryUpdated(oq, diff, lastDiff);
|
||
|
}
|
||
|
if (!onQueryUpdated || result === true) {
|
||
|
result = oq.refetch();
|
||
|
}
|
||
|
if (result !== false) {
|
||
|
results.set(oq, result);
|
||
|
}
|
||
|
if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
|
||
|
_this.stopQueryNoBroadcast(queryId);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
if (removeOptimistic) {
|
||
|
this.cache.removeOptimistic(removeOptimistic);
|
||
|
}
|
||
|
return results;
|
||
|
};
|
||
|
QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a,
|
||
|
networkStatus) {
|
||
|
var _this = this;
|
||
|
var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
|
||
|
var oldNetworkStatus = queryInfo.networkStatus;
|
||
|
queryInfo.init({
|
||
|
document: query,
|
||
|
variables: variables,
|
||
|
networkStatus: networkStatus,
|
||
|
});
|
||
|
var readCache = function () { return queryInfo.getDiff(); };
|
||
|
var resultsFromCache = function (diff, networkStatus) {
|
||
|
if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }
|
||
|
var data = diff.result;
|
||
|
if (globalThis.__DEV__ !== false && !returnPartialData && !equal.equal(data, {})) {
|
||
|
logMissingFieldErrors(diff.missing);
|
||
|
}
|
||
|
var fromData = function (data) {
|
||
|
return zenObservableTs.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));
|
||
|
};
|
||
|
if (data && _this.getDocumentInfo(query).hasForcedResolvers) {
|
||
|
return _this.localState
|
||
|
.runResolvers({
|
||
|
document: query,
|
||
|
remoteResult: { data: data },
|
||
|
context: context,
|
||
|
variables: variables,
|
||
|
onlyRunForcedResolvers: true,
|
||
|
})
|
||
|
.then(function (resolved) { return fromData(resolved.data || void 0); });
|
||
|
}
|
||
|
if (errorPolicy === "none" &&
|
||
|
networkStatus === exports.NetworkStatus.refetch &&
|
||
|
Array.isArray(diff.missing)) {
|
||
|
return fromData(void 0);
|
||
|
}
|
||
|
return fromData(data);
|
||
|
};
|
||
|
var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0
|
||
|
: (networkStatus === exports.NetworkStatus.refetch &&
|
||
|
refetchWritePolicy !== "merge") ?
|
||
|
1
|
||
|
: 2 ;
|
||
|
var resultsFromLink = function () {
|
||
|
return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
|
||
|
query: query,
|
||
|
variables: variables,
|
||
|
context: context,
|
||
|
fetchPolicy: fetchPolicy,
|
||
|
errorPolicy: errorPolicy,
|
||
|
});
|
||
|
};
|
||
|
var shouldNotify = notifyOnNetworkStatusChange &&
|
||
|
typeof oldNetworkStatus === "number" &&
|
||
|
oldNetworkStatus !== networkStatus &&
|
||
|
isNetworkRequestInFlight(networkStatus);
|
||
|
switch (fetchPolicy) {
|
||
|
default:
|
||
|
case "cache-first": {
|
||
|
var diff = readCache();
|
||
|
if (diff.complete) {
|
||
|
return {
|
||
|
fromLink: false,
|
||
|
sources: [resultsFromCache(diff, queryInfo.markReady())],
|
||
|
};
|
||
|
}
|
||
|
if (returnPartialData || shouldNotify) {
|
||
|
return {
|
||
|
fromLink: true,
|
||
|
sources: [resultsFromCache(diff), resultsFromLink()],
|
||
|
};
|
||
|
}
|
||
|
return { fromLink: true, sources: [resultsFromLink()] };
|
||
|
}
|
||
|
case "cache-and-network": {
|
||
|
var diff = readCache();
|
||
|
if (diff.complete || returnPartialData || shouldNotify) {
|
||
|
return {
|
||
|
fromLink: true,
|
||
|
sources: [resultsFromCache(diff), resultsFromLink()],
|
||
|
};
|
||
|
}
|
||
|
return { fromLink: true, sources: [resultsFromLink()] };
|
||
|
}
|
||
|
case "cache-only":
|
||
|
return {
|
||
|
fromLink: false,
|
||
|
sources: [resultsFromCache(readCache(), queryInfo.markReady())],
|
||
|
};
|
||
|
case "network-only":
|
||
|
if (shouldNotify) {
|
||
|
return {
|
||
|
fromLink: true,
|
||
|
sources: [resultsFromCache(readCache()), resultsFromLink()],
|
||
|
};
|
||
|
}
|
||
|
return { fromLink: true, sources: [resultsFromLink()] };
|
||
|
case "no-cache":
|
||
|
if (shouldNotify) {
|
||
|
return {
|
||
|
fromLink: true,
|
||
|
sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],
|
||
|
};
|
||
|
}
|
||
|
return { fromLink: true, sources: [resultsFromLink()] };
|
||
|
case "standby":
|
||
|
return { fromLink: false, sources: [] };
|
||
|
}
|
||
|
};
|
||
|
QueryManager.prototype.getQuery = function (queryId) {
|
||
|
if (queryId && !this.queries.has(queryId)) {
|
||
|
this.queries.set(queryId, new QueryInfo(this, queryId));
|
||
|
}
|
||
|
return this.queries.get(queryId);
|
||
|
};
|
||
|
QueryManager.prototype.prepareContext = function (context) {
|
||
|
if (context === void 0) { context = {}; }
|
||
|
var newContext = this.localState.prepareContext(context);
|
||
|
return tslib.__assign(tslib.__assign(tslib.__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });
|
||
|
};
|
||
|
return QueryManager;
|
||
|
}());
|
||
|
|
||
|
var hasSuggestedDevtools = false;
|
||
|
var ApolloClient = (function () {
|
||
|
function ApolloClient(options) {
|
||
|
var _this = this;
|
||
|
this.resetStoreCallbacks = [];
|
||
|
this.clearStoreCallbacks = [];
|
||
|
if (!options.cache) {
|
||
|
throw newInvariantError(15);
|
||
|
}
|
||
|
var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b,
|
||
|
_c = options.connectToDevTools,
|
||
|
connectToDevTools = _c === void 0 ? typeof window === "object" &&
|
||
|
!window.__APOLLO_CLIENT__ &&
|
||
|
globalThis.__DEV__ !== false : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? cache.assumeImmutableResults : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
|
||
|
var link = options.link;
|
||
|
if (!link) {
|
||
|
link =
|
||
|
uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();
|
||
|
}
|
||
|
this.link = link;
|
||
|
this.cache = cache;
|
||
|
this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;
|
||
|
this.queryDeduplication = queryDeduplication;
|
||
|
this.defaultOptions = defaultOptions || Object.create(null);
|
||
|
this.typeDefs = typeDefs;
|
||
|
if (ssrForceFetchDelay) {
|
||
|
setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);
|
||
|
}
|
||
|
this.watchQuery = this.watchQuery.bind(this);
|
||
|
this.query = this.query.bind(this);
|
||
|
this.mutate = this.mutate.bind(this);
|
||
|
this.resetStore = this.resetStore.bind(this);
|
||
|
this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);
|
||
|
this.version = version;
|
||
|
this.localState = new LocalState({
|
||
|
cache: cache,
|
||
|
client: this,
|
||
|
resolvers: resolvers,
|
||
|
fragmentMatcher: fragmentMatcher,
|
||
|
});
|
||
|
this.queryManager = new QueryManager({
|
||
|
cache: this.cache,
|
||
|
link: this.link,
|
||
|
defaultOptions: this.defaultOptions,
|
||
|
defaultContext: defaultContext,
|
||
|
documentTransform: documentTransform,
|
||
|
queryDeduplication: queryDeduplication,
|
||
|
ssrMode: ssrMode,
|
||
|
clientAwareness: {
|
||
|
name: clientAwarenessName,
|
||
|
version: clientAwarenessVersion,
|
||
|
},
|
||
|
localState: this.localState,
|
||
|
assumeImmutableResults: assumeImmutableResults,
|
||
|
onBroadcast: connectToDevTools ?
|
||
|
function () {
|
||
|
if (_this.devToolsHookCb) {
|
||
|
_this.devToolsHookCb({
|
||
|
action: {},
|
||
|
state: {
|
||
|
queries: _this.queryManager.getQueryStore(),
|
||
|
mutations: _this.queryManager.mutationStore || {},
|
||
|
},
|
||
|
dataWithOptimisticResults: _this.cache.extract(true),
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
: void 0,
|
||
|
});
|
||
|
if (connectToDevTools)
|
||
|
this.connectToDevTools();
|
||
|
}
|
||
|
ApolloClient.prototype.connectToDevTools = function () {
|
||
|
if (typeof window === "object") {
|
||
|
var windowWithDevTools = window;
|
||
|
var devtoolsSymbol = Symbol.for("apollo.devtools");
|
||
|
(windowWithDevTools[devtoolsSymbol] =
|
||
|
windowWithDevTools[devtoolsSymbol] || []).push(this);
|
||
|
windowWithDevTools.__APOLLO_CLIENT__ = this;
|
||
|
}
|
||
|
if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {
|
||
|
hasSuggestedDevtools = true;
|
||
|
setTimeout(function () {
|
||
|
if (typeof window !== "undefined" &&
|
||
|
window.document &&
|
||
|
window.top === window.self &&
|
||
|
!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {
|
||
|
var nav = window.navigator;
|
||
|
var ua = nav && nav.userAgent;
|
||
|
var url = void 0;
|
||
|
if (typeof ua === "string") {
|
||
|
if (ua.indexOf("Chrome/") > -1) {
|
||
|
url =
|
||
|
"https://chrome.google.com/webstore/detail/" +
|
||
|
"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm";
|
||
|
}
|
||
|
else if (ua.indexOf("Firefox/") > -1) {
|
||
|
url =
|
||
|
"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/";
|
||
|
}
|
||
|
}
|
||
|
if (url) {
|
||
|
globalThis.__DEV__ !== false && invariant.log("Download the Apollo DevTools for a better development " +
|
||
|
"experience: %s", url);
|
||
|
}
|
||
|
}
|
||
|
}, 10000);
|
||
|
}
|
||
|
};
|
||
|
Object.defineProperty(ApolloClient.prototype, "documentTransform", {
|
||
|
get: function () {
|
||
|
return this.queryManager.documentTransform;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
ApolloClient.prototype.stop = function () {
|
||
|
this.queryManager.stop();
|
||
|
};
|
||
|
ApolloClient.prototype.watchQuery = function (options) {
|
||
|
if (this.defaultOptions.watchQuery) {
|
||
|
options = mergeOptions(this.defaultOptions.watchQuery, options);
|
||
|
}
|
||
|
if (this.disableNetworkFetches &&
|
||
|
(options.fetchPolicy === "network-only" ||
|
||
|
options.fetchPolicy === "cache-and-network")) {
|
||
|
options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "cache-first" });
|
||
|
}
|
||
|
return this.queryManager.watchQuery(options);
|
||
|
};
|
||
|
ApolloClient.prototype.query = function (options) {
|
||
|
if (this.defaultOptions.query) {
|
||
|
options = mergeOptions(this.defaultOptions.query, options);
|
||
|
}
|
||
|
invariant(options.fetchPolicy !== "cache-and-network", 16);
|
||
|
if (this.disableNetworkFetches && options.fetchPolicy === "network-only") {
|
||
|
options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "cache-first" });
|
||
|
}
|
||
|
return this.queryManager.query(options);
|
||
|
};
|
||
|
ApolloClient.prototype.mutate = function (options) {
|
||
|
if (this.defaultOptions.mutate) {
|
||
|
options = mergeOptions(this.defaultOptions.mutate, options);
|
||
|
}
|
||
|
return this.queryManager.mutate(options);
|
||
|
};
|
||
|
ApolloClient.prototype.subscribe = function (options) {
|
||
|
return this.queryManager.startGraphQLSubscription(options);
|
||
|
};
|
||
|
ApolloClient.prototype.readQuery = function (options, optimistic) {
|
||
|
if (optimistic === void 0) { optimistic = false; }
|
||
|
return this.cache.readQuery(options, optimistic);
|
||
|
};
|
||
|
ApolloClient.prototype.readFragment = function (options, optimistic) {
|
||
|
if (optimistic === void 0) { optimistic = false; }
|
||
|
return this.cache.readFragment(options, optimistic);
|
||
|
};
|
||
|
ApolloClient.prototype.writeQuery = function (options) {
|
||
|
var ref = this.cache.writeQuery(options);
|
||
|
if (options.broadcast !== false) {
|
||
|
this.queryManager.broadcastQueries();
|
||
|
}
|
||
|
return ref;
|
||
|
};
|
||
|
ApolloClient.prototype.writeFragment = function (options) {
|
||
|
var ref = this.cache.writeFragment(options);
|
||
|
if (options.broadcast !== false) {
|
||
|
this.queryManager.broadcastQueries();
|
||
|
}
|
||
|
return ref;
|
||
|
};
|
||
|
ApolloClient.prototype.__actionHookForDevTools = function (cb) {
|
||
|
this.devToolsHookCb = cb;
|
||
|
};
|
||
|
ApolloClient.prototype.__requestRaw = function (payload) {
|
||
|
return execute(this.link, payload);
|
||
|
};
|
||
|
ApolloClient.prototype.resetStore = function () {
|
||
|
var _this = this;
|
||
|
return Promise.resolve()
|
||
|
.then(function () {
|
||
|
return _this.queryManager.clearStore({
|
||
|
discardWatches: false,
|
||
|
});
|
||
|
})
|
||
|
.then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })
|
||
|
.then(function () { return _this.reFetchObservableQueries(); });
|
||
|
};
|
||
|
ApolloClient.prototype.clearStore = function () {
|
||
|
var _this = this;
|
||
|
return Promise.resolve()
|
||
|
.then(function () {
|
||
|
return _this.queryManager.clearStore({
|
||
|
discardWatches: true,
|
||
|
});
|
||
|
})
|
||
|
.then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });
|
||
|
};
|
||
|
ApolloClient.prototype.onResetStore = function (cb) {
|
||
|
var _this = this;
|
||
|
this.resetStoreCallbacks.push(cb);
|
||
|
return function () {
|
||
|
_this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });
|
||
|
};
|
||
|
};
|
||
|
ApolloClient.prototype.onClearStore = function (cb) {
|
||
|
var _this = this;
|
||
|
this.clearStoreCallbacks.push(cb);
|
||
|
return function () {
|
||
|
_this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });
|
||
|
};
|
||
|
};
|
||
|
ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {
|
||
|
return this.queryManager.reFetchObservableQueries(includeStandby);
|
||
|
};
|
||
|
ApolloClient.prototype.refetchQueries = function (options) {
|
||
|
var map = this.queryManager.refetchQueries(options);
|
||
|
var queries = [];
|
||
|
var results = [];
|
||
|
map.forEach(function (result, obsQuery) {
|
||
|
queries.push(obsQuery);
|
||
|
results.push(result);
|
||
|
});
|
||
|
var result = Promise.all(results);
|
||
|
result.queries = queries;
|
||
|
result.results = results;
|
||
|
result.catch(function (error) {
|
||
|
globalThis.__DEV__ !== false && invariant.debug(17, error);
|
||
|
});
|
||
|
return result;
|
||
|
};
|
||
|
ApolloClient.prototype.getObservableQueries = function (include) {
|
||
|
if (include === void 0) { include = "active"; }
|
||
|
return this.queryManager.getObservableQueries(include);
|
||
|
};
|
||
|
ApolloClient.prototype.extract = function (optimistic) {
|
||
|
return this.cache.extract(optimistic);
|
||
|
};
|
||
|
ApolloClient.prototype.restore = function (serializedState) {
|
||
|
return this.cache.restore(serializedState);
|
||
|
};
|
||
|
ApolloClient.prototype.addResolvers = function (resolvers) {
|
||
|
this.localState.addResolvers(resolvers);
|
||
|
};
|
||
|
ApolloClient.prototype.setResolvers = function (resolvers) {
|
||
|
this.localState.setResolvers(resolvers);
|
||
|
};
|
||
|
ApolloClient.prototype.getResolvers = function () {
|
||
|
return this.localState.getResolvers();
|
||
|
};
|
||
|
ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {
|
||
|
this.localState.setFragmentMatcher(fragmentMatcher);
|
||
|
};
|
||
|
ApolloClient.prototype.setLink = function (newLink) {
|
||
|
this.link = this.queryManager.link = newLink;
|
||
|
};
|
||
|
Object.defineProperty(ApolloClient.prototype, "defaultContext", {
|
||
|
get: function () {
|
||
|
return this.queryManager.defaultContext;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
return ApolloClient;
|
||
|
}());
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;
|
||
|
}
|
||
|
|
||
|
var contextKey = canUseSymbol ? Symbol.for("__APOLLO_CONTEXT__") : "__APOLLO_CONTEXT__";
|
||
|
function getApolloContext() {
|
||
|
invariant("createContext" in React__namespace, 45);
|
||
|
var context = React__namespace.createContext[contextKey];
|
||
|
if (!context) {
|
||
|
Object.defineProperty(React__namespace.createContext, contextKey, {
|
||
|
value: (context = React__namespace.createContext({})),
|
||
|
enumerable: false,
|
||
|
writable: false,
|
||
|
configurable: true,
|
||
|
});
|
||
|
context.displayName = "ApolloContext";
|
||
|
}
|
||
|
return context;
|
||
|
}
|
||
|
var resetApolloContext = getApolloContext;
|
||
|
|
||
|
var ApolloConsumer = function (props) {
|
||
|
var ApolloContext = getApolloContext();
|
||
|
return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
|
||
|
invariant(context && context.client, 44);
|
||
|
return props.children(context.client);
|
||
|
}));
|
||
|
};
|
||
|
|
||
|
var ApolloProvider = function (_a) {
|
||
|
var client = _a.client, children = _a.children;
|
||
|
var ApolloContext = getApolloContext();
|
||
|
var parentContext = React__namespace.useContext(ApolloContext);
|
||
|
var context = React__namespace.useMemo(function () {
|
||
|
return tslib.__assign(tslib.__assign({}, parentContext), { client: client || parentContext.client });
|
||
|
}, [parentContext, client]);
|
||
|
invariant(context.client, 46);
|
||
|
return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
|
||
|
};
|
||
|
|
||
|
function useApolloClient(override) {
|
||
|
var context = React__namespace.useContext(getApolloContext());
|
||
|
var client = override || context.client;
|
||
|
invariant(!!client, 49);
|
||
|
return client;
|
||
|
}
|
||
|
|
||
|
var didWarnUncachedGetSnapshot = false;
|
||
|
var uSESKey = "useSyncExternalStore";
|
||
|
var realHook$1 = React__namespace[uSESKey];
|
||
|
var useSyncExternalStore = realHook$1 ||
|
||
|
(function (subscribe, getSnapshot, getServerSnapshot) {
|
||
|
var value = getSnapshot();
|
||
|
if (
|
||
|
globalThis.__DEV__ !== false &&
|
||
|
!didWarnUncachedGetSnapshot &&
|
||
|
value !== getSnapshot()) {
|
||
|
didWarnUncachedGetSnapshot = true;
|
||
|
globalThis.__DEV__ !== false && invariant.error(58);
|
||
|
}
|
||
|
var _a = React__namespace.useState({
|
||
|
inst: { value: value, getSnapshot: getSnapshot },
|
||
|
}), inst = _a[0].inst, forceUpdate = _a[1];
|
||
|
if (canUseLayoutEffect) {
|
||
|
React__namespace.useLayoutEffect(function () {
|
||
|
Object.assign(inst, { value: value, getSnapshot: getSnapshot });
|
||
|
if (checkIfSnapshotChanged(inst)) {
|
||
|
forceUpdate({ inst: inst });
|
||
|
}
|
||
|
}, [subscribe, value, getSnapshot]);
|
||
|
}
|
||
|
else {
|
||
|
Object.assign(inst, { value: value, getSnapshot: getSnapshot });
|
||
|
}
|
||
|
React__namespace.useEffect(function () {
|
||
|
if (checkIfSnapshotChanged(inst)) {
|
||
|
forceUpdate({ inst: inst });
|
||
|
}
|
||
|
return subscribe(function handleStoreChange() {
|
||
|
if (checkIfSnapshotChanged(inst)) {
|
||
|
forceUpdate({ inst: inst });
|
||
|
}
|
||
|
});
|
||
|
}, [subscribe]);
|
||
|
return value;
|
||
|
});
|
||
|
function checkIfSnapshotChanged(_a) {
|
||
|
var value = _a.value, getSnapshot = _a.getSnapshot;
|
||
|
try {
|
||
|
return value !== getSnapshot();
|
||
|
}
|
||
|
catch (_b) {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
exports.DocumentType = void 0;
|
||
|
(function (DocumentType) {
|
||
|
DocumentType[DocumentType["Query"] = 0] = "Query";
|
||
|
DocumentType[DocumentType["Mutation"] = 1] = "Mutation";
|
||
|
DocumentType[DocumentType["Subscription"] = 2] = "Subscription";
|
||
|
})(exports.DocumentType || (exports.DocumentType = {}));
|
||
|
var cache;
|
||
|
function operationName(type) {
|
||
|
var name;
|
||
|
switch (type) {
|
||
|
case exports.DocumentType.Query:
|
||
|
name = "Query";
|
||
|
break;
|
||
|
case exports.DocumentType.Mutation:
|
||
|
name = "Mutation";
|
||
|
break;
|
||
|
case exports.DocumentType.Subscription:
|
||
|
name = "Subscription";
|
||
|
break;
|
||
|
}
|
||
|
return name;
|
||
|
}
|
||
|
function parser(document) {
|
||
|
if (!cache) {
|
||
|
cache = new AutoCleanedWeakCache(cacheSizes.parser || 1000 );
|
||
|
}
|
||
|
var cached = cache.get(document);
|
||
|
if (cached)
|
||
|
return cached;
|
||
|
var variables, type, name;
|
||
|
invariant(!!document && !!document.kind, 59, document);
|
||
|
var fragments = [];
|
||
|
var queries = [];
|
||
|
var mutations = [];
|
||
|
var subscriptions = [];
|
||
|
for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {
|
||
|
var x = _a[_i];
|
||
|
if (x.kind === "FragmentDefinition") {
|
||
|
fragments.push(x);
|
||
|
continue;
|
||
|
}
|
||
|
if (x.kind === "OperationDefinition") {
|
||
|
switch (x.operation) {
|
||
|
case "query":
|
||
|
queries.push(x);
|
||
|
break;
|
||
|
case "mutation":
|
||
|
mutations.push(x);
|
||
|
break;
|
||
|
case "subscription":
|
||
|
subscriptions.push(x);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
invariant(!fragments.length ||
|
||
|
queries.length ||
|
||
|
mutations.length ||
|
||
|
subscriptions.length, 60);
|
||
|
invariant(
|
||
|
queries.length + mutations.length + subscriptions.length <= 1,
|
||
|
61,
|
||
|
document,
|
||
|
queries.length,
|
||
|
subscriptions.length,
|
||
|
mutations.length
|
||
|
);
|
||
|
type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
|
||
|
if (!queries.length && !mutations.length)
|
||
|
type = exports.DocumentType.Subscription;
|
||
|
var definitions = queries.length ? queries
|
||
|
: mutations.length ? mutations
|
||
|
: subscriptions;
|
||
|
invariant(definitions.length === 1, 62, document, definitions.length);
|
||
|
var definition = definitions[0];
|
||
|
variables = definition.variableDefinitions || [];
|
||
|
if (definition.name && definition.name.kind === "Name") {
|
||
|
name = definition.name.value;
|
||
|
}
|
||
|
else {
|
||
|
name = "data";
|
||
|
}
|
||
|
var payload = { name: name, type: type, variables: variables };
|
||
|
cache.set(document, payload);
|
||
|
return payload;
|
||
|
}
|
||
|
parser.resetCache = function () {
|
||
|
cache = undefined;
|
||
|
};
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
registerGlobalCache("parser", function () { return (cache ? cache.size : 0); });
|
||
|
}
|
||
|
function verifyDocumentType(document, type) {
|
||
|
var operation = parser(document);
|
||
|
var requiredOperationName = operationName(type);
|
||
|
var usedOperationName = operationName(operation.type);
|
||
|
invariant(
|
||
|
operation.type === type,
|
||
|
63,
|
||
|
requiredOperationName,
|
||
|
requiredOperationName,
|
||
|
usedOperationName
|
||
|
);
|
||
|
}
|
||
|
|
||
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
|
function useQuery(query, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
return useInternalState(useApolloClient(options.client), query).useQuery(options);
|
||
|
}
|
||
|
function useInternalState(client, query) {
|
||
|
var stateRef = React__namespace.useRef();
|
||
|
if (!stateRef.current ||
|
||
|
client !== stateRef.current.client ||
|
||
|
query !== stateRef.current.query) {
|
||
|
stateRef.current = new InternalState(client, query, stateRef.current);
|
||
|
}
|
||
|
var state = stateRef.current;
|
||
|
state.forceUpdateState = React__namespace.useReducer(function (tick) { return tick + 1; }, 0)[1];
|
||
|
return state;
|
||
|
}
|
||
|
var InternalState = (function () {
|
||
|
function InternalState(client, query, previous) {
|
||
|
var _this = this;
|
||
|
this.client = client;
|
||
|
this.query = query;
|
||
|
this.forceUpdate = function () { return _this.forceUpdateState(); };
|
||
|
this.ssrDisabledResult = maybeDeepFreeze({
|
||
|
loading: true,
|
||
|
data: void 0,
|
||
|
error: void 0,
|
||
|
networkStatus: exports.NetworkStatus.loading,
|
||
|
});
|
||
|
this.skipStandbyResult = maybeDeepFreeze({
|
||
|
loading: false,
|
||
|
data: void 0,
|
||
|
error: void 0,
|
||
|
networkStatus: exports.NetworkStatus.ready,
|
||
|
});
|
||
|
this.toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)();
|
||
|
verifyDocumentType(query, exports.DocumentType.Query);
|
||
|
var previousResult = previous && previous.result;
|
||
|
var previousData = previousResult && previousResult.data;
|
||
|
if (previousData) {
|
||
|
this.previousData = previousData;
|
||
|
}
|
||
|
}
|
||
|
InternalState.prototype.forceUpdateState = function () {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(51);
|
||
|
};
|
||
|
InternalState.prototype.executeQuery = function (options) {
|
||
|
var _this = this;
|
||
|
var _a;
|
||
|
if (options.query) {
|
||
|
Object.assign(this, { query: options.query });
|
||
|
}
|
||
|
this.watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));
|
||
|
var concast = this.observable.reobserveAsConcast(this.getObsQueryOptions());
|
||
|
this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
|
||
|
this.result = void 0;
|
||
|
this.forceUpdate();
|
||
|
return new Promise(function (resolve) {
|
||
|
var result;
|
||
|
concast.subscribe({
|
||
|
next: function (value) {
|
||
|
result = value;
|
||
|
},
|
||
|
error: function () {
|
||
|
resolve(_this.toQueryResult(_this.observable.getCurrentResult()));
|
||
|
},
|
||
|
complete: function () {
|
||
|
resolve(_this.toQueryResult(result));
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
InternalState.prototype.useQuery = function (options) {
|
||
|
var _this = this;
|
||
|
this.renderPromises = React__namespace.useContext(getApolloContext()).renderPromises;
|
||
|
this.useOptions(options);
|
||
|
var obsQuery = this.useObservableQuery();
|
||
|
var result = useSyncExternalStore(React__namespace.useCallback(function (handleStoreChange) {
|
||
|
if (_this.renderPromises) {
|
||
|
return function () { };
|
||
|
}
|
||
|
_this.forceUpdate = handleStoreChange;
|
||
|
var onNext = function () {
|
||
|
var previousResult = _this.result;
|
||
|
var result = obsQuery.getCurrentResult();
|
||
|
if (previousResult &&
|
||
|
previousResult.loading === result.loading &&
|
||
|
previousResult.networkStatus === result.networkStatus &&
|
||
|
equal.equal(previousResult.data, result.data)) {
|
||
|
return;
|
||
|
}
|
||
|
_this.setResult(result);
|
||
|
};
|
||
|
var onError = function (error) {
|
||
|
subscription.unsubscribe();
|
||
|
subscription = obsQuery.resubscribeAfterError(onNext, onError);
|
||
|
if (!hasOwnProperty.call(error, "graphQLErrors")) {
|
||
|
throw error;
|
||
|
}
|
||
|
var previousResult = _this.result;
|
||
|
if (!previousResult ||
|
||
|
(previousResult && previousResult.loading) ||
|
||
|
!equal.equal(error, previousResult.error)) {
|
||
|
_this.setResult({
|
||
|
data: (previousResult && previousResult.data),
|
||
|
error: error,
|
||
|
loading: false,
|
||
|
networkStatus: exports.NetworkStatus.error,
|
||
|
});
|
||
|
}
|
||
|
};
|
||
|
var subscription = obsQuery.subscribe(onNext, onError);
|
||
|
return function () {
|
||
|
setTimeout(function () { return subscription.unsubscribe(); });
|
||
|
_this.forceUpdate = function () { return _this.forceUpdateState(); };
|
||
|
};
|
||
|
}, [
|
||
|
obsQuery,
|
||
|
this.renderPromises,
|
||
|
this.client.disableNetworkFetches,
|
||
|
]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
|
||
|
this.unsafeHandlePartialRefetch(result);
|
||
|
return this.toQueryResult(result);
|
||
|
};
|
||
|
InternalState.prototype.useOptions = function (options) {
|
||
|
var _a;
|
||
|
var watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));
|
||
|
var currentWatchQueryOptions = this.watchQueryOptions;
|
||
|
if (!equal.equal(watchQueryOptions, currentWatchQueryOptions)) {
|
||
|
this.watchQueryOptions = watchQueryOptions;
|
||
|
if (currentWatchQueryOptions && this.observable) {
|
||
|
this.observable.reobserve(this.getObsQueryOptions());
|
||
|
this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
|
||
|
this.result = void 0;
|
||
|
}
|
||
|
}
|
||
|
this.onCompleted =
|
||
|
options.onCompleted || InternalState.prototype.onCompleted;
|
||
|
this.onError = options.onError || InternalState.prototype.onError;
|
||
|
if ((this.renderPromises || this.client.disableNetworkFetches) &&
|
||
|
this.queryHookOptions.ssr === false &&
|
||
|
!this.queryHookOptions.skip) {
|
||
|
this.result = this.ssrDisabledResult;
|
||
|
}
|
||
|
else if (this.queryHookOptions.skip ||
|
||
|
this.watchQueryOptions.fetchPolicy === "standby") {
|
||
|
this.result = this.skipStandbyResult;
|
||
|
}
|
||
|
else if (this.result === this.ssrDisabledResult ||
|
||
|
this.result === this.skipStandbyResult) {
|
||
|
this.result = void 0;
|
||
|
}
|
||
|
};
|
||
|
InternalState.prototype.getObsQueryOptions = function () {
|
||
|
var toMerge = [];
|
||
|
var globalDefaults = this.client.defaultOptions.watchQuery;
|
||
|
if (globalDefaults)
|
||
|
toMerge.push(globalDefaults);
|
||
|
if (this.queryHookOptions.defaultOptions) {
|
||
|
toMerge.push(this.queryHookOptions.defaultOptions);
|
||
|
}
|
||
|
toMerge.push(compact(this.observable && this.observable.options, this.watchQueryOptions));
|
||
|
return toMerge.reduce(mergeOptions);
|
||
|
};
|
||
|
InternalState.prototype.createWatchQueryOptions = function (_a) {
|
||
|
var _b;
|
||
|
if (_a === void 0) { _a = {}; }
|
||
|
var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.defaultOptions;
|
||
|
var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "defaultOptions"]);
|
||
|
var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
|
||
|
if (this.renderPromises &&
|
||
|
(watchQueryOptions.fetchPolicy === "network-only" ||
|
||
|
watchQueryOptions.fetchPolicy === "cache-and-network")) {
|
||
|
watchQueryOptions.fetchPolicy = "cache-first";
|
||
|
}
|
||
|
if (!watchQueryOptions.variables) {
|
||
|
watchQueryOptions.variables = {};
|
||
|
}
|
||
|
if (skip) {
|
||
|
var _c = watchQueryOptions.fetchPolicy, fetchPolicy = _c === void 0 ? this.getDefaultFetchPolicy() : _c, _d = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _d === void 0 ? fetchPolicy : _d;
|
||
|
Object.assign(watchQueryOptions, {
|
||
|
initialFetchPolicy: initialFetchPolicy,
|
||
|
fetchPolicy: "standby",
|
||
|
});
|
||
|
}
|
||
|
else if (!watchQueryOptions.fetchPolicy) {
|
||
|
watchQueryOptions.fetchPolicy =
|
||
|
((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||
|
||
|
this.getDefaultFetchPolicy();
|
||
|
}
|
||
|
return watchQueryOptions;
|
||
|
};
|
||
|
InternalState.prototype.getDefaultFetchPolicy = function () {
|
||
|
var _a, _b;
|
||
|
return (((_a = this.queryHookOptions.defaultOptions) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
|
||
|
((_b = this.client.defaultOptions.watchQuery) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
|
||
|
"cache-first");
|
||
|
};
|
||
|
InternalState.prototype.onCompleted = function (data) { };
|
||
|
InternalState.prototype.onError = function (error) { };
|
||
|
InternalState.prototype.useObservableQuery = function () {
|
||
|
var obsQuery = (this.observable =
|
||
|
(this.renderPromises &&
|
||
|
this.renderPromises.getSSRObservable(this.watchQueryOptions)) ||
|
||
|
this.observable ||
|
||
|
this.client.watchQuery(this.getObsQueryOptions()));
|
||
|
this.obsQueryFields = React__namespace.useMemo(function () { return ({
|
||
|
refetch: obsQuery.refetch.bind(obsQuery),
|
||
|
reobserve: obsQuery.reobserve.bind(obsQuery),
|
||
|
fetchMore: obsQuery.fetchMore.bind(obsQuery),
|
||
|
updateQuery: obsQuery.updateQuery.bind(obsQuery),
|
||
|
startPolling: obsQuery.startPolling.bind(obsQuery),
|
||
|
stopPolling: obsQuery.stopPolling.bind(obsQuery),
|
||
|
subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
|
||
|
}); }, [obsQuery]);
|
||
|
var ssrAllowed = !(this.queryHookOptions.ssr === false || this.queryHookOptions.skip);
|
||
|
if (this.renderPromises && ssrAllowed) {
|
||
|
this.renderPromises.registerSSRObservable(obsQuery);
|
||
|
if (obsQuery.getCurrentResult().loading) {
|
||
|
this.renderPromises.addObservableQueryPromise(obsQuery);
|
||
|
}
|
||
|
}
|
||
|
return obsQuery;
|
||
|
};
|
||
|
InternalState.prototype.setResult = function (nextResult) {
|
||
|
var previousResult = this.result;
|
||
|
if (previousResult && previousResult.data) {
|
||
|
this.previousData = previousResult.data;
|
||
|
}
|
||
|
this.result = nextResult;
|
||
|
this.forceUpdate();
|
||
|
this.handleErrorOrCompleted(nextResult, previousResult);
|
||
|
};
|
||
|
InternalState.prototype.handleErrorOrCompleted = function (result, previousResult) {
|
||
|
var _this = this;
|
||
|
if (!result.loading) {
|
||
|
var error_1 = this.toApolloError(result);
|
||
|
Promise.resolve()
|
||
|
.then(function () {
|
||
|
if (error_1) {
|
||
|
_this.onError(error_1);
|
||
|
}
|
||
|
else if (result.data &&
|
||
|
(previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
|
||
|
result.networkStatus === exports.NetworkStatus.ready) {
|
||
|
_this.onCompleted(result.data);
|
||
|
}
|
||
|
})
|
||
|
.catch(function (error) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(error);
|
||
|
});
|
||
|
}
|
||
|
};
|
||
|
InternalState.prototype.toApolloError = function (result) {
|
||
|
return isNonEmptyArray(result.errors) ?
|
||
|
new ApolloError({ graphQLErrors: result.errors })
|
||
|
: result.error;
|
||
|
};
|
||
|
InternalState.prototype.getCurrentResult = function () {
|
||
|
if (!this.result) {
|
||
|
this.handleErrorOrCompleted((this.result = this.observable.getCurrentResult()));
|
||
|
}
|
||
|
return this.result;
|
||
|
};
|
||
|
InternalState.prototype.toQueryResult = function (result) {
|
||
|
var queryResult = this.toQueryResultCache.get(result);
|
||
|
if (queryResult)
|
||
|
return queryResult;
|
||
|
var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, ["data", "partial"]);
|
||
|
this.toQueryResultCache.set(result, (queryResult = tslib.__assign(tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), this.obsQueryFields), { client: this.client, observable: this.observable, variables: this.observable.variables, called: !this.queryHookOptions.skip, previousData: this.previousData })));
|
||
|
if (!queryResult.error && isNonEmptyArray(result.errors)) {
|
||
|
queryResult.error = new ApolloError({ graphQLErrors: result.errors });
|
||
|
}
|
||
|
return queryResult;
|
||
|
};
|
||
|
InternalState.prototype.unsafeHandlePartialRefetch = function (result) {
|
||
|
if (result.partial &&
|
||
|
this.queryHookOptions.partialRefetch &&
|
||
|
!result.loading &&
|
||
|
(!result.data || Object.keys(result.data).length === 0) &&
|
||
|
this.observable.options.fetchPolicy !== "cache-only") {
|
||
|
Object.assign(result, {
|
||
|
loading: true,
|
||
|
networkStatus: exports.NetworkStatus.refetch,
|
||
|
});
|
||
|
this.observable.refetch();
|
||
|
}
|
||
|
};
|
||
|
return InternalState;
|
||
|
}());
|
||
|
|
||
|
var EAGER_METHODS = [
|
||
|
"refetch",
|
||
|
"reobserve",
|
||
|
"fetchMore",
|
||
|
"updateQuery",
|
||
|
"startPolling",
|
||
|
"subscribeToMore",
|
||
|
];
|
||
|
function useLazyQuery(query, options) {
|
||
|
var _a;
|
||
|
var execOptionsRef = React__namespace.useRef();
|
||
|
var optionsRef = React__namespace.useRef();
|
||
|
var queryRef = React__namespace.useRef();
|
||
|
var merged = mergeOptions(options, execOptionsRef.current || {});
|
||
|
var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;
|
||
|
optionsRef.current = options;
|
||
|
queryRef.current = document;
|
||
|
var internalState = useInternalState(useApolloClient(options && options.client), document);
|
||
|
var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current }));
|
||
|
var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
|
||
|
internalState.getDefaultFetchPolicy();
|
||
|
var result = Object.assign(useQueryResult, {
|
||
|
called: !!execOptionsRef.current,
|
||
|
});
|
||
|
var eagerMethods = React__namespace.useMemo(function () {
|
||
|
var eagerMethods = {};
|
||
|
var _loop_1 = function (key) {
|
||
|
var method = result[key];
|
||
|
eagerMethods[key] = function () {
|
||
|
if (!execOptionsRef.current) {
|
||
|
execOptionsRef.current = Object.create(null);
|
||
|
internalState.forceUpdateState();
|
||
|
}
|
||
|
return method.apply(this, arguments);
|
||
|
};
|
||
|
};
|
||
|
for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
|
||
|
var key = EAGER_METHODS_1[_i];
|
||
|
_loop_1(key);
|
||
|
}
|
||
|
return eagerMethods;
|
||
|
}, []);
|
||
|
Object.assign(result, eagerMethods);
|
||
|
var execute = React__namespace.useCallback(function (executeOptions) {
|
||
|
execOptionsRef.current =
|
||
|
executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
|
||
|
fetchPolicy: initialFetchPolicy,
|
||
|
};
|
||
|
var options = mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));
|
||
|
var promise = internalState
|
||
|
.executeQuery(tslib.__assign(tslib.__assign({}, options), { skip: false }))
|
||
|
.then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
|
||
|
promise.catch(function () { });
|
||
|
return promise;
|
||
|
}, []);
|
||
|
return [execute, result];
|
||
|
}
|
||
|
|
||
|
function useMutation(mutation, options) {
|
||
|
var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
|
||
|
verifyDocumentType(mutation, exports.DocumentType.Mutation);
|
||
|
var _a = React__namespace.useState({
|
||
|
called: false,
|
||
|
loading: false,
|
||
|
client: client,
|
||
|
}), result = _a[0], setResult = _a[1];
|
||
|
var ref = React__namespace.useRef({
|
||
|
result: result,
|
||
|
mutationId: 0,
|
||
|
isMounted: true,
|
||
|
client: client,
|
||
|
mutation: mutation,
|
||
|
options: options,
|
||
|
});
|
||
|
{
|
||
|
Object.assign(ref.current, { client: client, options: options, mutation: mutation });
|
||
|
}
|
||
|
var execute = React__namespace.useCallback(function (executeOptions) {
|
||
|
if (executeOptions === void 0) { executeOptions = {}; }
|
||
|
var _a = ref.current, options = _a.options, mutation = _a.mutation;
|
||
|
var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
|
||
|
var client = executeOptions.client || ref.current.client;
|
||
|
if (!ref.current.result.loading &&
|
||
|
!baseOptions.ignoreResults &&
|
||
|
ref.current.isMounted) {
|
||
|
setResult((ref.current.result = {
|
||
|
loading: true,
|
||
|
error: void 0,
|
||
|
data: void 0,
|
||
|
called: true,
|
||
|
client: client,
|
||
|
}));
|
||
|
}
|
||
|
var mutationId = ++ref.current.mutationId;
|
||
|
var clientOptions = mergeOptions(baseOptions, executeOptions);
|
||
|
return client
|
||
|
.mutate(clientOptions)
|
||
|
.then(function (response) {
|
||
|
var _a, _b;
|
||
|
var data = response.data, errors = response.errors;
|
||
|
var error = errors && errors.length > 0 ?
|
||
|
new ApolloError({ graphQLErrors: errors })
|
||
|
: void 0;
|
||
|
var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
|
||
|
if (error && onError) {
|
||
|
onError(error, clientOptions);
|
||
|
}
|
||
|
if (mutationId === ref.current.mutationId &&
|
||
|
!clientOptions.ignoreResults) {
|
||
|
var result_1 = {
|
||
|
called: true,
|
||
|
loading: false,
|
||
|
data: data,
|
||
|
error: error,
|
||
|
client: client,
|
||
|
};
|
||
|
if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {
|
||
|
setResult((ref.current.result = result_1));
|
||
|
}
|
||
|
}
|
||
|
var onCompleted = executeOptions.onCompleted || ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onCompleted);
|
||
|
if (!error) {
|
||
|
onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);
|
||
|
}
|
||
|
return response;
|
||
|
})
|
||
|
.catch(function (error) {
|
||
|
var _a;
|
||
|
if (mutationId === ref.current.mutationId && ref.current.isMounted) {
|
||
|
var result_2 = {
|
||
|
loading: false,
|
||
|
error: error,
|
||
|
data: void 0,
|
||
|
called: true,
|
||
|
client: client,
|
||
|
};
|
||
|
if (!equal.equal(ref.current.result, result_2)) {
|
||
|
setResult((ref.current.result = result_2));
|
||
|
}
|
||
|
}
|
||
|
var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
|
||
|
if (onError) {
|
||
|
onError(error, clientOptions);
|
||
|
return { data: void 0, errors: error };
|
||
|
}
|
||
|
throw error;
|
||
|
});
|
||
|
}, []);
|
||
|
var reset = React__namespace.useCallback(function () {
|
||
|
if (ref.current.isMounted) {
|
||
|
var result_3 = { called: false, loading: false, client: client };
|
||
|
Object.assign(ref.current, { mutationId: 0, result: result_3 });
|
||
|
setResult(result_3);
|
||
|
}
|
||
|
}, []);
|
||
|
React__namespace.useEffect(function () {
|
||
|
ref.current.isMounted = true;
|
||
|
return function () {
|
||
|
ref.current.isMounted = false;
|
||
|
};
|
||
|
}, []);
|
||
|
return [execute, tslib.__assign({ reset: reset }, result)];
|
||
|
}
|
||
|
|
||
|
function useSubscription(subscription, options) {
|
||
|
var hasIssuedDeprecationWarningRef = React__namespace.useRef(false);
|
||
|
var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
|
||
|
verifyDocumentType(subscription, exports.DocumentType.Subscription);
|
||
|
var _a = React__namespace.useState({
|
||
|
loading: !(options === null || options === void 0 ? void 0 : options.skip),
|
||
|
error: void 0,
|
||
|
data: void 0,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
}), result = _a[0], setResult = _a[1];
|
||
|
if (!hasIssuedDeprecationWarningRef.current) {
|
||
|
hasIssuedDeprecationWarningRef.current = true;
|
||
|
if (options === null || options === void 0 ? void 0 : options.onSubscriptionData) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(options.onData ? 52 : 53);
|
||
|
}
|
||
|
if (options === null || options === void 0 ? void 0 : options.onSubscriptionComplete) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(options.onComplete ? 54 : 55);
|
||
|
}
|
||
|
}
|
||
|
var _b = React__namespace.useState(function () {
|
||
|
if (options === null || options === void 0 ? void 0 : options.skip) {
|
||
|
return null;
|
||
|
}
|
||
|
return client.subscribe({
|
||
|
query: subscription,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
|
||
|
context: options === null || options === void 0 ? void 0 : options.context,
|
||
|
});
|
||
|
}), observable = _b[0], setObservable = _b[1];
|
||
|
var canResetObservableRef = React__namespace.useRef(false);
|
||
|
React__namespace.useEffect(function () {
|
||
|
return function () {
|
||
|
canResetObservableRef.current = true;
|
||
|
};
|
||
|
}, []);
|
||
|
var ref = React__namespace.useRef({ client: client, subscription: subscription, options: options });
|
||
|
React__namespace.useEffect(function () {
|
||
|
var _a, _b, _c, _d;
|
||
|
var shouldResubscribe = options === null || options === void 0 ? void 0 : options.shouldResubscribe;
|
||
|
if (typeof shouldResubscribe === "function") {
|
||
|
shouldResubscribe = !!shouldResubscribe(options);
|
||
|
}
|
||
|
if (options === null || options === void 0 ? void 0 : options.skip) {
|
||
|
if (!(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip) ||
|
||
|
canResetObservableRef.current) {
|
||
|
setResult({
|
||
|
loading: false,
|
||
|
data: void 0,
|
||
|
error: void 0,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
});
|
||
|
setObservable(null);
|
||
|
canResetObservableRef.current = false;
|
||
|
}
|
||
|
}
|
||
|
else if ((shouldResubscribe !== false &&
|
||
|
(client !== ref.current.client ||
|
||
|
subscription !== ref.current.subscription ||
|
||
|
(options === null || options === void 0 ? void 0 : options.fetchPolicy) !== ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
|
||
|
!(options === null || options === void 0 ? void 0 : options.skip) !== !((_c = ref.current.options) === null || _c === void 0 ? void 0 : _c.skip) ||
|
||
|
!equal.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
|
||
|
canResetObservableRef.current) {
|
||
|
setResult({
|
||
|
loading: true,
|
||
|
data: void 0,
|
||
|
error: void 0,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
});
|
||
|
setObservable(client.subscribe({
|
||
|
query: subscription,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
|
||
|
context: options === null || options === void 0 ? void 0 : options.context,
|
||
|
}));
|
||
|
canResetObservableRef.current = false;
|
||
|
}
|
||
|
Object.assign(ref.current, { client: client, subscription: subscription, options: options });
|
||
|
}, [client, subscription, options, canResetObservableRef.current]);
|
||
|
React__namespace.useEffect(function () {
|
||
|
if (!observable) {
|
||
|
return;
|
||
|
}
|
||
|
var subscriptionStopped = false;
|
||
|
var subscription = observable.subscribe({
|
||
|
next: function (fetchResult) {
|
||
|
var _a, _b;
|
||
|
if (subscriptionStopped) {
|
||
|
return;
|
||
|
}
|
||
|
var result = {
|
||
|
loading: false,
|
||
|
data: fetchResult.data,
|
||
|
error: void 0,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
};
|
||
|
setResult(result);
|
||
|
if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onData) {
|
||
|
ref.current.options.onData({
|
||
|
client: client,
|
||
|
data: result,
|
||
|
});
|
||
|
}
|
||
|
else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionData) {
|
||
|
ref.current.options.onSubscriptionData({
|
||
|
client: client,
|
||
|
subscriptionData: result,
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
error: function (error) {
|
||
|
var _a, _b;
|
||
|
if (!subscriptionStopped) {
|
||
|
setResult({
|
||
|
loading: false,
|
||
|
data: void 0,
|
||
|
error: error,
|
||
|
variables: options === null || options === void 0 ? void 0 : options.variables,
|
||
|
});
|
||
|
(_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
|
||
|
}
|
||
|
},
|
||
|
complete: function () {
|
||
|
var _a, _b;
|
||
|
if (!subscriptionStopped) {
|
||
|
if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onComplete) {
|
||
|
ref.current.options.onComplete();
|
||
|
}
|
||
|
else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionComplete) {
|
||
|
ref.current.options.onSubscriptionComplete();
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
return function () {
|
||
|
subscriptionStopped = true;
|
||
|
setTimeout(function () {
|
||
|
subscription.unsubscribe();
|
||
|
});
|
||
|
};
|
||
|
}, [observable]);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
function useReactiveVar(rv) {
|
||
|
return useSyncExternalStore(React__namespace.useCallback(function (update) {
|
||
|
return rv.onNextChange(function onNext() {
|
||
|
update();
|
||
|
rv.onNextChange(onNext);
|
||
|
});
|
||
|
}, [rv]), rv, rv);
|
||
|
}
|
||
|
|
||
|
function useDeepMemo(memoFn, deps) {
|
||
|
var ref = React__namespace.useRef();
|
||
|
if (!ref.current || !equal.equal(ref.current.deps, deps)) {
|
||
|
ref.current = { value: memoFn(), deps: deps };
|
||
|
}
|
||
|
return ref.current.value;
|
||
|
}
|
||
|
|
||
|
function getRenderDispatcher() {
|
||
|
var _a, _b;
|
||
|
return (_b = (_a = React__namespace.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _a === void 0 ? void 0 : _a.ReactCurrentDispatcher) === null || _b === void 0 ? void 0 : _b.current;
|
||
|
}
|
||
|
var RenderDispatcher = null;
|
||
|
function useRenderGuard() {
|
||
|
RenderDispatcher = getRenderDispatcher();
|
||
|
return React__namespace.useCallback(function () {
|
||
|
return (RenderDispatcher !== null && RenderDispatcher === getRenderDispatcher());
|
||
|
}, []);
|
||
|
}
|
||
|
|
||
|
var INIT = {};
|
||
|
function useLazyRef(getInitialValue) {
|
||
|
var ref = React__namespace.useRef(INIT);
|
||
|
if (ref.current === INIT) {
|
||
|
ref.current = getInitialValue();
|
||
|
}
|
||
|
return ref;
|
||
|
}
|
||
|
|
||
|
var useKey = "use";
|
||
|
var realHook = React__namespace[useKey];
|
||
|
var __use = realHook ||
|
||
|
function __use(promise) {
|
||
|
var statefulPromise = wrapPromiseWithState(promise);
|
||
|
switch (statefulPromise.status) {
|
||
|
case "pending":
|
||
|
throw statefulPromise;
|
||
|
case "rejected":
|
||
|
throw statefulPromise.reason;
|
||
|
case "fulfilled":
|
||
|
return statefulPromise.value;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
function useFragment(options) {
|
||
|
var cache = useApolloClient(options.client).cache;
|
||
|
var diffOptions = useDeepMemo(function () {
|
||
|
var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, rest = tslib.__rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
|
||
|
return tslib.__assign(tslib.__assign({}, rest), { returnPartialData: true, id: typeof from === "string" ? from : cache.identify(from), query: cache["getFragmentDoc"](fragment, fragmentName), optimistic: optimistic });
|
||
|
}, [options]);
|
||
|
var resultRef = useLazyRef(function () {
|
||
|
return diffToResult(cache.diff(diffOptions));
|
||
|
});
|
||
|
var getSnapshot = React__namespace.useCallback(function () { return resultRef.current; }, []);
|
||
|
return useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {
|
||
|
var lastTimeout = 0;
|
||
|
var unsubscribe = cache.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
|
||
|
if (!equal.equal(diff.result, resultRef.current.data)) {
|
||
|
resultRef.current = diffToResult(diff);
|
||
|
clearTimeout(lastTimeout);
|
||
|
lastTimeout = setTimeout(forceUpdate);
|
||
|
}
|
||
|
} }));
|
||
|
return function () {
|
||
|
unsubscribe();
|
||
|
clearTimeout(lastTimeout);
|
||
|
};
|
||
|
}, [cache, diffOptions]), getSnapshot, getSnapshot);
|
||
|
}
|
||
|
function diffToResult(diff) {
|
||
|
var result = {
|
||
|
data: diff.result,
|
||
|
complete: !!diff.complete,
|
||
|
};
|
||
|
if (diff.missing) {
|
||
|
result.missing = mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
var QUERY_REFERENCE_SYMBOL = Symbol();
|
||
|
var PROMISE_SYMBOL = Symbol();
|
||
|
function wrapQueryRef(internalQueryRef) {
|
||
|
var _a;
|
||
|
var ref = (_a = {
|
||
|
toPromise: function () {
|
||
|
return getWrappedPromise(ref).then(function () { return ref; });
|
||
|
}
|
||
|
},
|
||
|
_a[QUERY_REFERENCE_SYMBOL] = internalQueryRef,
|
||
|
_a[PROMISE_SYMBOL] = internalQueryRef.promise,
|
||
|
_a);
|
||
|
return ref;
|
||
|
}
|
||
|
function getWrappedPromise(queryRef) {
|
||
|
var internalQueryRef = unwrapQueryRef(queryRef);
|
||
|
return internalQueryRef.promise.status === "fulfilled" ?
|
||
|
internalQueryRef.promise
|
||
|
: queryRef[PROMISE_SYMBOL];
|
||
|
}
|
||
|
function unwrapQueryRef(queryRef) {
|
||
|
return queryRef[QUERY_REFERENCE_SYMBOL];
|
||
|
}
|
||
|
function updateWrappedQueryRef(queryRef, promise) {
|
||
|
queryRef[PROMISE_SYMBOL] = promise;
|
||
|
}
|
||
|
var OBSERVED_CHANGED_OPTIONS = [
|
||
|
"canonizeResults",
|
||
|
"context",
|
||
|
"errorPolicy",
|
||
|
"fetchPolicy",
|
||
|
"refetchWritePolicy",
|
||
|
"returnPartialData",
|
||
|
];
|
||
|
var InternalQueryReference = (function () {
|
||
|
function InternalQueryReference(observable, options) {
|
||
|
var _this = this;
|
||
|
this.key = {};
|
||
|
this.listeners = new Set();
|
||
|
this.references = 0;
|
||
|
this.handleNext = this.handleNext.bind(this);
|
||
|
this.handleError = this.handleError.bind(this);
|
||
|
this.dispose = this.dispose.bind(this);
|
||
|
this.observable = observable;
|
||
|
if (options.onDispose) {
|
||
|
this.onDispose = options.onDispose;
|
||
|
}
|
||
|
this.setResult();
|
||
|
this.subscribeToQuery();
|
||
|
var startDisposeTimer = function () {
|
||
|
var _a;
|
||
|
if (!_this.references) {
|
||
|
_this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
|
||
|
}
|
||
|
};
|
||
|
this.promise.then(startDisposeTimer, startDisposeTimer);
|
||
|
}
|
||
|
Object.defineProperty(InternalQueryReference.prototype, "disposed", {
|
||
|
get: function () {
|
||
|
return this.subscription.closed;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
Object.defineProperty(InternalQueryReference.prototype, "watchQueryOptions", {
|
||
|
get: function () {
|
||
|
return this.observable.options;
|
||
|
},
|
||
|
enumerable: false,
|
||
|
configurable: true
|
||
|
});
|
||
|
InternalQueryReference.prototype.reinitialize = function () {
|
||
|
var observable = this.observable;
|
||
|
var originalFetchPolicy = this.watchQueryOptions.fetchPolicy;
|
||
|
try {
|
||
|
if (originalFetchPolicy !== "no-cache") {
|
||
|
observable.resetLastResults();
|
||
|
observable.silentSetOptions({ fetchPolicy: "cache-first" });
|
||
|
}
|
||
|
else {
|
||
|
observable.silentSetOptions({ fetchPolicy: "standby" });
|
||
|
}
|
||
|
this.subscribeToQuery();
|
||
|
if (originalFetchPolicy === "no-cache") {
|
||
|
return;
|
||
|
}
|
||
|
observable.resetDiff();
|
||
|
this.setResult();
|
||
|
}
|
||
|
finally {
|
||
|
observable.silentSetOptions({ fetchPolicy: originalFetchPolicy });
|
||
|
}
|
||
|
};
|
||
|
InternalQueryReference.prototype.retain = function () {
|
||
|
var _this = this;
|
||
|
this.references++;
|
||
|
clearTimeout(this.autoDisposeTimeoutId);
|
||
|
var disposed = false;
|
||
|
return function () {
|
||
|
if (disposed) {
|
||
|
return;
|
||
|
}
|
||
|
disposed = true;
|
||
|
_this.references--;
|
||
|
setTimeout(function () {
|
||
|
if (!_this.references) {
|
||
|
_this.dispose();
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
};
|
||
|
InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) {
|
||
|
var _this = this;
|
||
|
return OBSERVED_CHANGED_OPTIONS.some(function (option) {
|
||
|
return !equal.equal(_this.watchQueryOptions[option], watchQueryOptions[option]);
|
||
|
});
|
||
|
};
|
||
|
InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) {
|
||
|
var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults;
|
||
|
if (currentFetchPolicy === "standby" &&
|
||
|
currentFetchPolicy !== watchQueryOptions.fetchPolicy) {
|
||
|
this.initiateFetch(this.observable.reobserve(watchQueryOptions));
|
||
|
}
|
||
|
else {
|
||
|
this.observable.silentSetOptions(watchQueryOptions);
|
||
|
if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {
|
||
|
this.result = tslib.__assign(tslib.__assign({}, this.result), this.observable.getCurrentResult());
|
||
|
this.promise = createFulfilledPromise(this.result);
|
||
|
}
|
||
|
}
|
||
|
return this.promise;
|
||
|
};
|
||
|
InternalQueryReference.prototype.listen = function (listener) {
|
||
|
var _this = this;
|
||
|
this.listeners.add(listener);
|
||
|
return function () {
|
||
|
_this.listeners.delete(listener);
|
||
|
};
|
||
|
};
|
||
|
InternalQueryReference.prototype.refetch = function (variables) {
|
||
|
return this.initiateFetch(this.observable.refetch(variables));
|
||
|
};
|
||
|
InternalQueryReference.prototype.fetchMore = function (options) {
|
||
|
return this.initiateFetch(this.observable.fetchMore(options));
|
||
|
};
|
||
|
InternalQueryReference.prototype.dispose = function () {
|
||
|
this.subscription.unsubscribe();
|
||
|
this.onDispose();
|
||
|
};
|
||
|
InternalQueryReference.prototype.onDispose = function () {
|
||
|
};
|
||
|
InternalQueryReference.prototype.handleNext = function (result) {
|
||
|
var _a;
|
||
|
switch (this.promise.status) {
|
||
|
case "pending": {
|
||
|
if (result.data === void 0) {
|
||
|
result.data = this.result.data;
|
||
|
}
|
||
|
this.result = result;
|
||
|
(_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);
|
||
|
break;
|
||
|
}
|
||
|
default: {
|
||
|
if (result.data === this.result.data &&
|
||
|
result.networkStatus === this.result.networkStatus) {
|
||
|
return;
|
||
|
}
|
||
|
if (result.data === void 0) {
|
||
|
result.data = this.result.data;
|
||
|
}
|
||
|
this.result = result;
|
||
|
this.promise = createFulfilledPromise(result);
|
||
|
this.deliver(this.promise);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
InternalQueryReference.prototype.handleError = function (error) {
|
||
|
var _a;
|
||
|
this.subscription.unsubscribe();
|
||
|
this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError);
|
||
|
switch (this.promise.status) {
|
||
|
case "pending": {
|
||
|
(_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);
|
||
|
break;
|
||
|
}
|
||
|
default: {
|
||
|
this.promise = createRejectedPromise(error);
|
||
|
this.deliver(this.promise);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
InternalQueryReference.prototype.deliver = function (promise) {
|
||
|
this.listeners.forEach(function (listener) { return listener(promise); });
|
||
|
};
|
||
|
InternalQueryReference.prototype.initiateFetch = function (returnedPromise) {
|
||
|
var _this = this;
|
||
|
this.promise = this.createPendingPromise();
|
||
|
this.promise.catch(function () { });
|
||
|
returnedPromise
|
||
|
.then(function (result) {
|
||
|
var _a;
|
||
|
if (_this.promise.status === "pending") {
|
||
|
_this.result = result;
|
||
|
(_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, result);
|
||
|
}
|
||
|
})
|
||
|
.catch(function () { });
|
||
|
return returnedPromise;
|
||
|
};
|
||
|
InternalQueryReference.prototype.subscribeToQuery = function () {
|
||
|
var _this = this;
|
||
|
this.subscription = this.observable
|
||
|
.filter(function (result) { return !equal.equal(result.data, {}) && !equal.equal(result, _this.result); })
|
||
|
.subscribe(this.handleNext, this.handleError);
|
||
|
};
|
||
|
InternalQueryReference.prototype.setResult = function () {
|
||
|
var result = this.observable.getCurrentResult(false);
|
||
|
if (equal.equal(result, this.result)) {
|
||
|
return;
|
||
|
}
|
||
|
this.result = result;
|
||
|
this.promise =
|
||
|
(result.data &&
|
||
|
(!result.partial || this.watchQueryOptions.returnPartialData)) ?
|
||
|
createFulfilledPromise(result)
|
||
|
: this.createPendingPromise();
|
||
|
};
|
||
|
InternalQueryReference.prototype.createPendingPromise = function () {
|
||
|
var _this = this;
|
||
|
return wrapPromiseWithState(new Promise(function (resolve, reject) {
|
||
|
_this.resolve = resolve;
|
||
|
_this.reject = reject;
|
||
|
}));
|
||
|
};
|
||
|
return InternalQueryReference;
|
||
|
}());
|
||
|
|
||
|
var SuspenseCache = (function () {
|
||
|
function SuspenseCache(options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
this.queryRefs = new trie.Trie(canUseWeakMap);
|
||
|
this.options = options;
|
||
|
}
|
||
|
SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) {
|
||
|
var ref = this.queryRefs.lookupArray(cacheKey);
|
||
|
if (!ref.current) {
|
||
|
ref.current = new InternalQueryReference(createObservable(), {
|
||
|
autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,
|
||
|
onDispose: function () {
|
||
|
delete ref.current;
|
||
|
},
|
||
|
});
|
||
|
}
|
||
|
return ref.current;
|
||
|
};
|
||
|
return SuspenseCache;
|
||
|
}());
|
||
|
|
||
|
var suspenseCacheSymbol = Symbol.for("apollo.suspenseCache");
|
||
|
function getSuspenseCache(client) {
|
||
|
var _a;
|
||
|
if (!client[suspenseCacheSymbol]) {
|
||
|
client[suspenseCacheSymbol] = new SuspenseCache((_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense);
|
||
|
}
|
||
|
return client[suspenseCacheSymbol];
|
||
|
}
|
||
|
|
||
|
var skipToken = Symbol.for("apollo.skipToken");
|
||
|
|
||
|
function useSuspenseQuery(query, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
var client = useApolloClient(options.client);
|
||
|
var suspenseCache = getSuspenseCache(client);
|
||
|
var watchQueryOptions = useWatchQueryOptions({
|
||
|
client: client,
|
||
|
query: query,
|
||
|
options: options,
|
||
|
});
|
||
|
var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
|
||
|
var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
|
||
|
var cacheKey = tslib.__spreadArray([
|
||
|
query,
|
||
|
canonicalStringify(variables)
|
||
|
], [].concat(queryKey), true);
|
||
|
var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
|
||
|
return client.watchQuery(watchQueryOptions);
|
||
|
});
|
||
|
var _b = React__namespace.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1];
|
||
|
if (current[0] !== queryRef.key) {
|
||
|
current[0] = queryRef.key;
|
||
|
current[1] = queryRef.promise;
|
||
|
}
|
||
|
var promise = current[1];
|
||
|
if (queryRef.didChangeOptions(watchQueryOptions)) {
|
||
|
current[1] = promise = queryRef.applyOptions(watchQueryOptions);
|
||
|
}
|
||
|
React__namespace.useEffect(function () {
|
||
|
var dispose = queryRef.retain();
|
||
|
var removeListener = queryRef.listen(function (promise) {
|
||
|
setPromise([queryRef.key, promise]);
|
||
|
});
|
||
|
return function () {
|
||
|
removeListener();
|
||
|
dispose();
|
||
|
};
|
||
|
}, [queryRef]);
|
||
|
var skipResult = React__namespace.useMemo(function () {
|
||
|
var error = toApolloError(queryRef.result);
|
||
|
return {
|
||
|
loading: false,
|
||
|
data: queryRef.result.data,
|
||
|
networkStatus: error ? exports.NetworkStatus.error : exports.NetworkStatus.ready,
|
||
|
error: error,
|
||
|
};
|
||
|
}, [queryRef.result]);
|
||
|
var result = fetchPolicy === "standby" ? skipResult : __use(promise);
|
||
|
var fetchMore = React__namespace.useCallback((function (options) {
|
||
|
var promise = queryRef.fetchMore(options);
|
||
|
setPromise([queryRef.key, queryRef.promise]);
|
||
|
return promise;
|
||
|
}), [queryRef]);
|
||
|
var refetch = React__namespace.useCallback(function (variables) {
|
||
|
var promise = queryRef.refetch(variables);
|
||
|
setPromise([queryRef.key, queryRef.promise]);
|
||
|
return promise;
|
||
|
}, [queryRef]);
|
||
|
var subscribeToMore = React__namespace.useCallback(function (options) { return queryRef.observable.subscribeToMore(options); }, [queryRef]);
|
||
|
return React__namespace.useMemo(function () {
|
||
|
return {
|
||
|
client: client,
|
||
|
data: result.data,
|
||
|
error: toApolloError(result),
|
||
|
networkStatus: result.networkStatus,
|
||
|
fetchMore: fetchMore,
|
||
|
refetch: refetch,
|
||
|
subscribeToMore: subscribeToMore,
|
||
|
};
|
||
|
}, [client, fetchMore, refetch, result, subscribeToMore]);
|
||
|
}
|
||
|
function validateOptions(options) {
|
||
|
var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;
|
||
|
verifyDocumentType(query, exports.DocumentType.Query);
|
||
|
validateFetchPolicy(fetchPolicy);
|
||
|
validatePartialDataReturn(fetchPolicy, returnPartialData);
|
||
|
}
|
||
|
function validateFetchPolicy(fetchPolicy) {
|
||
|
if (fetchPolicy === void 0) { fetchPolicy = "cache-first"; }
|
||
|
var supportedFetchPolicies = [
|
||
|
"cache-first",
|
||
|
"network-only",
|
||
|
"no-cache",
|
||
|
"cache-and-network",
|
||
|
];
|
||
|
invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy);
|
||
|
}
|
||
|
function validatePartialDataReturn(fetchPolicy, returnPartialData) {
|
||
|
if (fetchPolicy === "no-cache" && returnPartialData) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(57);
|
||
|
}
|
||
|
}
|
||
|
function toApolloError(result) {
|
||
|
return isNonEmptyArray(result.errors) ?
|
||
|
new ApolloError({ graphQLErrors: result.errors })
|
||
|
: result.error;
|
||
|
}
|
||
|
function useWatchQueryOptions(_a) {
|
||
|
var client = _a.client, query = _a.query, options = _a.options;
|
||
|
return useDeepMemo(function () {
|
||
|
var _a;
|
||
|
if (options === skipToken) {
|
||
|
return { query: query, fetchPolicy: "standby" };
|
||
|
}
|
||
|
var fetchPolicy = options.fetchPolicy ||
|
||
|
((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
|
||
|
"cache-first";
|
||
|
var watchQueryOptions = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
validateOptions(watchQueryOptions);
|
||
|
}
|
||
|
if (options.skip) {
|
||
|
watchQueryOptions.fetchPolicy = "standby";
|
||
|
}
|
||
|
return watchQueryOptions;
|
||
|
}, [client, options, query]);
|
||
|
}
|
||
|
|
||
|
function useBackgroundQuery(query, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
var client = useApolloClient(options.client);
|
||
|
var suspenseCache = getSuspenseCache(client);
|
||
|
var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
|
||
|
var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
|
||
|
var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
|
||
|
var didFetchResult = React__namespace.useRef(fetchPolicy !== "standby");
|
||
|
didFetchResult.current || (didFetchResult.current = fetchPolicy !== "standby");
|
||
|
var cacheKey = tslib.__spreadArray([
|
||
|
query,
|
||
|
canonicalStringify(variables)
|
||
|
], [].concat(queryKey), true);
|
||
|
var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
|
||
|
return client.watchQuery(watchQueryOptions);
|
||
|
});
|
||
|
var _b = React__namespace.useState(wrapQueryRef(queryRef)), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];
|
||
|
if (unwrapQueryRef(wrappedQueryRef) !== queryRef) {
|
||
|
setWrappedQueryRef(wrapQueryRef(queryRef));
|
||
|
}
|
||
|
if (queryRef.didChangeOptions(watchQueryOptions)) {
|
||
|
var promise = queryRef.applyOptions(watchQueryOptions);
|
||
|
updateWrappedQueryRef(wrappedQueryRef, promise);
|
||
|
}
|
||
|
var fetchMore = React__namespace.useCallback(function (options) {
|
||
|
var promise = queryRef.fetchMore(options);
|
||
|
setWrappedQueryRef(wrapQueryRef(queryRef));
|
||
|
return promise;
|
||
|
}, [queryRef]);
|
||
|
var refetch = React__namespace.useCallback(function (variables) {
|
||
|
var promise = queryRef.refetch(variables);
|
||
|
setWrappedQueryRef(wrapQueryRef(queryRef));
|
||
|
return promise;
|
||
|
}, [queryRef]);
|
||
|
return [
|
||
|
didFetchResult.current ? wrappedQueryRef : void 0,
|
||
|
{ fetchMore: fetchMore, refetch: refetch },
|
||
|
];
|
||
|
}
|
||
|
|
||
|
function useLoadableQuery(query, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
var client = useApolloClient(options.client);
|
||
|
var suspenseCache = getSuspenseCache(client);
|
||
|
var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
|
||
|
var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
|
||
|
var _b = React__namespace.useState(null), queryRef = _b[0], setQueryRef = _b[1];
|
||
|
var internalQueryRef = queryRef && unwrapQueryRef(queryRef);
|
||
|
if (queryRef && (internalQueryRef === null || internalQueryRef === void 0 ? void 0 : internalQueryRef.didChangeOptions(watchQueryOptions))) {
|
||
|
var promise = internalQueryRef.applyOptions(watchQueryOptions);
|
||
|
updateWrappedQueryRef(queryRef, promise);
|
||
|
}
|
||
|
var calledDuringRender = useRenderGuard();
|
||
|
var fetchMore = React__namespace.useCallback(function (options) {
|
||
|
if (!internalQueryRef) {
|
||
|
throw new Error("The query has not been loaded. Please load the query.");
|
||
|
}
|
||
|
var promise = internalQueryRef.fetchMore(options);
|
||
|
setQueryRef(wrapQueryRef(internalQueryRef));
|
||
|
return promise;
|
||
|
}, [internalQueryRef]);
|
||
|
var refetch = React__namespace.useCallback(function (options) {
|
||
|
if (!internalQueryRef) {
|
||
|
throw new Error("The query has not been loaded. Please load the query.");
|
||
|
}
|
||
|
var promise = internalQueryRef.refetch(options);
|
||
|
setQueryRef(wrapQueryRef(internalQueryRef));
|
||
|
return promise;
|
||
|
}, [internalQueryRef]);
|
||
|
var loadQuery = React__namespace.useCallback(function () {
|
||
|
var args = [];
|
||
|
for (var _i = 0; _i < arguments.length; _i++) {
|
||
|
args[_i] = arguments[_i];
|
||
|
}
|
||
|
invariant(!calledDuringRender(), 50);
|
||
|
var variables = args[0];
|
||
|
var cacheKey = tslib.__spreadArray([
|
||
|
query,
|
||
|
canonicalStringify(variables)
|
||
|
], [].concat(queryKey), true);
|
||
|
var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
|
||
|
return client.watchQuery(tslib.__assign(tslib.__assign({}, watchQueryOptions), { variables: variables }));
|
||
|
});
|
||
|
setQueryRef(wrapQueryRef(queryRef));
|
||
|
}, [query, queryKey, suspenseCache, watchQueryOptions, calledDuringRender]);
|
||
|
var reset = React__namespace.useCallback(function () {
|
||
|
setQueryRef(null);
|
||
|
}, [queryRef]);
|
||
|
return [loadQuery, queryRef, { fetchMore: fetchMore, refetch: refetch, reset: reset }];
|
||
|
}
|
||
|
|
||
|
function useQueryRefHandlers(queryRef) {
|
||
|
var _a = React__namespace.useState(queryRef), previousQueryRef = _a[0], setPreviousQueryRef = _a[1];
|
||
|
var _b = React__namespace.useState(queryRef), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];
|
||
|
var internalQueryRef = unwrapQueryRef(queryRef);
|
||
|
if (previousQueryRef !== queryRef) {
|
||
|
setPreviousQueryRef(queryRef);
|
||
|
setWrappedQueryRef(queryRef);
|
||
|
}
|
||
|
else {
|
||
|
updateWrappedQueryRef(queryRef, getWrappedPromise(wrappedQueryRef));
|
||
|
}
|
||
|
var refetch = React__namespace.useCallback(function (variables) {
|
||
|
var promise = internalQueryRef.refetch(variables);
|
||
|
setWrappedQueryRef(wrapQueryRef(internalQueryRef));
|
||
|
return promise;
|
||
|
}, [internalQueryRef]);
|
||
|
var fetchMore = React__namespace.useCallback(function (options) {
|
||
|
var promise = internalQueryRef.fetchMore(options);
|
||
|
setWrappedQueryRef(wrapQueryRef(internalQueryRef));
|
||
|
return promise;
|
||
|
}, [internalQueryRef]);
|
||
|
return { refetch: refetch, fetchMore: fetchMore };
|
||
|
}
|
||
|
|
||
|
function useReadQuery(queryRef) {
|
||
|
var internalQueryRef = React__namespace.useMemo(function () { return unwrapQueryRef(queryRef); }, [queryRef]);
|
||
|
var getPromise = React__namespace.useCallback(function () { return getWrappedPromise(queryRef); }, [queryRef]);
|
||
|
if (internalQueryRef.disposed) {
|
||
|
internalQueryRef.reinitialize();
|
||
|
updateWrappedQueryRef(queryRef, internalQueryRef.promise);
|
||
|
}
|
||
|
React__namespace.useEffect(function () { return internalQueryRef.retain(); }, [internalQueryRef]);
|
||
|
var promise = useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {
|
||
|
return internalQueryRef.listen(function (promise) {
|
||
|
updateWrappedQueryRef(queryRef, promise);
|
||
|
forceUpdate();
|
||
|
});
|
||
|
}, [internalQueryRef]), getPromise, getPromise);
|
||
|
var result = __use(promise);
|
||
|
return React__namespace.useMemo(function () {
|
||
|
return {
|
||
|
data: result.data,
|
||
|
networkStatus: result.networkStatus,
|
||
|
error: toApolloError(result),
|
||
|
};
|
||
|
}, [result]);
|
||
|
}
|
||
|
|
||
|
function createQueryPreloader(client) {
|
||
|
return function preloadQuery(query, options) {
|
||
|
var _a, _b;
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
var queryRef = new InternalQueryReference(client.watchQuery(tslib.__assign(tslib.__assign({}, options), { query: query })), {
|
||
|
autoDisposeTimeoutMs: (_b = (_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense) === null || _b === void 0 ? void 0 : _b.autoDisposeTimeoutMs,
|
||
|
});
|
||
|
return wrapQueryRef(queryRef);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
exports.setLogVerbosity = tsInvariant.setVerbosity;
|
||
|
exports.Observable = zenObservableTs.Observable;
|
||
|
exports.disableExperimentalFragmentVariables = graphqlTag.disableExperimentalFragmentVariables;
|
||
|
exports.disableFragmentWarnings = graphqlTag.disableFragmentWarnings;
|
||
|
exports.enableExperimentalFragmentVariables = graphqlTag.enableExperimentalFragmentVariables;
|
||
|
exports.gql = graphqlTag.gql;
|
||
|
exports.resetCaches = graphqlTag.resetCaches;
|
||
|
exports.ApolloCache = ApolloCache;
|
||
|
exports.ApolloClient = ApolloClient;
|
||
|
exports.ApolloConsumer = ApolloConsumer;
|
||
|
exports.ApolloError = ApolloError;
|
||
|
exports.ApolloLink = ApolloLink;
|
||
|
exports.ApolloProvider = ApolloProvider;
|
||
|
exports.DocumentTransform = DocumentTransform;
|
||
|
exports.HttpLink = HttpLink;
|
||
|
exports.InMemoryCache = InMemoryCache;
|
||
|
exports.MissingFieldError = MissingFieldError;
|
||
|
exports.ObservableQuery = ObservableQuery;
|
||
|
exports.checkFetcher = checkFetcher;
|
||
|
exports.concat = concat;
|
||
|
exports.createHttpLink = createHttpLink;
|
||
|
exports.createQueryPreloader = createQueryPreloader;
|
||
|
exports.createSignalIfSupported = createSignalIfSupported;
|
||
|
exports.defaultDataIdFromObject = defaultDataIdFromObject;
|
||
|
exports.defaultPrinter = defaultPrinter;
|
||
|
exports.empty = empty;
|
||
|
exports.execute = execute;
|
||
|
exports.fallbackHttpConfig = fallbackHttpConfig;
|
||
|
exports.from = from;
|
||
|
exports.fromError = fromError;
|
||
|
exports.fromPromise = fromPromise;
|
||
|
exports.getApolloContext = getApolloContext;
|
||
|
exports.isApolloError = isApolloError;
|
||
|
exports.isNetworkRequestSettled = isNetworkRequestSettled;
|
||
|
exports.isReference = isReference;
|
||
|
exports.makeReference = makeReference;
|
||
|
exports.makeVar = makeVar;
|
||
|
exports.mergeOptions = mergeOptions;
|
||
|
exports.operationName = operationName;
|
||
|
exports.parseAndCheckHttpResponse = parseAndCheckHttpResponse;
|
||
|
exports.parser = parser;
|
||
|
exports.resetApolloContext = resetApolloContext;
|
||
|
exports.rewriteURIForGET = rewriteURIForGET;
|
||
|
exports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;
|
||
|
exports.selectHttpOptionsAndBodyInternal = selectHttpOptionsAndBodyInternal;
|
||
|
exports.selectURI = selectURI;
|
||
|
exports.serializeFetchParameter = serializeFetchParameter;
|
||
|
exports.skipToken = skipToken;
|
||
|
exports.split = split;
|
||
|
exports.throwServerError = throwServerError;
|
||
|
exports.toPromise = toPromise;
|
||
|
exports.useApolloClient = useApolloClient;
|
||
|
exports.useBackgroundQuery = useBackgroundQuery;
|
||
|
exports.useFragment = useFragment;
|
||
|
exports.useLazyQuery = useLazyQuery;
|
||
|
exports.useLoadableQuery = useLoadableQuery;
|
||
|
exports.useMutation = useMutation;
|
||
|
exports.useQuery = useQuery;
|
||
|
exports.useQueryRefHandlers = useQueryRefHandlers;
|
||
|
exports.useReactiveVar = useReactiveVar;
|
||
|
exports.useReadQuery = useReadQuery;
|
||
|
exports.useSubscription = useSubscription;
|
||
|
exports.useSuspenseQuery = useSuspenseQuery;
|
||
|
//# sourceMappingURL=apollo-client.cjs.map
|