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.
8661 lines
349 KiB
8661 lines
349 KiB
'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
|
|
|