@apollo/client
Version:
A fully-featured caching GraphQL client.
1,396 lines (1,363 loc) • 367 kB
JavaScript
'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 trie = require('@wry/trie');
var optimism = require('optimism');
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.11.4";
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) {
if (typeof arg == "string") {
return arg;
}
try {
return stringifyForDisplay(arg, 2).slice(0, 1000);
}
catch (_a) {
return "<non-serializable>";
}
}
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, 70, 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, 71, directiveName);
var ifArgument = directiveArguments[0];
invariant(ifArgument.name && ifArgument.name.value === "if", 72, directiveName);
var ifValue = ifArgument.value;
invariant(ifValue &&
(ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 73, directiveName);
result.push({ directive: directive, ifArgument: ifArgument });
});
}
return result;
}
var isReactNative = maybe(function () { return navigator.product; }) == "ReactNative";
var canUseWeakMap = typeof WeakMap === "function" &&
!(isReactNative && !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 || isReactNative) && !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(
74,
definition.operation,
definition.name ? " named '".concat(definition.name.value, "'") : ""
);
}
if (definition.kind === "FragmentDefinition") {
fragments.push(definition);
}
});
if (typeof actualFragmentName === "undefined") {
invariant(fragments.length === 1, 75, 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, 76, fragmentName);
return fragment || null;
}
default:
return null;
}
}
var scheduledCleanup = new WeakSet();
function schedule(cache) {
if (cache.size <= (cache.max || -1)) {
return;
}
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) {
var ret = caches.WeakCache.prototype.set.call(this, key, value);
schedule(this);
return ret;
};
return cache;
};
var AutoCleanedStrongCache = function (max, dispose) {
var cache = new caches.StrongCache(max, dispose);
cache.set = function (key, value) {
var ret = caches.StrongCache.prototype.set.call(this, key, value);
schedule(this);
return ret;
};
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(85, 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", 77);
var operations = doc.definitions
.filter(function (d) { return d.kind !== "FragmentDefinition"; })
.map(function (definition) {
if (definition.kind !== "OperationDefinition") {
throw newInvariantError(78, definition.kind);
}
return definition;
});
invariant(operations.length <= 1, 79, 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", 80);
return queryDef;
}
function getFragmentDefinition(doc) {
invariant(doc.kind === "Document", 81);
invariant(doc.definitions.length <= 1, 82);
var fragmentDef = doc.definitions[0];
invariant(fragmentDef.kind === "FragmentDefinition", 83);
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(84);
}
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), 69);
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(86);
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)