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