1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, '__esModule', { value: true });
|
4 |
|
5 | var globals = require('../utilities/globals');
|
6 | var tslib = require('tslib');
|
7 | var optimism = require('optimism');
|
8 | var utilities = require('../utilities');
|
9 | var caches = require('@wry/caches');
|
10 | var equality = require('@wry/equality');
|
11 | var trie = require('@wry/trie');
|
12 | var graphql = require('graphql');
|
13 |
|
14 | var getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ?
|
15 | _getInMemoryCacheMemoryInternals
|
16 | : undefined;
|
17 | var getApolloCacheMemoryInternals = globalThis.__DEV__ !== false ?
|
18 | _getApolloCacheMemoryInternals
|
19 | : undefined;
|
20 | function _getApolloCacheMemoryInternals() {
|
21 | return {
|
22 | cache: {
|
23 | fragmentQueryDocuments: getWrapperInformation(this["getFragmentDoc"]),
|
24 | },
|
25 | };
|
26 | }
|
27 | function _getInMemoryCacheMemoryInternals() {
|
28 | var fragments = this.config.fragments;
|
29 | return tslib.__assign(tslib.__assign({}, _getApolloCacheMemoryInternals.apply(this)), { addTypenameDocumentTransform: transformInfo(this["addTypenameTransform"]), inMemoryCache: {
|
30 | executeSelectionSet: getWrapperInformation(this["storeReader"]["executeSelectionSet"]),
|
31 | executeSubSelectedArray: getWrapperInformation(this["storeReader"]["executeSubSelectedArray"]),
|
32 | maybeBroadcastWatch: getWrapperInformation(this["maybeBroadcastWatch"]),
|
33 | }, fragmentRegistry: {
|
34 | findFragmentSpreads: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.findFragmentSpreads),
|
35 | lookup: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.lookup),
|
36 | transform: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.transform),
|
37 | } });
|
38 | }
|
39 | function isWrapper(f) {
|
40 | return !!f && "dirtyKey" in f;
|
41 | }
|
42 | function getWrapperInformation(f) {
|
43 | return isWrapper(f) ? f.size : undefined;
|
44 | }
|
45 | function isDefined(value) {
|
46 | return value != null;
|
47 | }
|
48 | function transformInfo(transform) {
|
49 | return recurseTransformInfo(transform).map(function (cache) { return ({ cache: cache }); });
|
50 | }
|
51 | function recurseTransformInfo(transform) {
|
52 | return transform ?
|
53 | tslib.__spreadArray(tslib.__spreadArray([
|
54 | getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform["performWork"])
|
55 | ], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["left"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["right"]), true).filter(isDefined)
|
56 | : [];
|
57 | }
|
58 |
|
59 | var ApolloCache = (function () {
|
60 | function ApolloCache() {
|
61 | this.assumeImmutableResults = false;
|
62 | this.getFragmentDoc = optimism.wrap(utilities.getFragmentQueryDocument, {
|
63 | max: utilities.cacheSizes["cache.fragmentQueryDocuments"] ||
|
64 | 1000 ,
|
65 | cache: caches.WeakCache,
|
66 | });
|
67 | }
|
68 | ApolloCache.prototype.batch = function (options) {
|
69 | var _this = this;
|
70 | var optimisticId = typeof options.optimistic === "string" ? options.optimistic
|
71 | : options.optimistic === false ? null
|
72 | : void 0;
|
73 | var updateResult;
|
74 | this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);
|
75 | return updateResult;
|
76 | };
|
77 | ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
|
78 | this.performTransaction(transaction, optimisticId);
|
79 | };
|
80 | ApolloCache.prototype.transformDocument = function (document) {
|
81 | return document;
|
82 | };
|
83 | ApolloCache.prototype.transformForLink = function (document) {
|
84 | return document;
|
85 | };
|
86 | ApolloCache.prototype.identify = function (object) {
|
87 | return;
|
88 | };
|
89 | ApolloCache.prototype.gc = function () {
|
90 | return [];
|
91 | };
|
92 | ApolloCache.prototype.modify = function (options) {
|
93 | return false;
|
94 | };
|
95 | ApolloCache.prototype.readQuery = function (options, optimistic) {
|
96 | if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
97 | return this.read(tslib.__assign(tslib.__assign({}, options), { rootId: options.id || "ROOT_QUERY", optimistic: optimistic }));
|
98 | };
|
99 | ApolloCache.prototype.readFragment = function (options, optimistic) {
|
100 | if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
101 | return this.read(tslib.__assign(tslib.__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));
|
102 | };
|
103 | ApolloCache.prototype.writeQuery = function (_a) {
|
104 | var id = _a.id, data = _a.data, options = tslib.__rest(_a, ["id", "data"]);
|
105 | return this.write(Object.assign(options, {
|
106 | dataId: id || "ROOT_QUERY",
|
107 | result: data,
|
108 | }));
|
109 | };
|
110 | ApolloCache.prototype.writeFragment = function (_a) {
|
111 | var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = tslib.__rest(_a, ["id", "data", "fragment", "fragmentName"]);
|
112 | return this.write(Object.assign(options, {
|
113 | query: this.getFragmentDoc(fragment, fragmentName),
|
114 | dataId: id,
|
115 | result: data,
|
116 | }));
|
117 | };
|
118 | ApolloCache.prototype.updateQuery = function (options, update) {
|
119 | return this.batch({
|
120 | update: function (cache) {
|
121 | var value = cache.readQuery(options);
|
122 | var data = update(value);
|
123 | if (data === void 0 || data === null)
|
124 | return value;
|
125 | cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));
|
126 | return data;
|
127 | },
|
128 | });
|
129 | };
|
130 | ApolloCache.prototype.updateFragment = function (options, update) {
|
131 | return this.batch({
|
132 | update: function (cache) {
|
133 | var value = cache.readFragment(options);
|
134 | var data = update(value);
|
135 | if (data === void 0 || data === null)
|
136 | return value;
|
137 | cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));
|
138 | return data;
|
139 | },
|
140 | });
|
141 | };
|
142 | return ApolloCache;
|
143 | }());
|
144 | if (globalThis.__DEV__ !== false) {
|
145 | ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;
|
146 | }
|
147 |
|
148 | exports.Cache = void 0;
|
149 | (function (Cache) {
|
150 | })(exports.Cache || (exports.Cache = {}));
|
151 |
|
152 | var MissingFieldError = (function (_super) {
|
153 | tslib.__extends(MissingFieldError, _super);
|
154 | function MissingFieldError(message, path, query, variables) {
|
155 | var _a;
|
156 | var _this = _super.call(this, message) || this;
|
157 | _this.message = message;
|
158 | _this.path = path;
|
159 | _this.query = query;
|
160 | _this.variables = variables;
|
161 | if (Array.isArray(_this.path)) {
|
162 | _this.missing = _this.message;
|
163 | for (var i = _this.path.length - 1; i >= 0; --i) {
|
164 | _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);
|
165 | }
|
166 | }
|
167 | else {
|
168 | _this.missing = _this.path;
|
169 | }
|
170 | _this.__proto__ = MissingFieldError.prototype;
|
171 | return _this;
|
172 | }
|
173 | return MissingFieldError;
|
174 | }(Error));
|
175 |
|
176 | var hasOwn = Object.prototype.hasOwnProperty;
|
177 | function isNullish(value) {
|
178 | return value === null || value === void 0;
|
179 | }
|
180 | function defaultDataIdFromObject(_a, context) {
|
181 | var __typename = _a.__typename, id = _a.id, _id = _a._id;
|
182 | if (typeof __typename === "string") {
|
183 | if (context) {
|
184 | context.keyObject =
|
185 | !isNullish(id) ? { id: id }
|
186 | : !isNullish(_id) ? { _id: _id }
|
187 | : void 0;
|
188 | }
|
189 | if (isNullish(id) && !isNullish(_id)) {
|
190 | id = _id;
|
191 | }
|
192 | if (!isNullish(id)) {
|
193 | return "".concat(__typename, ":").concat(typeof id === "number" || typeof id === "string" ?
|
194 | id
|
195 | : JSON.stringify(id));
|
196 | }
|
197 | }
|
198 | }
|
199 | var defaultConfig = {
|
200 | dataIdFromObject: defaultDataIdFromObject,
|
201 | addTypename: true,
|
202 | resultCaching: true,
|
203 | canonizeResults: false,
|
204 | };
|
205 | function normalizeConfig(config) {
|
206 | return utilities.compact(defaultConfig, config);
|
207 | }
|
208 | function shouldCanonizeResults(config) {
|
209 | var value = config.canonizeResults;
|
210 | return value === void 0 ? defaultConfig.canonizeResults : value;
|
211 | }
|
212 | function getTypenameFromStoreObject(store, objectOrReference) {
|
213 | return utilities.isReference(objectOrReference) ?
|
214 | store.get(objectOrReference.__ref, "__typename")
|
215 | : objectOrReference && objectOrReference.__typename;
|
216 | }
|
217 | var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
|
218 | function fieldNameFromStoreName(storeFieldName) {
|
219 | var match = storeFieldName.match(TypeOrFieldNameRegExp);
|
220 | return match ? match[0] : storeFieldName;
|
221 | }
|
222 | function selectionSetMatchesResult(selectionSet, result, variables) {
|
223 | if (utilities.isNonNullObject(result)) {
|
224 | return utilities.isArray(result) ?
|
225 | result.every(function (item) {
|
226 | return selectionSetMatchesResult(selectionSet, item, variables);
|
227 | })
|
228 | : selectionSet.selections.every(function (field) {
|
229 | if (utilities.isField(field) && utilities.shouldInclude(field, variables)) {
|
230 | var key = utilities.resultKeyNameFromField(field);
|
231 | return (hasOwn.call(result, key) &&
|
232 | (!field.selectionSet ||
|
233 | selectionSetMatchesResult(field.selectionSet, result[key], variables)));
|
234 | }
|
235 | return true;
|
236 | });
|
237 | }
|
238 | return false;
|
239 | }
|
240 | function storeValueIsStoreObject(value) {
|
241 | return utilities.isNonNullObject(value) && !utilities.isReference(value) && !utilities.isArray(value);
|
242 | }
|
243 | function makeProcessedFieldsMerger() {
|
244 | return new utilities.DeepMerger();
|
245 | }
|
246 | function extractFragmentContext(document, fragments) {
|
247 | var fragmentMap = utilities.createFragmentMap(utilities.getFragmentDefinitions(document));
|
248 | return {
|
249 | fragmentMap: fragmentMap,
|
250 | lookupFragment: function (name) {
|
251 | var def = fragmentMap[name];
|
252 | if (!def && fragments) {
|
253 | def = fragments.lookup(name);
|
254 | }
|
255 | return def || null;
|
256 | },
|
257 | };
|
258 | }
|
259 |
|
260 | var DELETE = Object.create(null);
|
261 | var delModifier = function () { return DELETE; };
|
262 | var INVALIDATE = Object.create(null);
|
263 | exports.EntityStore = (function () {
|
264 | function EntityStore(policies, group) {
|
265 | var _this = this;
|
266 | this.policies = policies;
|
267 | this.group = group;
|
268 | this.data = Object.create(null);
|
269 | this.rootIds = Object.create(null);
|
270 | this.refs = Object.create(null);
|
271 | this.getFieldValue = function (objectOrReference, storeFieldName) {
|
272 | return utilities.maybeDeepFreeze(utilities.isReference(objectOrReference) ?
|
273 | _this.get(objectOrReference.__ref, storeFieldName)
|
274 | : objectOrReference && objectOrReference[storeFieldName]);
|
275 | };
|
276 | this.canRead = function (objOrRef) {
|
277 | return utilities.isReference(objOrRef) ?
|
278 | _this.has(objOrRef.__ref)
|
279 | : typeof objOrRef === "object";
|
280 | };
|
281 | this.toReference = function (objOrIdOrRef, mergeIntoStore) {
|
282 | if (typeof objOrIdOrRef === "string") {
|
283 | return utilities.makeReference(objOrIdOrRef);
|
284 | }
|
285 | if (utilities.isReference(objOrIdOrRef)) {
|
286 | return objOrIdOrRef;
|
287 | }
|
288 | var id = _this.policies.identify(objOrIdOrRef)[0];
|
289 | if (id) {
|
290 | var ref = utilities.makeReference(id);
|
291 | if (mergeIntoStore) {
|
292 | _this.merge(id, objOrIdOrRef);
|
293 | }
|
294 | return ref;
|
295 | }
|
296 | };
|
297 | }
|
298 | EntityStore.prototype.toObject = function () {
|
299 | return tslib.__assign({}, this.data);
|
300 | };
|
301 | EntityStore.prototype.has = function (dataId) {
|
302 | return this.lookup(dataId, true) !== void 0;
|
303 | };
|
304 | EntityStore.prototype.get = function (dataId, fieldName) {
|
305 | this.group.depend(dataId, fieldName);
|
306 | if (hasOwn.call(this.data, dataId)) {
|
307 | var storeObject = this.data[dataId];
|
308 | if (storeObject && hasOwn.call(storeObject, fieldName)) {
|
309 | return storeObject[fieldName];
|
310 | }
|
311 | }
|
312 | if (fieldName === "__typename" &&
|
313 | hasOwn.call(this.policies.rootTypenamesById, dataId)) {
|
314 | return this.policies.rootTypenamesById[dataId];
|
315 | }
|
316 | if (this instanceof Layer) {
|
317 | return this.parent.get(dataId, fieldName);
|
318 | }
|
319 | };
|
320 | EntityStore.prototype.lookup = function (dataId, dependOnExistence) {
|
321 | if (dependOnExistence)
|
322 | this.group.depend(dataId, "__exists");
|
323 | if (hasOwn.call(this.data, dataId)) {
|
324 | return this.data[dataId];
|
325 | }
|
326 | if (this instanceof Layer) {
|
327 | return this.parent.lookup(dataId, dependOnExistence);
|
328 | }
|
329 | if (this.policies.rootTypenamesById[dataId]) {
|
330 | return Object.create(null);
|
331 | }
|
332 | };
|
333 | EntityStore.prototype.merge = function (older, newer) {
|
334 | var _this = this;
|
335 | var dataId;
|
336 | if (utilities.isReference(older))
|
337 | older = older.__ref;
|
338 | if (utilities.isReference(newer))
|
339 | newer = newer.__ref;
|
340 | var existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
|
341 | var incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
|
342 | if (!incoming)
|
343 | return;
|
344 | globals.invariant(typeof dataId === "string", 1);
|
345 | var merged = new utilities.DeepMerger(storeObjectReconciler).merge(existing, incoming);
|
346 | this.data[dataId] = merged;
|
347 | if (merged !== existing) {
|
348 | delete this.refs[dataId];
|
349 | if (this.group.caching) {
|
350 | var fieldsToDirty_1 = Object.create(null);
|
351 | if (!existing)
|
352 | fieldsToDirty_1.__exists = 1;
|
353 | Object.keys(incoming).forEach(function (storeFieldName) {
|
354 | if (!existing ||
|
355 | existing[storeFieldName] !== merged[storeFieldName]) {
|
356 | fieldsToDirty_1[storeFieldName] = 1;
|
357 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
358 | if (fieldName !== storeFieldName &&
|
359 | !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {
|
360 | fieldsToDirty_1[fieldName] = 1;
|
361 | }
|
362 | if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {
|
363 | delete merged[storeFieldName];
|
364 | }
|
365 | }
|
366 | });
|
367 | if (fieldsToDirty_1.__typename &&
|
368 | !(existing && existing.__typename) &&
|
369 | this.policies.rootTypenamesById[dataId] === merged.__typename) {
|
370 | delete fieldsToDirty_1.__typename;
|
371 | }
|
372 | Object.keys(fieldsToDirty_1).forEach(function (fieldName) {
|
373 | return _this.group.dirty(dataId, fieldName);
|
374 | });
|
375 | }
|
376 | }
|
377 | };
|
378 | EntityStore.prototype.modify = function (dataId, fields) {
|
379 | var _this = this;
|
380 | var storeObject = this.lookup(dataId);
|
381 | if (storeObject) {
|
382 | var changedFields_1 = Object.create(null);
|
383 | var needToMerge_1 = false;
|
384 | var allDeleted_1 = true;
|
385 | var sharedDetails_1 = {
|
386 | DELETE: DELETE,
|
387 | INVALIDATE: INVALIDATE,
|
388 | isReference: utilities.isReference,
|
389 | toReference: this.toReference,
|
390 | canRead: this.canRead,
|
391 | readField: function (fieldNameOrOptions, from) {
|
392 | return _this.policies.readField(typeof fieldNameOrOptions === "string" ?
|
393 | {
|
394 | fieldName: fieldNameOrOptions,
|
395 | from: from || utilities.makeReference(dataId),
|
396 | }
|
397 | : fieldNameOrOptions, { store: _this });
|
398 | },
|
399 | };
|
400 | Object.keys(storeObject).forEach(function (storeFieldName) {
|
401 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
402 | var fieldValue = storeObject[storeFieldName];
|
403 | if (fieldValue === void 0)
|
404 | return;
|
405 | var modify = typeof fields === "function" ? fields : (fields[storeFieldName] || fields[fieldName]);
|
406 | if (modify) {
|
407 | var newValue = modify === delModifier ? DELETE : (modify(utilities.maybeDeepFreeze(fieldValue), tslib.__assign(tslib.__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));
|
408 | if (newValue === INVALIDATE) {
|
409 | _this.group.dirty(dataId, storeFieldName);
|
410 | }
|
411 | else {
|
412 | if (newValue === DELETE)
|
413 | newValue = void 0;
|
414 | if (newValue !== fieldValue) {
|
415 | changedFields_1[storeFieldName] = newValue;
|
416 | needToMerge_1 = true;
|
417 | fieldValue = newValue;
|
418 | if (globalThis.__DEV__ !== false) {
|
419 | var checkReference = function (ref) {
|
420 | if (_this.lookup(ref.__ref) === undefined) {
|
421 | globalThis.__DEV__ !== false && globals.invariant.warn(2, ref);
|
422 | return true;
|
423 | }
|
424 | };
|
425 | if (utilities.isReference(newValue)) {
|
426 | checkReference(newValue);
|
427 | }
|
428 | else if (Array.isArray(newValue)) {
|
429 | var seenReference = false;
|
430 | var someNonReference = void 0;
|
431 | for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {
|
432 | var value = newValue_1[_i];
|
433 | if (utilities.isReference(value)) {
|
434 | seenReference = true;
|
435 | if (checkReference(value))
|
436 | break;
|
437 | }
|
438 | else {
|
439 | if (typeof value === "object" && !!value) {
|
440 | var id = _this.policies.identify(value)[0];
|
441 | if (id) {
|
442 | someNonReference = value;
|
443 | }
|
444 | }
|
445 | }
|
446 | if (seenReference && someNonReference !== undefined) {
|
447 | globalThis.__DEV__ !== false && globals.invariant.warn(3, someNonReference);
|
448 | break;
|
449 | }
|
450 | }
|
451 | }
|
452 | }
|
453 | }
|
454 | }
|
455 | }
|
456 | if (fieldValue !== void 0) {
|
457 | allDeleted_1 = false;
|
458 | }
|
459 | });
|
460 | if (needToMerge_1) {
|
461 | this.merge(dataId, changedFields_1);
|
462 | if (allDeleted_1) {
|
463 | if (this instanceof Layer) {
|
464 | this.data[dataId] = void 0;
|
465 | }
|
466 | else {
|
467 | delete this.data[dataId];
|
468 | }
|
469 | this.group.dirty(dataId, "__exists");
|
470 | }
|
471 | return true;
|
472 | }
|
473 | }
|
474 | return false;
|
475 | };
|
476 | EntityStore.prototype.delete = function (dataId, fieldName, args) {
|
477 | var _a;
|
478 | var storeObject = this.lookup(dataId);
|
479 | if (storeObject) {
|
480 | var typename = this.getFieldValue(storeObject, "__typename");
|
481 | var storeFieldName = fieldName && args ?
|
482 | this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })
|
483 | : fieldName;
|
484 | return this.modify(dataId, storeFieldName ? (_a = {},
|
485 | _a[storeFieldName] = delModifier,
|
486 | _a) : delModifier);
|
487 | }
|
488 | return false;
|
489 | };
|
490 | EntityStore.prototype.evict = function (options, limit) {
|
491 | var evicted = false;
|
492 | if (options.id) {
|
493 | if (hasOwn.call(this.data, options.id)) {
|
494 | evicted = this.delete(options.id, options.fieldName, options.args);
|
495 | }
|
496 | if (this instanceof Layer && this !== limit) {
|
497 | evicted = this.parent.evict(options, limit) || evicted;
|
498 | }
|
499 | if (options.fieldName || evicted) {
|
500 | this.group.dirty(options.id, options.fieldName || "__exists");
|
501 | }
|
502 | }
|
503 | return evicted;
|
504 | };
|
505 | EntityStore.prototype.clear = function () {
|
506 | this.replace(null);
|
507 | };
|
508 | EntityStore.prototype.extract = function () {
|
509 | var _this = this;
|
510 | var obj = this.toObject();
|
511 | var extraRootIds = [];
|
512 | this.getRootIdSet().forEach(function (id) {
|
513 | if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {
|
514 | extraRootIds.push(id);
|
515 | }
|
516 | });
|
517 | if (extraRootIds.length) {
|
518 | obj.__META = { extraRootIds: extraRootIds.sort() };
|
519 | }
|
520 | return obj;
|
521 | };
|
522 | EntityStore.prototype.replace = function (newData) {
|
523 | var _this = this;
|
524 | Object.keys(this.data).forEach(function (dataId) {
|
525 | if (!(newData && hasOwn.call(newData, dataId))) {
|
526 | _this.delete(dataId);
|
527 | }
|
528 | });
|
529 | if (newData) {
|
530 | var __META = newData.__META, rest_1 = tslib.__rest(newData, ["__META"]);
|
531 | Object.keys(rest_1).forEach(function (dataId) {
|
532 | _this.merge(dataId, rest_1[dataId]);
|
533 | });
|
534 | if (__META) {
|
535 | __META.extraRootIds.forEach(this.retain, this);
|
536 | }
|
537 | }
|
538 | };
|
539 | EntityStore.prototype.retain = function (rootId) {
|
540 | return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);
|
541 | };
|
542 | EntityStore.prototype.release = function (rootId) {
|
543 | if (this.rootIds[rootId] > 0) {
|
544 | var count = --this.rootIds[rootId];
|
545 | if (!count)
|
546 | delete this.rootIds[rootId];
|
547 | return count;
|
548 | }
|
549 | return 0;
|
550 | };
|
551 | EntityStore.prototype.getRootIdSet = function (ids) {
|
552 | if (ids === void 0) { ids = new Set(); }
|
553 | Object.keys(this.rootIds).forEach(ids.add, ids);
|
554 | if (this instanceof Layer) {
|
555 | this.parent.getRootIdSet(ids);
|
556 | }
|
557 | else {
|
558 | Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
|
559 | }
|
560 | return ids;
|
561 | };
|
562 | EntityStore.prototype.gc = function () {
|
563 | var _this = this;
|
564 | var ids = this.getRootIdSet();
|
565 | var snapshot = this.toObject();
|
566 | ids.forEach(function (id) {
|
567 | if (hasOwn.call(snapshot, id)) {
|
568 | Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);
|
569 | delete snapshot[id];
|
570 | }
|
571 | });
|
572 | var idsToRemove = Object.keys(snapshot);
|
573 | if (idsToRemove.length) {
|
574 | var root_1 = this;
|
575 | while (root_1 instanceof Layer)
|
576 | root_1 = root_1.parent;
|
577 | idsToRemove.forEach(function (id) { return root_1.delete(id); });
|
578 | }
|
579 | return idsToRemove;
|
580 | };
|
581 | EntityStore.prototype.findChildRefIds = function (dataId) {
|
582 | if (!hasOwn.call(this.refs, dataId)) {
|
583 | var found_1 = (this.refs[dataId] = Object.create(null));
|
584 | var root = this.data[dataId];
|
585 | if (!root)
|
586 | return found_1;
|
587 | var workSet_1 = new Set([root]);
|
588 | workSet_1.forEach(function (obj) {
|
589 | if (utilities.isReference(obj)) {
|
590 | found_1[obj.__ref] = true;
|
591 | }
|
592 | if (utilities.isNonNullObject(obj)) {
|
593 | Object.keys(obj).forEach(function (key) {
|
594 | var child = obj[key];
|
595 | if (utilities.isNonNullObject(child)) {
|
596 | workSet_1.add(child);
|
597 | }
|
598 | });
|
599 | }
|
600 | });
|
601 | }
|
602 | return this.refs[dataId];
|
603 | };
|
604 | EntityStore.prototype.makeCacheKey = function () {
|
605 | return this.group.keyMaker.lookupArray(arguments);
|
606 | };
|
607 | return EntityStore;
|
608 | }());
|
609 | var CacheGroup = (function () {
|
610 | function CacheGroup(caching, parent) {
|
611 | if (parent === void 0) { parent = null; }
|
612 | this.caching = caching;
|
613 | this.parent = parent;
|
614 | this.d = null;
|
615 | this.resetCaching();
|
616 | }
|
617 | CacheGroup.prototype.resetCaching = function () {
|
618 | this.d = this.caching ? optimism.dep() : null;
|
619 | this.keyMaker = new trie.Trie(utilities.canUseWeakMap);
|
620 | };
|
621 | CacheGroup.prototype.depend = function (dataId, storeFieldName) {
|
622 | if (this.d) {
|
623 | this.d(makeDepKey(dataId, storeFieldName));
|
624 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
625 | if (fieldName !== storeFieldName) {
|
626 | this.d(makeDepKey(dataId, fieldName));
|
627 | }
|
628 | if (this.parent) {
|
629 | this.parent.depend(dataId, storeFieldName);
|
630 | }
|
631 | }
|
632 | };
|
633 | CacheGroup.prototype.dirty = function (dataId, storeFieldName) {
|
634 | if (this.d) {
|
635 | this.d.dirty(makeDepKey(dataId, storeFieldName),
|
636 | storeFieldName === "__exists" ? "forget" : "setDirty");
|
637 | }
|
638 | };
|
639 | return CacheGroup;
|
640 | }());
|
641 | function makeDepKey(dataId, storeFieldName) {
|
642 | return storeFieldName + "#" + dataId;
|
643 | }
|
644 | function maybeDependOnExistenceOfEntity(store, entityId) {
|
645 | if (supportsResultCaching(store)) {
|
646 | store.group.depend(entityId, "__exists");
|
647 | }
|
648 | }
|
649 | (function (EntityStore) {
|
650 | var Root = (function (_super) {
|
651 | tslib.__extends(Root, _super);
|
652 | function Root(_a) {
|
653 | var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;
|
654 | var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;
|
655 | _this.stump = new Stump(_this);
|
656 | _this.storageTrie = new trie.Trie(utilities.canUseWeakMap);
|
657 | if (seed)
|
658 | _this.replace(seed);
|
659 | return _this;
|
660 | }
|
661 | Root.prototype.addLayer = function (layerId, replay) {
|
662 | return this.stump.addLayer(layerId, replay);
|
663 | };
|
664 | Root.prototype.removeLayer = function () {
|
665 | return this;
|
666 | };
|
667 | Root.prototype.getStorage = function () {
|
668 | return this.storageTrie.lookupArray(arguments);
|
669 | };
|
670 | return Root;
|
671 | }(EntityStore));
|
672 | EntityStore.Root = Root;
|
673 | })(exports.EntityStore || (exports.EntityStore = {}));
|
674 | var Layer = (function (_super) {
|
675 | tslib.__extends(Layer, _super);
|
676 | function Layer(id, parent, replay, group) {
|
677 | var _this = _super.call(this, parent.policies, group) || this;
|
678 | _this.id = id;
|
679 | _this.parent = parent;
|
680 | _this.replay = replay;
|
681 | _this.group = group;
|
682 | replay(_this);
|
683 | return _this;
|
684 | }
|
685 | Layer.prototype.addLayer = function (layerId, replay) {
|
686 | return new Layer(layerId, this, replay, this.group);
|
687 | };
|
688 | Layer.prototype.removeLayer = function (layerId) {
|
689 | var _this = this;
|
690 | var parent = this.parent.removeLayer(layerId);
|
691 | if (layerId === this.id) {
|
692 | if (this.group.caching) {
|
693 | Object.keys(this.data).forEach(function (dataId) {
|
694 | var ownStoreObject = _this.data[dataId];
|
695 | var parentStoreObject = parent["lookup"](dataId);
|
696 | if (!parentStoreObject) {
|
697 | _this.delete(dataId);
|
698 | }
|
699 | else if (!ownStoreObject) {
|
700 | _this.group.dirty(dataId, "__exists");
|
701 | Object.keys(parentStoreObject).forEach(function (storeFieldName) {
|
702 | _this.group.dirty(dataId, storeFieldName);
|
703 | });
|
704 | }
|
705 | else if (ownStoreObject !== parentStoreObject) {
|
706 | Object.keys(ownStoreObject).forEach(function (storeFieldName) {
|
707 | if (!equality.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
|
708 | _this.group.dirty(dataId, storeFieldName);
|
709 | }
|
710 | });
|
711 | }
|
712 | });
|
713 | }
|
714 | return parent;
|
715 | }
|
716 | if (parent === this.parent)
|
717 | return this;
|
718 | return parent.addLayer(this.id, this.replay);
|
719 | };
|
720 | Layer.prototype.toObject = function () {
|
721 | return tslib.__assign(tslib.__assign({}, this.parent.toObject()), this.data);
|
722 | };
|
723 | Layer.prototype.findChildRefIds = function (dataId) {
|
724 | var fromParent = this.parent.findChildRefIds(dataId);
|
725 | return hasOwn.call(this.data, dataId) ? tslib.__assign(tslib.__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;
|
726 | };
|
727 | Layer.prototype.getStorage = function () {
|
728 | var p = this.parent;
|
729 | while (p.parent)
|
730 | p = p.parent;
|
731 | return p.getStorage.apply(p,
|
732 | arguments);
|
733 | };
|
734 | return Layer;
|
735 | }(exports.EntityStore));
|
736 | var Stump = (function (_super) {
|
737 | tslib.__extends(Stump, _super);
|
738 | function Stump(root) {
|
739 | return _super.call(this, "EntityStore.Stump", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;
|
740 | }
|
741 | Stump.prototype.removeLayer = function () {
|
742 | return this;
|
743 | };
|
744 | Stump.prototype.merge = function (older, newer) {
|
745 | return this.parent.merge(older, newer);
|
746 | };
|
747 | return Stump;
|
748 | }(Layer));
|
749 | function storeObjectReconciler(existingObject, incomingObject, property) {
|
750 | var existingValue = existingObject[property];
|
751 | var incomingValue = incomingObject[property];
|
752 | return equality.equal(existingValue, incomingValue) ? existingValue : incomingValue;
|
753 | }
|
754 | function supportsResultCaching(store) {
|
755 | return !!(store instanceof exports.EntityStore && store.group.caching);
|
756 | }
|
757 |
|
758 | function shallowCopy(value) {
|
759 | if (utilities.isNonNullObject(value)) {
|
760 | return utilities.isArray(value) ?
|
761 | value.slice(0)
|
762 | : tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
|
763 | }
|
764 | return value;
|
765 | }
|
766 | var ObjectCanon = (function () {
|
767 | function ObjectCanon() {
|
768 | this.known = new (utilities.canUseWeakSet ? WeakSet : Set)();
|
769 | this.pool = new trie.Trie(utilities.canUseWeakMap);
|
770 | this.passes = new WeakMap();
|
771 | this.keysByJSON = new Map();
|
772 | this.empty = this.admit({});
|
773 | }
|
774 | ObjectCanon.prototype.isKnown = function (value) {
|
775 | return utilities.isNonNullObject(value) && this.known.has(value);
|
776 | };
|
777 | ObjectCanon.prototype.pass = function (value) {
|
778 | if (utilities.isNonNullObject(value)) {
|
779 | var copy = shallowCopy(value);
|
780 | this.passes.set(copy, value);
|
781 | return copy;
|
782 | }
|
783 | return value;
|
784 | };
|
785 | ObjectCanon.prototype.admit = function (value) {
|
786 | var _this = this;
|
787 | if (utilities.isNonNullObject(value)) {
|
788 | var original = this.passes.get(value);
|
789 | if (original)
|
790 | return original;
|
791 | var proto = Object.getPrototypeOf(value);
|
792 | switch (proto) {
|
793 | case Array.prototype: {
|
794 | if (this.known.has(value))
|
795 | return value;
|
796 | var array = value.map(this.admit, this);
|
797 | var node = this.pool.lookupArray(array);
|
798 | if (!node.array) {
|
799 | this.known.add((node.array = array));
|
800 | if (globalThis.__DEV__ !== false) {
|
801 | Object.freeze(array);
|
802 | }
|
803 | }
|
804 | return node.array;
|
805 | }
|
806 | case null:
|
807 | case Object.prototype: {
|
808 | if (this.known.has(value))
|
809 | return value;
|
810 | var proto_1 = Object.getPrototypeOf(value);
|
811 | var array_1 = [proto_1];
|
812 | var keys = this.sortedKeys(value);
|
813 | array_1.push(keys.json);
|
814 | var firstValueIndex_1 = array_1.length;
|
815 | keys.sorted.forEach(function (key) {
|
816 | array_1.push(_this.admit(value[key]));
|
817 | });
|
818 | var node = this.pool.lookupArray(array_1);
|
819 | if (!node.object) {
|
820 | var obj_1 = (node.object = Object.create(proto_1));
|
821 | this.known.add(obj_1);
|
822 | keys.sorted.forEach(function (key, i) {
|
823 | obj_1[key] = array_1[firstValueIndex_1 + i];
|
824 | });
|
825 | if (globalThis.__DEV__ !== false) {
|
826 | Object.freeze(obj_1);
|
827 | }
|
828 | }
|
829 | return node.object;
|
830 | }
|
831 | }
|
832 | }
|
833 | return value;
|
834 | };
|
835 | ObjectCanon.prototype.sortedKeys = function (obj) {
|
836 | var keys = Object.keys(obj);
|
837 | var node = this.pool.lookupArray(keys);
|
838 | if (!node.keys) {
|
839 | keys.sort();
|
840 | var json = JSON.stringify(keys);
|
841 | if (!(node.keys = this.keysByJSON.get(json))) {
|
842 | this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));
|
843 | }
|
844 | }
|
845 | return node.keys;
|
846 | };
|
847 | return ObjectCanon;
|
848 | }());
|
849 |
|
850 | function execSelectionSetKeyArgs(options) {
|
851 | return [
|
852 | options.selectionSet,
|
853 | options.objectOrReference,
|
854 | options.context,
|
855 | options.context.canonizeResults,
|
856 | ];
|
857 | }
|
858 | var StoreReader = (function () {
|
859 | function StoreReader(config) {
|
860 | var _this = this;
|
861 | this.knownResults = new (utilities.canUseWeakMap ? WeakMap : Map)();
|
862 | this.config = utilities.compact(config, {
|
863 | addTypename: config.addTypename !== false,
|
864 | canonizeResults: shouldCanonizeResults(config),
|
865 | });
|
866 | this.canon = config.canon || new ObjectCanon();
|
867 | this.executeSelectionSet = optimism.wrap(function (options) {
|
868 | var _a;
|
869 | var canonizeResults = options.context.canonizeResults;
|
870 | var peekArgs = execSelectionSetKeyArgs(options);
|
871 | peekArgs[3] = !canonizeResults;
|
872 | var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);
|
873 | if (other) {
|
874 | if (canonizeResults) {
|
875 | return tslib.__assign(tslib.__assign({}, other), {
|
876 | result: _this.canon.admit(other.result) });
|
877 | }
|
878 | return other;
|
879 | }
|
880 | maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
|
881 | return _this.execSelectionSetImpl(options);
|
882 | }, {
|
883 | max: this.config.resultCacheMaxSize ||
|
884 | utilities.cacheSizes["inMemoryCache.executeSelectionSet"] ||
|
885 | 50000 ,
|
886 | keyArgs: execSelectionSetKeyArgs,
|
887 | makeCacheKey: function (selectionSet, parent, context, canonizeResults) {
|
888 | if (supportsResultCaching(context.store)) {
|
889 | return context.store.makeCacheKey(selectionSet, utilities.isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);
|
890 | }
|
891 | },
|
892 | });
|
893 | this.executeSubSelectedArray = optimism.wrap(function (options) {
|
894 | maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
|
895 | return _this.execSubSelectedArrayImpl(options);
|
896 | }, {
|
897 | max: this.config.resultCacheMaxSize ||
|
898 | utilities.cacheSizes["inMemoryCache.executeSubSelectedArray"] ||
|
899 | 10000 ,
|
900 | makeCacheKey: function (_a) {
|
901 | var field = _a.field, array = _a.array, context = _a.context;
|
902 | if (supportsResultCaching(context.store)) {
|
903 | return context.store.makeCacheKey(field, array, context.varString);
|
904 | }
|
905 | },
|
906 | });
|
907 | }
|
908 | StoreReader.prototype.resetCanon = function () {
|
909 | this.canon = new ObjectCanon();
|
910 | };
|
911 | StoreReader.prototype.diffQueryAgainstStore = function (_a) {
|
912 | 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;
|
913 | var policies = this.config.cache.policies;
|
914 | variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(utilities.getQueryDefinition(query))), variables);
|
915 | var rootRef = utilities.makeReference(rootId);
|
916 | var execResult = this.executeSelectionSet({
|
917 | selectionSet: utilities.getMainDefinition(query).selectionSet,
|
918 | objectOrReference: rootRef,
|
919 | enclosingRef: rootRef,
|
920 | context: tslib.__assign({ store: store, query: query, policies: policies, variables: variables, varString: utilities.canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),
|
921 | });
|
922 | var missing;
|
923 | if (execResult.missing) {
|
924 | missing = [
|
925 | new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),
|
926 | ];
|
927 | if (!returnPartialData) {
|
928 | throw missing[0];
|
929 | }
|
930 | }
|
931 | return {
|
932 | result: execResult.result,
|
933 | complete: !missing,
|
934 | missing: missing,
|
935 | };
|
936 | };
|
937 | StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {
|
938 | if (supportsResultCaching(context.store) &&
|
939 | this.knownResults.get(result) === selectionSet) {
|
940 | var latest = this.executeSelectionSet.peek(selectionSet, parent, context,
|
941 | this.canon.isKnown(result));
|
942 | if (latest && result === latest.result) {
|
943 | return true;
|
944 | }
|
945 | }
|
946 | return false;
|
947 | };
|
948 | StoreReader.prototype.execSelectionSetImpl = function (_a) {
|
949 | var _this = this;
|
950 | var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;
|
951 | if (utilities.isReference(objectOrReference) &&
|
952 | !context.policies.rootTypenamesById[objectOrReference.__ref] &&
|
953 | !context.store.has(objectOrReference.__ref)) {
|
954 | return {
|
955 | result: this.canon.empty,
|
956 | missing: "Dangling reference to missing ".concat(objectOrReference.__ref, " object"),
|
957 | };
|
958 | }
|
959 | var variables = context.variables, policies = context.policies, store = context.store;
|
960 | var typename = store.getFieldValue(objectOrReference, "__typename");
|
961 | var objectsToMerge = [];
|
962 | var missing;
|
963 | var missingMerger = new utilities.DeepMerger();
|
964 | if (this.config.addTypename &&
|
965 | typeof typename === "string" &&
|
966 | !policies.rootIdsByTypename[typename]) {
|
967 | objectsToMerge.push({ __typename: typename });
|
968 | }
|
969 | function handleMissing(result, resultName) {
|
970 | var _a;
|
971 | if (result.missing) {
|
972 | missing = missingMerger.merge(missing, (_a = {},
|
973 | _a[resultName] = result.missing,
|
974 | _a));
|
975 | }
|
976 | return result.result;
|
977 | }
|
978 | var workSet = new Set(selectionSet.selections);
|
979 | workSet.forEach(function (selection) {
|
980 | var _a, _b;
|
981 | if (!utilities.shouldInclude(selection, variables))
|
982 | return;
|
983 | if (utilities.isField(selection)) {
|
984 | var fieldValue = policies.readField({
|
985 | fieldName: selection.name.value,
|
986 | field: selection,
|
987 | variables: context.variables,
|
988 | from: objectOrReference,
|
989 | }, context);
|
990 | var resultName = utilities.resultKeyNameFromField(selection);
|
991 | if (fieldValue === void 0) {
|
992 | if (!utilities.addTypenameToDocument.added(selection)) {
|
993 | missing = missingMerger.merge(missing, (_a = {},
|
994 | _a[resultName] = "Can't find field '".concat(selection.name.value, "' on ").concat(utilities.isReference(objectOrReference) ?
|
995 | objectOrReference.__ref + " object"
|
996 | : "object " + JSON.stringify(objectOrReference, null, 2)),
|
997 | _a));
|
998 | }
|
999 | }
|
1000 | else if (utilities.isArray(fieldValue)) {
|
1001 | fieldValue = handleMissing(_this.executeSubSelectedArray({
|
1002 | field: selection,
|
1003 | array: fieldValue,
|
1004 | enclosingRef: enclosingRef,
|
1005 | context: context,
|
1006 | }), resultName);
|
1007 | }
|
1008 | else if (!selection.selectionSet) {
|
1009 | if (context.canonizeResults) {
|
1010 | fieldValue = _this.canon.pass(fieldValue);
|
1011 | }
|
1012 | }
|
1013 | else if (fieldValue != null) {
|
1014 | fieldValue = handleMissing(_this.executeSelectionSet({
|
1015 | selectionSet: selection.selectionSet,
|
1016 | objectOrReference: fieldValue,
|
1017 | enclosingRef: utilities.isReference(fieldValue) ? fieldValue : enclosingRef,
|
1018 | context: context,
|
1019 | }), resultName);
|
1020 | }
|
1021 | if (fieldValue !== void 0) {
|
1022 | objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));
|
1023 | }
|
1024 | }
|
1025 | else {
|
1026 | var fragment = utilities.getFragmentFromSelection(selection, context.lookupFragment);
|
1027 | if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
|
1028 | throw globals.newInvariantError(9, selection.name.value);
|
1029 | }
|
1030 | if (fragment && policies.fragmentMatches(fragment, typename)) {
|
1031 | fragment.selectionSet.selections.forEach(workSet.add, workSet);
|
1032 | }
|
1033 | }
|
1034 | });
|
1035 | var result = utilities.mergeDeepArray(objectsToMerge);
|
1036 | var finalResult = { result: result, missing: missing };
|
1037 | var frozen = context.canonizeResults ?
|
1038 | this.canon.admit(finalResult)
|
1039 | : utilities.maybeDeepFreeze(finalResult);
|
1040 | if (frozen.result) {
|
1041 | this.knownResults.set(frozen.result, selectionSet);
|
1042 | }
|
1043 | return frozen;
|
1044 | };
|
1045 | StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {
|
1046 | var _this = this;
|
1047 | var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;
|
1048 | var missing;
|
1049 | var missingMerger = new utilities.DeepMerger();
|
1050 | function handleMissing(childResult, i) {
|
1051 | var _a;
|
1052 | if (childResult.missing) {
|
1053 | missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));
|
1054 | }
|
1055 | return childResult.result;
|
1056 | }
|
1057 | if (field.selectionSet) {
|
1058 | array = array.filter(context.store.canRead);
|
1059 | }
|
1060 | array = array.map(function (item, i) {
|
1061 | if (item === null) {
|
1062 | return null;
|
1063 | }
|
1064 | if (utilities.isArray(item)) {
|
1065 | return handleMissing(_this.executeSubSelectedArray({
|
1066 | field: field,
|
1067 | array: item,
|
1068 | enclosingRef: enclosingRef,
|
1069 | context: context,
|
1070 | }), i);
|
1071 | }
|
1072 | if (field.selectionSet) {
|
1073 | return handleMissing(_this.executeSelectionSet({
|
1074 | selectionSet: field.selectionSet,
|
1075 | objectOrReference: item,
|
1076 | enclosingRef: utilities.isReference(item) ? item : enclosingRef,
|
1077 | context: context,
|
1078 | }), i);
|
1079 | }
|
1080 | if (globalThis.__DEV__ !== false) {
|
1081 | assertSelectionSetForIdValue(context.store, field, item);
|
1082 | }
|
1083 | return item;
|
1084 | });
|
1085 | return {
|
1086 | result: context.canonizeResults ? this.canon.admit(array) : array,
|
1087 | missing: missing,
|
1088 | };
|
1089 | };
|
1090 | return StoreReader;
|
1091 | }());
|
1092 | function firstMissing(tree) {
|
1093 | try {
|
1094 | JSON.stringify(tree, function (_, value) {
|
1095 | if (typeof value === "string")
|
1096 | throw value;
|
1097 | return value;
|
1098 | });
|
1099 | }
|
1100 | catch (result) {
|
1101 | return result;
|
1102 | }
|
1103 | }
|
1104 | function assertSelectionSetForIdValue(store, field, fieldValue) {
|
1105 | if (!field.selectionSet) {
|
1106 | var workSet_1 = new Set([fieldValue]);
|
1107 | workSet_1.forEach(function (value) {
|
1108 | if (utilities.isNonNullObject(value)) {
|
1109 | globals.invariant(
|
1110 | !utilities.isReference(value),
|
1111 | 10,
|
1112 | getTypenameFromStoreObject(store, value),
|
1113 | field.name.value
|
1114 | );
|
1115 | Object.values(value).forEach(workSet_1.add, workSet_1);
|
1116 | }
|
1117 | });
|
1118 | }
|
1119 | }
|
1120 |
|
1121 | var cacheSlot = new optimism.Slot();
|
1122 | var cacheInfoMap = new WeakMap();
|
1123 | function getCacheInfo(cache) {
|
1124 | var info = cacheInfoMap.get(cache);
|
1125 | if (!info) {
|
1126 | cacheInfoMap.set(cache, (info = {
|
1127 | vars: new Set(),
|
1128 | dep: optimism.dep(),
|
1129 | }));
|
1130 | }
|
1131 | return info;
|
1132 | }
|
1133 | function forgetCache(cache) {
|
1134 | getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
|
1135 | }
|
1136 | function recallCache(cache) {
|
1137 | getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
|
1138 | }
|
1139 | function makeVar(value) {
|
1140 | var caches = new Set();
|
1141 | var listeners = new Set();
|
1142 | var rv = function (newValue) {
|
1143 | if (arguments.length > 0) {
|
1144 | if (value !== newValue) {
|
1145 | value = newValue;
|
1146 | caches.forEach(function (cache) {
|
1147 | getCacheInfo(cache).dep.dirty(rv);
|
1148 | broadcast(cache);
|
1149 | });
|
1150 | var oldListeners = Array.from(listeners);
|
1151 | listeners.clear();
|
1152 | oldListeners.forEach(function (listener) { return listener(value); });
|
1153 | }
|
1154 | }
|
1155 | else {
|
1156 | var cache = cacheSlot.getValue();
|
1157 | if (cache) {
|
1158 | attach(cache);
|
1159 | getCacheInfo(cache).dep(rv);
|
1160 | }
|
1161 | }
|
1162 | return value;
|
1163 | };
|
1164 | rv.onNextChange = function (listener) {
|
1165 | listeners.add(listener);
|
1166 | return function () {
|
1167 | listeners.delete(listener);
|
1168 | };
|
1169 | };
|
1170 | var attach = (rv.attachCache = function (cache) {
|
1171 | caches.add(cache);
|
1172 | getCacheInfo(cache).vars.add(rv);
|
1173 | return rv;
|
1174 | });
|
1175 | rv.forgetCache = function (cache) { return caches.delete(cache); };
|
1176 | return rv;
|
1177 | }
|
1178 | function broadcast(cache) {
|
1179 | if (cache.broadcastWatches) {
|
1180 | cache.broadcastWatches();
|
1181 | }
|
1182 | }
|
1183 |
|
1184 | var specifierInfoCache = Object.create(null);
|
1185 | function lookupSpecifierInfo(spec) {
|
1186 | var cacheKey = JSON.stringify(spec);
|
1187 | return (specifierInfoCache[cacheKey] ||
|
1188 | (specifierInfoCache[cacheKey] = Object.create(null)));
|
1189 | }
|
1190 | function keyFieldsFnFromSpecifier(specifier) {
|
1191 | var info = lookupSpecifierInfo(specifier);
|
1192 | return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {
|
1193 | var extract = function (from, key) {
|
1194 | return context.readField(key, from);
|
1195 | };
|
1196 | var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {
|
1197 | var extracted = extractKeyPath(context.storeObject, schemaKeyPath,
|
1198 | extract);
|
1199 | if (extracted === void 0 &&
|
1200 | object !== context.storeObject &&
|
1201 | hasOwn.call(object, schemaKeyPath[0])) {
|
1202 | extracted = extractKeyPath(object, schemaKeyPath, extractKey);
|
1203 | }
|
1204 | globals.invariant(extracted !== void 0, 4, schemaKeyPath.join("."), object);
|
1205 | return extracted;
|
1206 | }));
|
1207 | return "".concat(context.typename, ":").concat(JSON.stringify(keyObject));
|
1208 | }));
|
1209 | }
|
1210 | function keyArgsFnFromSpecifier(specifier) {
|
1211 | var info = lookupSpecifierInfo(specifier);
|
1212 | return (info.keyArgsFn ||
|
1213 | (info.keyArgsFn = function (args, _a) {
|
1214 | var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;
|
1215 | var collected = collectSpecifierPaths(specifier, function (keyPath) {
|
1216 | var firstKey = keyPath[0];
|
1217 | var firstChar = firstKey.charAt(0);
|
1218 | if (firstChar === "@") {
|
1219 | if (field && utilities.isNonEmptyArray(field.directives)) {
|
1220 | var directiveName_1 = firstKey.slice(1);
|
1221 | var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });
|
1222 | var directiveArgs = d && utilities.argumentsObjectFromField(d, variables);
|
1223 | return (directiveArgs &&
|
1224 | extractKeyPath(directiveArgs,
|
1225 | keyPath.slice(1)));
|
1226 | }
|
1227 | return;
|
1228 | }
|
1229 | if (firstChar === "$") {
|
1230 | var variableName = firstKey.slice(1);
|
1231 | if (variables && hasOwn.call(variables, variableName)) {
|
1232 | var varKeyPath = keyPath.slice(0);
|
1233 | varKeyPath[0] = variableName;
|
1234 | return extractKeyPath(variables, varKeyPath);
|
1235 | }
|
1236 | return;
|
1237 | }
|
1238 | if (args) {
|
1239 | return extractKeyPath(args, keyPath);
|
1240 | }
|
1241 | });
|
1242 | var suffix = JSON.stringify(collected);
|
1243 | if (args || suffix !== "{}") {
|
1244 | fieldName += ":" + suffix;
|
1245 | }
|
1246 | return fieldName;
|
1247 | }));
|
1248 | }
|
1249 | function collectSpecifierPaths(specifier, extractor) {
|
1250 | var merger = new utilities.DeepMerger();
|
1251 | return getSpecifierPaths(specifier).reduce(function (collected, path) {
|
1252 | var _a;
|
1253 | var toMerge = extractor(path);
|
1254 | if (toMerge !== void 0) {
|
1255 | for (var i = path.length - 1; i >= 0; --i) {
|
1256 | toMerge = (_a = {}, _a[path[i]] = toMerge, _a);
|
1257 | }
|
1258 | collected = merger.merge(collected, toMerge);
|
1259 | }
|
1260 | return collected;
|
1261 | }, Object.create(null));
|
1262 | }
|
1263 | function getSpecifierPaths(spec) {
|
1264 | var info = lookupSpecifierInfo(spec);
|
1265 | if (!info.paths) {
|
1266 | var paths_1 = (info.paths = []);
|
1267 | var currentPath_1 = [];
|
1268 | spec.forEach(function (s, i) {
|
1269 | if (utilities.isArray(s)) {
|
1270 | getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });
|
1271 | currentPath_1.length = 0;
|
1272 | }
|
1273 | else {
|
1274 | currentPath_1.push(s);
|
1275 | if (!utilities.isArray(spec[i + 1])) {
|
1276 | paths_1.push(currentPath_1.slice(0));
|
1277 | currentPath_1.length = 0;
|
1278 | }
|
1279 | }
|
1280 | });
|
1281 | }
|
1282 | return info.paths;
|
1283 | }
|
1284 | function extractKey(object, key) {
|
1285 | return object[key];
|
1286 | }
|
1287 | function extractKeyPath(object, path, extract) {
|
1288 | extract = extract || extractKey;
|
1289 | return normalize(path.reduce(function reducer(obj, key) {
|
1290 | return utilities.isArray(obj) ?
|
1291 | obj.map(function (child) { return reducer(child, key); })
|
1292 | : obj && extract(obj, key);
|
1293 | }, object));
|
1294 | }
|
1295 | function normalize(value) {
|
1296 | if (utilities.isNonNullObject(value)) {
|
1297 | if (utilities.isArray(value)) {
|
1298 | return value.map(normalize);
|
1299 | }
|
1300 | return collectSpecifierPaths(Object.keys(value).sort(), function (path) {
|
1301 | return extractKeyPath(value, path);
|
1302 | });
|
1303 | }
|
1304 | return value;
|
1305 | }
|
1306 |
|
1307 | function argsFromFieldSpecifier(spec) {
|
1308 | return (spec.args !== void 0 ? spec.args
|
1309 | : spec.field ? utilities.argumentsObjectFromField(spec.field, spec.variables)
|
1310 | : null);
|
1311 | }
|
1312 | var nullKeyFieldsFn = function () { return void 0; };
|
1313 | var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
|
1314 | var mergeTrueFn = function (existing, incoming, _a) {
|
1315 | var mergeObjects = _a.mergeObjects;
|
1316 | return mergeObjects(existing, incoming);
|
1317 | };
|
1318 | var mergeFalseFn = function (_, incoming) { return incoming; };
|
1319 | var Policies = (function () {
|
1320 | function Policies(config) {
|
1321 | this.config = config;
|
1322 | this.typePolicies = Object.create(null);
|
1323 | this.toBeAdded = Object.create(null);
|
1324 | this.supertypeMap = new Map();
|
1325 | this.fuzzySubtypes = new Map();
|
1326 | this.rootIdsByTypename = Object.create(null);
|
1327 | this.rootTypenamesById = Object.create(null);
|
1328 | this.usingPossibleTypes = false;
|
1329 | this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);
|
1330 | this.cache = this.config.cache;
|
1331 | this.setRootTypename("Query");
|
1332 | this.setRootTypename("Mutation");
|
1333 | this.setRootTypename("Subscription");
|
1334 | if (config.possibleTypes) {
|
1335 | this.addPossibleTypes(config.possibleTypes);
|
1336 | }
|
1337 | if (config.typePolicies) {
|
1338 | this.addTypePolicies(config.typePolicies);
|
1339 | }
|
1340 | }
|
1341 | Policies.prototype.identify = function (object, partialContext) {
|
1342 | var _a;
|
1343 | var policies = this;
|
1344 | var typename = (partialContext &&
|
1345 | (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||
|
1346 | object.__typename;
|
1347 | if (typename === this.rootTypenamesById.ROOT_QUERY) {
|
1348 | return ["ROOT_QUERY"];
|
1349 | }
|
1350 | var storeObject = (partialContext && partialContext.storeObject) || object;
|
1351 | var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||
|
1352 | function () {
|
1353 | var options = normalizeReadFieldOptions(arguments, storeObject);
|
1354 | return policies.readField(options, {
|
1355 | store: policies.cache["data"],
|
1356 | variables: options.variables,
|
1357 | });
|
1358 | } });
|
1359 | var id;
|
1360 | var policy = typename && this.getTypePolicy(typename);
|
1361 | var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;
|
1362 | while (keyFn) {
|
1363 | var specifierOrId = keyFn(tslib.__assign(tslib.__assign({}, object), storeObject), context);
|
1364 | if (utilities.isArray(specifierOrId)) {
|
1365 | keyFn = keyFieldsFnFromSpecifier(specifierOrId);
|
1366 | }
|
1367 | else {
|
1368 | id = specifierOrId;
|
1369 | break;
|
1370 | }
|
1371 | }
|
1372 | id = id ? String(id) : void 0;
|
1373 | return context.keyObject ? [id, context.keyObject] : [id];
|
1374 | };
|
1375 | Policies.prototype.addTypePolicies = function (typePolicies) {
|
1376 | var _this = this;
|
1377 | Object.keys(typePolicies).forEach(function (typename) {
|
1378 | var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = tslib.__rest(_a, ["queryType", "mutationType", "subscriptionType"]);
|
1379 | if (queryType)
|
1380 | _this.setRootTypename("Query", typename);
|
1381 | if (mutationType)
|
1382 | _this.setRootTypename("Mutation", typename);
|
1383 | if (subscriptionType)
|
1384 | _this.setRootTypename("Subscription", typename);
|
1385 | if (hasOwn.call(_this.toBeAdded, typename)) {
|
1386 | _this.toBeAdded[typename].push(incoming);
|
1387 | }
|
1388 | else {
|
1389 | _this.toBeAdded[typename] = [incoming];
|
1390 | }
|
1391 | });
|
1392 | };
|
1393 | Policies.prototype.updateTypePolicy = function (typename, incoming) {
|
1394 | var _this = this;
|
1395 | var existing = this.getTypePolicy(typename);
|
1396 | var keyFields = incoming.keyFields, fields = incoming.fields;
|
1397 | function setMerge(existing, merge) {
|
1398 | existing.merge =
|
1399 | typeof merge === "function" ? merge
|
1400 | : merge === true ? mergeTrueFn
|
1401 | : merge === false ? mergeFalseFn
|
1402 | : existing.merge;
|
1403 | }
|
1404 | setMerge(existing, incoming.merge);
|
1405 | existing.keyFn =
|
1406 | keyFields === false ? nullKeyFieldsFn
|
1407 | : utilities.isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)
|
1408 | : typeof keyFields === "function" ? keyFields
|
1409 | : existing.keyFn;
|
1410 | if (fields) {
|
1411 | Object.keys(fields).forEach(function (fieldName) {
|
1412 | var existing = _this.getFieldPolicy(typename, fieldName, true);
|
1413 | var incoming = fields[fieldName];
|
1414 | if (typeof incoming === "function") {
|
1415 | existing.read = incoming;
|
1416 | }
|
1417 | else {
|
1418 | var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;
|
1419 | existing.keyFn =
|
1420 | keyArgs === false ? simpleKeyArgsFn
|
1421 | : utilities.isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)
|
1422 | : typeof keyArgs === "function" ? keyArgs
|
1423 | : existing.keyFn;
|
1424 | if (typeof read === "function") {
|
1425 | existing.read = read;
|
1426 | }
|
1427 | setMerge(existing, merge);
|
1428 | }
|
1429 | if (existing.read && existing.merge) {
|
1430 | existing.keyFn = existing.keyFn || simpleKeyArgsFn;
|
1431 | }
|
1432 | });
|
1433 | }
|
1434 | };
|
1435 | Policies.prototype.setRootTypename = function (which, typename) {
|
1436 | if (typename === void 0) { typename = which; }
|
1437 | var rootId = "ROOT_" + which.toUpperCase();
|
1438 | var old = this.rootTypenamesById[rootId];
|
1439 | if (typename !== old) {
|
1440 | globals.invariant(!old || old === which, 5, which);
|
1441 | if (old)
|
1442 | delete this.rootIdsByTypename[old];
|
1443 | this.rootIdsByTypename[typename] = rootId;
|
1444 | this.rootTypenamesById[rootId] = typename;
|
1445 | }
|
1446 | };
|
1447 | Policies.prototype.addPossibleTypes = function (possibleTypes) {
|
1448 | var _this = this;
|
1449 | this.usingPossibleTypes = true;
|
1450 | Object.keys(possibleTypes).forEach(function (supertype) {
|
1451 | _this.getSupertypeSet(supertype, true);
|
1452 | possibleTypes[supertype].forEach(function (subtype) {
|
1453 | _this.getSupertypeSet(subtype, true).add(supertype);
|
1454 | var match = subtype.match(TypeOrFieldNameRegExp);
|
1455 | if (!match || match[0] !== subtype) {
|
1456 | _this.fuzzySubtypes.set(subtype, new RegExp(subtype));
|
1457 | }
|
1458 | });
|
1459 | });
|
1460 | };
|
1461 | Policies.prototype.getTypePolicy = function (typename) {
|
1462 | var _this = this;
|
1463 | if (!hasOwn.call(this.typePolicies, typename)) {
|
1464 | var policy_1 = (this.typePolicies[typename] = Object.create(null));
|
1465 | policy_1.fields = Object.create(null);
|
1466 | var supertypes_1 = this.supertypeMap.get(typename);
|
1467 | if (!supertypes_1 && this.fuzzySubtypes.size) {
|
1468 | supertypes_1 = this.getSupertypeSet(typename, true);
|
1469 | this.fuzzySubtypes.forEach(function (regExp, fuzzy) {
|
1470 | if (regExp.test(typename)) {
|
1471 | var fuzzySupertypes = _this.supertypeMap.get(fuzzy);
|
1472 | if (fuzzySupertypes) {
|
1473 | fuzzySupertypes.forEach(function (supertype) {
|
1474 | return supertypes_1.add(supertype);
|
1475 | });
|
1476 | }
|
1477 | }
|
1478 | });
|
1479 | }
|
1480 | if (supertypes_1 && supertypes_1.size) {
|
1481 | supertypes_1.forEach(function (supertype) {
|
1482 | var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = tslib.__rest(_a, ["fields"]);
|
1483 | Object.assign(policy_1, rest);
|
1484 | Object.assign(policy_1.fields, fields);
|
1485 | });
|
1486 | }
|
1487 | }
|
1488 | var inbox = this.toBeAdded[typename];
|
1489 | if (inbox && inbox.length) {
|
1490 | inbox.splice(0).forEach(function (policy) {
|
1491 | _this.updateTypePolicy(typename, policy);
|
1492 | });
|
1493 | }
|
1494 | return this.typePolicies[typename];
|
1495 | };
|
1496 | Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {
|
1497 | if (typename) {
|
1498 | var fieldPolicies = this.getTypePolicy(typename).fields;
|
1499 | return (fieldPolicies[fieldName] ||
|
1500 | (createIfMissing && (fieldPolicies[fieldName] = Object.create(null))));
|
1501 | }
|
1502 | };
|
1503 | Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {
|
1504 | var supertypeSet = this.supertypeMap.get(subtype);
|
1505 | if (!supertypeSet && createIfMissing) {
|
1506 | this.supertypeMap.set(subtype, (supertypeSet = new Set()));
|
1507 | }
|
1508 | return supertypeSet;
|
1509 | };
|
1510 | Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {
|
1511 | var _this = this;
|
1512 | if (!fragment.typeCondition)
|
1513 | return true;
|
1514 | if (!typename)
|
1515 | return false;
|
1516 | var supertype = fragment.typeCondition.name.value;
|
1517 | if (typename === supertype)
|
1518 | return true;
|
1519 | if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {
|
1520 | var typenameSupertypeSet = this.getSupertypeSet(typename, true);
|
1521 | var workQueue_1 = [typenameSupertypeSet];
|
1522 | var maybeEnqueue_1 = function (subtype) {
|
1523 | var supertypeSet = _this.getSupertypeSet(subtype, false);
|
1524 | if (supertypeSet &&
|
1525 | supertypeSet.size &&
|
1526 | workQueue_1.indexOf(supertypeSet) < 0) {
|
1527 | workQueue_1.push(supertypeSet);
|
1528 | }
|
1529 | };
|
1530 | var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
|
1531 | var checkingFuzzySubtypes = false;
|
1532 | for (var i = 0; i < workQueue_1.length; ++i) {
|
1533 | var supertypeSet = workQueue_1[i];
|
1534 | if (supertypeSet.has(supertype)) {
|
1535 | if (!typenameSupertypeSet.has(supertype)) {
|
1536 | if (checkingFuzzySubtypes) {
|
1537 | globalThis.__DEV__ !== false && globals.invariant.warn(6, typename, supertype);
|
1538 | }
|
1539 | typenameSupertypeSet.add(supertype);
|
1540 | }
|
1541 | return true;
|
1542 | }
|
1543 | supertypeSet.forEach(maybeEnqueue_1);
|
1544 | if (needToCheckFuzzySubtypes &&
|
1545 | i === workQueue_1.length - 1 &&
|
1546 | selectionSetMatchesResult(fragment.selectionSet, result, variables)) {
|
1547 | needToCheckFuzzySubtypes = false;
|
1548 | checkingFuzzySubtypes = true;
|
1549 | this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {
|
1550 | var match = typename.match(regExp);
|
1551 | if (match && match[0] === typename) {
|
1552 | maybeEnqueue_1(fuzzyString);
|
1553 | }
|
1554 | });
|
1555 | }
|
1556 | }
|
1557 | }
|
1558 | return false;
|
1559 | };
|
1560 | Policies.prototype.hasKeyArgs = function (typename, fieldName) {
|
1561 | var policy = this.getFieldPolicy(typename, fieldName, false);
|
1562 | return !!(policy && policy.keyFn);
|
1563 | };
|
1564 | Policies.prototype.getStoreFieldName = function (fieldSpec) {
|
1565 | var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;
|
1566 | var policy = this.getFieldPolicy(typename, fieldName, false);
|
1567 | var storeFieldName;
|
1568 | var keyFn = policy && policy.keyFn;
|
1569 | if (keyFn && typename) {
|
1570 | var context = {
|
1571 | typename: typename,
|
1572 | fieldName: fieldName,
|
1573 | field: fieldSpec.field || null,
|
1574 | variables: fieldSpec.variables,
|
1575 | };
|
1576 | var args = argsFromFieldSpecifier(fieldSpec);
|
1577 | while (keyFn) {
|
1578 | var specifierOrString = keyFn(args, context);
|
1579 | if (utilities.isArray(specifierOrString)) {
|
1580 | keyFn = keyArgsFnFromSpecifier(specifierOrString);
|
1581 | }
|
1582 | else {
|
1583 | storeFieldName = specifierOrString || fieldName;
|
1584 | break;
|
1585 | }
|
1586 | }
|
1587 | }
|
1588 | if (storeFieldName === void 0) {
|
1589 | storeFieldName =
|
1590 | fieldSpec.field ?
|
1591 | utilities.storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)
|
1592 | : utilities.getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));
|
1593 | }
|
1594 | if (storeFieldName === false) {
|
1595 | return fieldName;
|
1596 | }
|
1597 | return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName
|
1598 | : fieldName + ":" + storeFieldName;
|
1599 | };
|
1600 | Policies.prototype.readField = function (options, context) {
|
1601 | var objectOrReference = options.from;
|
1602 | if (!objectOrReference)
|
1603 | return;
|
1604 | var nameOrField = options.field || options.fieldName;
|
1605 | if (!nameOrField)
|
1606 | return;
|
1607 | if (options.typename === void 0) {
|
1608 | var typename = context.store.getFieldValue(objectOrReference, "__typename");
|
1609 | if (typename)
|
1610 | options.typename = typename;
|
1611 | }
|
1612 | var storeFieldName = this.getStoreFieldName(options);
|
1613 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
1614 | var existing = context.store.getFieldValue(objectOrReference, storeFieldName);
|
1615 | var policy = this.getFieldPolicy(options.typename, fieldName, false);
|
1616 | var read = policy && policy.read;
|
1617 | if (read) {
|
1618 | var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(utilities.isReference(objectOrReference) ?
|
1619 | objectOrReference.__ref
|
1620 | : objectOrReference, storeFieldName));
|
1621 | return cacheSlot.withValue(this.cache, read, [
|
1622 | existing,
|
1623 | readOptions,
|
1624 | ]);
|
1625 | }
|
1626 | return existing;
|
1627 | };
|
1628 | Policies.prototype.getReadFunction = function (typename, fieldName) {
|
1629 | var policy = this.getFieldPolicy(typename, fieldName, false);
|
1630 | return policy && policy.read;
|
1631 | };
|
1632 | Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
|
1633 | var policy = this.getFieldPolicy(parentTypename, fieldName, false);
|
1634 | var merge = policy && policy.merge;
|
1635 | if (!merge && childTypename) {
|
1636 | policy = this.getTypePolicy(childTypename);
|
1637 | merge = policy && policy.merge;
|
1638 | }
|
1639 | return merge;
|
1640 | };
|
1641 | Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {
|
1642 | var field = _a.field, typename = _a.typename, merge = _a.merge;
|
1643 | if (merge === mergeTrueFn) {
|
1644 | return makeMergeObjectsFunction(context.store)(existing, incoming);
|
1645 | }
|
1646 | if (merge === mergeFalseFn) {
|
1647 | return incoming;
|
1648 | }
|
1649 | if (context.overwrite) {
|
1650 | existing = void 0;
|
1651 | }
|
1652 | return merge(existing, incoming, makeFieldFunctionOptions(this,
|
1653 | void 0, {
|
1654 | typename: typename,
|
1655 | fieldName: field.name.value,
|
1656 | field: field,
|
1657 | variables: context.variables,
|
1658 | }, context, storage || Object.create(null)));
|
1659 | };
|
1660 | return Policies;
|
1661 | }());
|
1662 | function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
|
1663 | var storeFieldName = policies.getStoreFieldName(fieldSpec);
|
1664 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
1665 | var variables = fieldSpec.variables || context.variables;
|
1666 | var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;
|
1667 | return {
|
1668 | args: argsFromFieldSpecifier(fieldSpec),
|
1669 | field: fieldSpec.field || null,
|
1670 | fieldName: fieldName,
|
1671 | storeFieldName: storeFieldName,
|
1672 | variables: variables,
|
1673 | isReference: utilities.isReference,
|
1674 | toReference: toReference,
|
1675 | storage: storage,
|
1676 | cache: policies.cache,
|
1677 | canRead: canRead,
|
1678 | readField: function () {
|
1679 | return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);
|
1680 | },
|
1681 | mergeObjects: makeMergeObjectsFunction(context.store),
|
1682 | };
|
1683 | }
|
1684 | function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
|
1685 | var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
|
1686 | var options;
|
1687 | if (typeof fieldNameOrOptions === "string") {
|
1688 | options = {
|
1689 | fieldName: fieldNameOrOptions,
|
1690 | from: argc > 1 ? from : objectOrReference,
|
1691 | };
|
1692 | }
|
1693 | else {
|
1694 | options = tslib.__assign({}, fieldNameOrOptions);
|
1695 | if (!hasOwn.call(options, "from")) {
|
1696 | options.from = objectOrReference;
|
1697 | }
|
1698 | }
|
1699 | if (globalThis.__DEV__ !== false && options.from === void 0) {
|
1700 | globalThis.__DEV__ !== false && globals.invariant.warn(7, utilities.stringifyForDisplay(Array.from(readFieldArgs)));
|
1701 | }
|
1702 | if (void 0 === options.variables) {
|
1703 | options.variables = variables;
|
1704 | }
|
1705 | return options;
|
1706 | }
|
1707 | function makeMergeObjectsFunction(store) {
|
1708 | return function mergeObjects(existing, incoming) {
|
1709 | if (utilities.isArray(existing) || utilities.isArray(incoming)) {
|
1710 | throw globals.newInvariantError(8);
|
1711 | }
|
1712 | if (utilities.isNonNullObject(existing) && utilities.isNonNullObject(incoming)) {
|
1713 | var eType = store.getFieldValue(existing, "__typename");
|
1714 | var iType = store.getFieldValue(incoming, "__typename");
|
1715 | var typesDiffer = eType && iType && eType !== iType;
|
1716 | if (typesDiffer) {
|
1717 | return incoming;
|
1718 | }
|
1719 | if (utilities.isReference(existing) && storeValueIsStoreObject(incoming)) {
|
1720 | store.merge(existing.__ref, incoming);
|
1721 | return existing;
|
1722 | }
|
1723 | if (storeValueIsStoreObject(existing) && utilities.isReference(incoming)) {
|
1724 | store.merge(existing, incoming.__ref);
|
1725 | return incoming;
|
1726 | }
|
1727 | if (storeValueIsStoreObject(existing) &&
|
1728 | storeValueIsStoreObject(incoming)) {
|
1729 | return tslib.__assign(tslib.__assign({}, existing), incoming);
|
1730 | }
|
1731 | }
|
1732 | return incoming;
|
1733 | };
|
1734 | }
|
1735 |
|
1736 | function getContextFlavor(context, clientOnly, deferred) {
|
1737 | var key = "".concat(clientOnly).concat(deferred);
|
1738 | var flavored = context.flavors.get(key);
|
1739 | if (!flavored) {
|
1740 | context.flavors.set(key, (flavored =
|
1741 | context.clientOnly === clientOnly && context.deferred === deferred ?
|
1742 | context
|
1743 | : tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));
|
1744 | }
|
1745 | return flavored;
|
1746 | }
|
1747 | var StoreWriter = (function () {
|
1748 | function StoreWriter(cache, reader, fragments) {
|
1749 | this.cache = cache;
|
1750 | this.reader = reader;
|
1751 | this.fragments = fragments;
|
1752 | }
|
1753 | StoreWriter.prototype.writeToStore = function (store, _a) {
|
1754 | var _this = this;
|
1755 | var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
|
1756 | var operationDefinition = utilities.getOperationDefinition(query);
|
1757 | var merger = makeProcessedFieldsMerger();
|
1758 | variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(operationDefinition)), variables);
|
1759 | var context = tslib.__assign(tslib.__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {
|
1760 | return merger.merge(existing, incoming);
|
1761 | }, variables: variables, varString: utilities.canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });
|
1762 | var ref = this.processSelectionSet({
|
1763 | result: result || Object.create(null),
|
1764 | dataId: dataId,
|
1765 | selectionSet: operationDefinition.selectionSet,
|
1766 | mergeTree: { map: new Map() },
|
1767 | context: context,
|
1768 | });
|
1769 | if (!utilities.isReference(ref)) {
|
1770 | throw globals.newInvariantError(11, result);
|
1771 | }
|
1772 | context.incomingById.forEach(function (_a, dataId) {
|
1773 | var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
|
1774 | var entityRef = utilities.makeReference(dataId);
|
1775 | if (mergeTree && mergeTree.map.size) {
|
1776 | var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
|
1777 | if (utilities.isReference(applied)) {
|
1778 | return;
|
1779 | }
|
1780 | storeObject = applied;
|
1781 | }
|
1782 | if (globalThis.__DEV__ !== false && !context.overwrite) {
|
1783 | var fieldsWithSelectionSets_1 = Object.create(null);
|
1784 | fieldNodeSet.forEach(function (field) {
|
1785 | if (field.selectionSet) {
|
1786 | fieldsWithSelectionSets_1[field.name.value] = true;
|
1787 | }
|
1788 | });
|
1789 | var hasSelectionSet_1 = function (storeFieldName) {
|
1790 | return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===
|
1791 | true;
|
1792 | };
|
1793 | var hasMergeFunction_1 = function (storeFieldName) {
|
1794 | var childTree = mergeTree && mergeTree.map.get(storeFieldName);
|
1795 | return Boolean(childTree && childTree.info && childTree.info.merge);
|
1796 | };
|
1797 | Object.keys(storeObject).forEach(function (storeFieldName) {
|
1798 | if (hasSelectionSet_1(storeFieldName) &&
|
1799 | !hasMergeFunction_1(storeFieldName)) {
|
1800 | warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
|
1801 | }
|
1802 | });
|
1803 | }
|
1804 | store.merge(dataId, storeObject);
|
1805 | });
|
1806 | store.retain(ref.__ref);
|
1807 | return ref;
|
1808 | };
|
1809 | StoreWriter.prototype.processSelectionSet = function (_a) {
|
1810 | var _this = this;
|
1811 | var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context,
|
1812 | mergeTree = _a.mergeTree;
|
1813 | var policies = this.cache.policies;
|
1814 | var incoming = Object.create(null);
|
1815 | var typename = (dataId && policies.rootTypenamesById[dataId]) ||
|
1816 | utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
|
1817 | (dataId && context.store.get(dataId, "__typename"));
|
1818 | if ("string" === typeof typename) {
|
1819 | incoming.__typename = typename;
|
1820 | }
|
1821 | var readField = function () {
|
1822 | var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
|
1823 | if (utilities.isReference(options.from)) {
|
1824 | var info = context.incomingById.get(options.from.__ref);
|
1825 | if (info) {
|
1826 | var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);
|
1827 | if (result_1 !== void 0) {
|
1828 | return result_1;
|
1829 | }
|
1830 | }
|
1831 | }
|
1832 | return policies.readField(options, context);
|
1833 | };
|
1834 | var fieldNodeSet = new Set();
|
1835 | this.flattenFields(selectionSet, result,
|
1836 | context, typename).forEach(function (context, field) {
|
1837 | var _a;
|
1838 | var resultFieldKey = utilities.resultKeyNameFromField(field);
|
1839 | var value = result[resultFieldKey];
|
1840 | fieldNodeSet.add(field);
|
1841 | if (value !== void 0) {
|
1842 | var storeFieldName = policies.getStoreFieldName({
|
1843 | typename: typename,
|
1844 | fieldName: field.name.value,
|
1845 | field: field,
|
1846 | variables: context.variables,
|
1847 | });
|
1848 | var childTree = getChildMergeTree(mergeTree, storeFieldName);
|
1849 | var incomingValue = _this.processFieldValue(value, field,
|
1850 | field.selectionSet ?
|
1851 | getContextFlavor(context, false, false)
|
1852 | : context, childTree);
|
1853 | var childTypename = void 0;
|
1854 | if (field.selectionSet &&
|
1855 | (utilities.isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {
|
1856 | childTypename = readField("__typename", incomingValue);
|
1857 | }
|
1858 | var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
|
1859 | if (merge) {
|
1860 | childTree.info = {
|
1861 | field: field,
|
1862 | typename: typename,
|
1863 | merge: merge,
|
1864 | };
|
1865 | }
|
1866 | else {
|
1867 | maybeRecycleChildMergeTree(mergeTree, storeFieldName);
|
1868 | }
|
1869 | incoming = context.merge(incoming, (_a = {},
|
1870 | _a[storeFieldName] = incomingValue,
|
1871 | _a));
|
1872 | }
|
1873 | else if (globalThis.__DEV__ !== false &&
|
1874 | !context.clientOnly &&
|
1875 | !context.deferred &&
|
1876 | !utilities.addTypenameToDocument.added(field) &&
|
1877 | !policies.getReadFunction(typename, field.name.value)) {
|
1878 | globalThis.__DEV__ !== false && globals.invariant.error(12, utilities.resultKeyNameFromField(field), result);
|
1879 | }
|
1880 | });
|
1881 | try {
|
1882 | var _b = policies.identify(result, {
|
1883 | typename: typename,
|
1884 | selectionSet: selectionSet,
|
1885 | fragmentMap: context.fragmentMap,
|
1886 | storeObject: incoming,
|
1887 | readField: readField,
|
1888 | }), id = _b[0], keyObject = _b[1];
|
1889 | dataId = dataId || id;
|
1890 | if (keyObject) {
|
1891 | incoming = context.merge(incoming, keyObject);
|
1892 | }
|
1893 | }
|
1894 | catch (e) {
|
1895 | if (!dataId)
|
1896 | throw e;
|
1897 | }
|
1898 | if ("string" === typeof dataId) {
|
1899 | var dataRef = utilities.makeReference(dataId);
|
1900 | var sets = context.written[dataId] || (context.written[dataId] = []);
|
1901 | if (sets.indexOf(selectionSet) >= 0)
|
1902 | return dataRef;
|
1903 | sets.push(selectionSet);
|
1904 | if (this.reader &&
|
1905 | this.reader.isFresh(result, dataRef, selectionSet, context)) {
|
1906 | return dataRef;
|
1907 | }
|
1908 | var previous_1 = context.incomingById.get(dataId);
|
1909 | if (previous_1) {
|
1910 | previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
|
1911 | previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
|
1912 | fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
|
1913 | }
|
1914 | else {
|
1915 | context.incomingById.set(dataId, {
|
1916 | storeObject: incoming,
|
1917 | mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
|
1918 | fieldNodeSet: fieldNodeSet,
|
1919 | });
|
1920 | }
|
1921 | return dataRef;
|
1922 | }
|
1923 | return incoming;
|
1924 | };
|
1925 | StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
|
1926 | var _this = this;
|
1927 | if (!field.selectionSet || value === null) {
|
1928 | return globalThis.__DEV__ !== false ? utilities.cloneDeep(value) : value;
|
1929 | }
|
1930 | if (utilities.isArray(value)) {
|
1931 | return value.map(function (item, i) {
|
1932 | var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
|
1933 | maybeRecycleChildMergeTree(mergeTree, i);
|
1934 | return value;
|
1935 | });
|
1936 | }
|
1937 | return this.processSelectionSet({
|
1938 | result: value,
|
1939 | selectionSet: field.selectionSet,
|
1940 | context: context,
|
1941 | mergeTree: mergeTree,
|
1942 | });
|
1943 | };
|
1944 | StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
|
1945 | if (typename === void 0) { typename = utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap); }
|
1946 | var fieldMap = new Map();
|
1947 | var policies = this.cache.policies;
|
1948 | var limitingTrie = new trie.Trie(false);
|
1949 | (function flatten(selectionSet, inheritedContext) {
|
1950 | var visitedNode = limitingTrie.lookup(selectionSet,
|
1951 | inheritedContext.clientOnly, inheritedContext.deferred);
|
1952 | if (visitedNode.visited)
|
1953 | return;
|
1954 | visitedNode.visited = true;
|
1955 | selectionSet.selections.forEach(function (selection) {
|
1956 | if (!utilities.shouldInclude(selection, context.variables))
|
1957 | return;
|
1958 | var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
|
1959 | if (
|
1960 | !(clientOnly && deferred) &&
|
1961 | utilities.isNonEmptyArray(selection.directives)) {
|
1962 | selection.directives.forEach(function (dir) {
|
1963 | var name = dir.name.value;
|
1964 | if (name === "client")
|
1965 | clientOnly = true;
|
1966 | if (name === "defer") {
|
1967 | var args = utilities.argumentsObjectFromField(dir, context.variables);
|
1968 | if (!args || args.if !== false) {
|
1969 | deferred = true;
|
1970 | }
|
1971 | }
|
1972 | });
|
1973 | }
|
1974 | if (utilities.isField(selection)) {
|
1975 | var existing = fieldMap.get(selection);
|
1976 | if (existing) {
|
1977 | clientOnly = clientOnly && existing.clientOnly;
|
1978 | deferred = deferred && existing.deferred;
|
1979 | }
|
1980 | fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
|
1981 | }
|
1982 | else {
|
1983 | var fragment = utilities.getFragmentFromSelection(selection, context.lookupFragment);
|
1984 | if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
|
1985 | throw globals.newInvariantError(13, selection.name.value);
|
1986 | }
|
1987 | if (fragment &&
|
1988 | policies.fragmentMatches(fragment, typename, result, context.variables)) {
|
1989 | flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
|
1990 | }
|
1991 | }
|
1992 | });
|
1993 | })(selectionSet, context);
|
1994 | return fieldMap;
|
1995 | };
|
1996 | StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
|
1997 | var _a;
|
1998 | var _this = this;
|
1999 | if (mergeTree.map.size && !utilities.isReference(incoming)) {
|
2000 | var e_1 =
|
2001 | (!utilities.isArray(incoming) &&
|
2002 | (utilities.isReference(existing) || storeValueIsStoreObject(existing))) ?
|
2003 | existing
|
2004 | : void 0;
|
2005 | var i_1 = incoming;
|
2006 | if (e_1 && !getStorageArgs) {
|
2007 | getStorageArgs = [utilities.isReference(e_1) ? e_1.__ref : e_1];
|
2008 | }
|
2009 | var changedFields_1;
|
2010 | var getValue_1 = function (from, name) {
|
2011 | return (utilities.isArray(from) ?
|
2012 | typeof name === "number" ?
|
2013 | from[name]
|
2014 | : void 0
|
2015 | : context.store.getFieldValue(from, String(name)));
|
2016 | };
|
2017 | mergeTree.map.forEach(function (childTree, storeFieldName) {
|
2018 | var eVal = getValue_1(e_1, storeFieldName);
|
2019 | var iVal = getValue_1(i_1, storeFieldName);
|
2020 | if (void 0 === iVal)
|
2021 | return;
|
2022 | if (getStorageArgs) {
|
2023 | getStorageArgs.push(storeFieldName);
|
2024 | }
|
2025 | var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
|
2026 | if (aVal !== iVal) {
|
2027 | changedFields_1 = changedFields_1 || new Map();
|
2028 | changedFields_1.set(storeFieldName, aVal);
|
2029 | }
|
2030 | if (getStorageArgs) {
|
2031 | globals.invariant(getStorageArgs.pop() === storeFieldName);
|
2032 | }
|
2033 | });
|
2034 | if (changedFields_1) {
|
2035 | incoming = (utilities.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
|
2036 | changedFields_1.forEach(function (value, name) {
|
2037 | incoming[name] = value;
|
2038 | });
|
2039 | }
|
2040 | }
|
2041 | if (mergeTree.info) {
|
2042 | return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
|
2043 | }
|
2044 | return incoming;
|
2045 | };
|
2046 | return StoreWriter;
|
2047 | }());
|
2048 | var emptyMergeTreePool = [];
|
2049 | function getChildMergeTree(_a, name) {
|
2050 | var map = _a.map;
|
2051 | if (!map.has(name)) {
|
2052 | map.set(name, emptyMergeTreePool.pop() || { map: new Map() });
|
2053 | }
|
2054 | return map.get(name);
|
2055 | }
|
2056 | function mergeMergeTrees(left, right) {
|
2057 | if (left === right || !right || mergeTreeIsEmpty(right))
|
2058 | return left;
|
2059 | if (!left || mergeTreeIsEmpty(left))
|
2060 | return right;
|
2061 | var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
|
2062 | var needToMergeMaps = left.map.size && right.map.size;
|
2063 | var map = needToMergeMaps ? new Map()
|
2064 | : left.map.size ? left.map
|
2065 | : right.map;
|
2066 | var merged = { info: info, map: map };
|
2067 | if (needToMergeMaps) {
|
2068 | var remainingRightKeys_1 = new Set(right.map.keys());
|
2069 | left.map.forEach(function (leftTree, key) {
|
2070 | merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
|
2071 | remainingRightKeys_1.delete(key);
|
2072 | });
|
2073 | remainingRightKeys_1.forEach(function (key) {
|
2074 | merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
|
2075 | });
|
2076 | }
|
2077 | return merged;
|
2078 | }
|
2079 | function mergeTreeIsEmpty(tree) {
|
2080 | return !tree || !(tree.info || tree.map.size);
|
2081 | }
|
2082 | function maybeRecycleChildMergeTree(_a, name) {
|
2083 | var map = _a.map;
|
2084 | var childTree = map.get(name);
|
2085 | if (childTree && mergeTreeIsEmpty(childTree)) {
|
2086 | emptyMergeTreePool.push(childTree);
|
2087 | map.delete(name);
|
2088 | }
|
2089 | }
|
2090 | var warnings = new Set();
|
2091 | function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
|
2092 | var getChild = function (objOrRef) {
|
2093 | var child = store.getFieldValue(objOrRef, storeFieldName);
|
2094 | return typeof child === "object" && child;
|
2095 | };
|
2096 | var existing = getChild(existingRef);
|
2097 | if (!existing)
|
2098 | return;
|
2099 | var incoming = getChild(incomingObj);
|
2100 | if (!incoming)
|
2101 | return;
|
2102 | if (utilities.isReference(existing))
|
2103 | return;
|
2104 | if (equality.equal(existing, incoming))
|
2105 | return;
|
2106 | if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
|
2107 | return;
|
2108 | }
|
2109 | var parentType = store.getFieldValue(existingRef, "__typename") ||
|
2110 | store.getFieldValue(incomingObj, "__typename");
|
2111 | var fieldName = fieldNameFromStoreName(storeFieldName);
|
2112 | var typeDotName = "".concat(parentType, ".").concat(fieldName);
|
2113 | if (warnings.has(typeDotName))
|
2114 | return;
|
2115 | warnings.add(typeDotName);
|
2116 | var childTypenames = [];
|
2117 | if (!utilities.isArray(existing) && !utilities.isArray(incoming)) {
|
2118 | [existing, incoming].forEach(function (child) {
|
2119 | var typename = store.getFieldValue(child, "__typename");
|
2120 | if (typeof typename === "string" && !childTypenames.includes(typename)) {
|
2121 | childTypenames.push(typename);
|
2122 | }
|
2123 | });
|
2124 | }
|
2125 | globalThis.__DEV__ !== false && globals.invariant.warn(14, fieldName, parentType, childTypenames.length ?
|
2126 | "either ensure all objects of type " +
|
2127 | childTypenames.join(" and ") +
|
2128 | " have an ID or a custom merge function, or "
|
2129 | : "", typeDotName, existing, incoming);
|
2130 | }
|
2131 |
|
2132 | var InMemoryCache = (function (_super) {
|
2133 | tslib.__extends(InMemoryCache, _super);
|
2134 | function InMemoryCache(config) {
|
2135 | if (config === void 0) { config = {}; }
|
2136 | var _this = _super.call(this) || this;
|
2137 | _this.watches = new Set();
|
2138 | _this.addTypenameTransform = new utilities.DocumentTransform(utilities.addTypenameToDocument);
|
2139 | _this.assumeImmutableResults = true;
|
2140 | _this.makeVar = makeVar;
|
2141 | _this.txCount = 0;
|
2142 | _this.config = normalizeConfig(config);
|
2143 | _this.addTypename = !!_this.config.addTypename;
|
2144 | _this.policies = new Policies({
|
2145 | cache: _this,
|
2146 | dataIdFromObject: _this.config.dataIdFromObject,
|
2147 | possibleTypes: _this.config.possibleTypes,
|
2148 | typePolicies: _this.config.typePolicies,
|
2149 | });
|
2150 | _this.init();
|
2151 | return _this;
|
2152 | }
|
2153 | InMemoryCache.prototype.init = function () {
|
2154 | var rootStore = (this.data = new exports.EntityStore.Root({
|
2155 | policies: this.policies,
|
2156 | resultCaching: this.config.resultCaching,
|
2157 | }));
|
2158 | this.optimisticData = rootStore.stump;
|
2159 | this.resetResultCache();
|
2160 | };
|
2161 | InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
|
2162 | var _this = this;
|
2163 | var previousReader = this.storeReader;
|
2164 | var fragments = this.config.fragments;
|
2165 | this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({
|
2166 | cache: this,
|
2167 | addTypename: this.addTypename,
|
2168 | resultCacheMaxSize: this.config.resultCacheMaxSize,
|
2169 | canonizeResults: shouldCanonizeResults(this.config),
|
2170 | canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),
|
2171 | fragments: fragments,
|
2172 | })), fragments);
|
2173 | this.maybeBroadcastWatch = optimism.wrap(function (c, options) {
|
2174 | return _this.broadcastWatch(c, options);
|
2175 | }, {
|
2176 | max: this.config.resultCacheMaxSize ||
|
2177 | utilities.cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
|
2178 | 5000 ,
|
2179 | makeCacheKey: function (c) {
|
2180 | var store = c.optimistic ? _this.optimisticData : _this.data;
|
2181 | if (supportsResultCaching(store)) {
|
2182 | var optimistic = c.optimistic, id = c.id, variables = c.variables;
|
2183 | return store.makeCacheKey(c.query,
|
2184 | c.callback, utilities.canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));
|
2185 | }
|
2186 | },
|
2187 | });
|
2188 | new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {
|
2189 | return group.resetCaching();
|
2190 | });
|
2191 | };
|
2192 | InMemoryCache.prototype.restore = function (data) {
|
2193 | this.init();
|
2194 | if (data)
|
2195 | this.data.replace(data);
|
2196 | return this;
|
2197 | };
|
2198 | InMemoryCache.prototype.extract = function (optimistic) {
|
2199 | if (optimistic === void 0) { optimistic = false; }
|
2200 | return (optimistic ? this.optimisticData : this.data).extract();
|
2201 | };
|
2202 | InMemoryCache.prototype.read = function (options) {
|
2203 | var
|
2204 | _a = options.returnPartialData,
|
2205 | returnPartialData = _a === void 0 ? false : _a;
|
2206 | try {
|
2207 | return (this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);
|
2208 | }
|
2209 | catch (e) {
|
2210 | if (e instanceof MissingFieldError) {
|
2211 | return null;
|
2212 | }
|
2213 | throw e;
|
2214 | }
|
2215 | };
|
2216 | InMemoryCache.prototype.write = function (options) {
|
2217 | try {
|
2218 | ++this.txCount;
|
2219 | return this.storeWriter.writeToStore(this.data, options);
|
2220 | }
|
2221 | finally {
|
2222 | if (!--this.txCount && options.broadcast !== false) {
|
2223 | this.broadcastWatches();
|
2224 | }
|
2225 | }
|
2226 | };
|
2227 | InMemoryCache.prototype.modify = function (options) {
|
2228 | if (hasOwn.call(options, "id") && !options.id) {
|
2229 | return false;
|
2230 | }
|
2231 | var store = ((options.optimistic)
|
2232 | ) ?
|
2233 | this.optimisticData
|
2234 | : this.data;
|
2235 | try {
|
2236 | ++this.txCount;
|
2237 | return store.modify(options.id || "ROOT_QUERY", options.fields);
|
2238 | }
|
2239 | finally {
|
2240 | if (!--this.txCount && options.broadcast !== false) {
|
2241 | this.broadcastWatches();
|
2242 | }
|
2243 | }
|
2244 | };
|
2245 | InMemoryCache.prototype.diff = function (options) {
|
2246 | return this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || "ROOT_QUERY", config: this.config }));
|
2247 | };
|
2248 | InMemoryCache.prototype.watch = function (watch) {
|
2249 | var _this = this;
|
2250 | if (!this.watches.size) {
|
2251 | recallCache(this);
|
2252 | }
|
2253 | this.watches.add(watch);
|
2254 | if (watch.immediate) {
|
2255 | this.maybeBroadcastWatch(watch);
|
2256 | }
|
2257 | return function () {
|
2258 | if (_this.watches.delete(watch) && !_this.watches.size) {
|
2259 | forgetCache(_this);
|
2260 | }
|
2261 | _this.maybeBroadcastWatch.forget(watch);
|
2262 | };
|
2263 | };
|
2264 | InMemoryCache.prototype.gc = function (options) {
|
2265 | var _a;
|
2266 | utilities.canonicalStringify.reset();
|
2267 | utilities.print.reset();
|
2268 | this.addTypenameTransform.resetCache();
|
2269 | (_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();
|
2270 | var ids = this.optimisticData.gc();
|
2271 | if (options && !this.txCount) {
|
2272 | if (options.resetResultCache) {
|
2273 | this.resetResultCache(options.resetResultIdentities);
|
2274 | }
|
2275 | else if (options.resetResultIdentities) {
|
2276 | this.storeReader.resetCanon();
|
2277 | }
|
2278 | }
|
2279 | return ids;
|
2280 | };
|
2281 | InMemoryCache.prototype.retain = function (rootId, optimistic) {
|
2282 | return (optimistic ? this.optimisticData : this.data).retain(rootId);
|
2283 | };
|
2284 | InMemoryCache.prototype.release = function (rootId, optimistic) {
|
2285 | return (optimistic ? this.optimisticData : this.data).release(rootId);
|
2286 | };
|
2287 | InMemoryCache.prototype.identify = function (object) {
|
2288 | if (utilities.isReference(object))
|
2289 | return object.__ref;
|
2290 | try {
|
2291 | return this.policies.identify(object)[0];
|
2292 | }
|
2293 | catch (e) {
|
2294 | globalThis.__DEV__ !== false && globals.invariant.warn(e);
|
2295 | }
|
2296 | };
|
2297 | InMemoryCache.prototype.evict = function (options) {
|
2298 | if (!options.id) {
|
2299 | if (hasOwn.call(options, "id")) {
|
2300 | return false;
|
2301 | }
|
2302 | options = tslib.__assign(tslib.__assign({}, options), { id: "ROOT_QUERY" });
|
2303 | }
|
2304 | try {
|
2305 | ++this.txCount;
|
2306 | return this.optimisticData.evict(options, this.data);
|
2307 | }
|
2308 | finally {
|
2309 | if (!--this.txCount && options.broadcast !== false) {
|
2310 | this.broadcastWatches();
|
2311 | }
|
2312 | }
|
2313 | };
|
2314 | InMemoryCache.prototype.reset = function (options) {
|
2315 | var _this = this;
|
2316 | this.init();
|
2317 | utilities.canonicalStringify.reset();
|
2318 | if (options && options.discardWatches) {
|
2319 | this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
|
2320 | this.watches.clear();
|
2321 | forgetCache(this);
|
2322 | }
|
2323 | else {
|
2324 | this.broadcastWatches();
|
2325 | }
|
2326 | return Promise.resolve();
|
2327 | };
|
2328 | InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
|
2329 | var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
|
2330 | if (newOptimisticData !== this.optimisticData) {
|
2331 | this.optimisticData = newOptimisticData;
|
2332 | this.broadcastWatches();
|
2333 | }
|
2334 | };
|
2335 | InMemoryCache.prototype.batch = function (options) {
|
2336 | var _this = this;
|
2337 | var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
|
2338 | var updateResult;
|
2339 | var perform = function (layer) {
|
2340 | var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
|
2341 | ++_this.txCount;
|
2342 | if (layer) {
|
2343 | _this.data = _this.optimisticData = layer;
|
2344 | }
|
2345 | try {
|
2346 | return (updateResult = update(_this));
|
2347 | }
|
2348 | finally {
|
2349 | --_this.txCount;
|
2350 | _this.data = data;
|
2351 | _this.optimisticData = optimisticData;
|
2352 | }
|
2353 | };
|
2354 | var alreadyDirty = new Set();
|
2355 | if (onWatchUpdated && !this.txCount) {
|
2356 | this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch) {
|
2357 | alreadyDirty.add(watch);
|
2358 | return false;
|
2359 | } }));
|
2360 | }
|
2361 | if (typeof optimistic === "string") {
|
2362 | this.optimisticData = this.optimisticData.addLayer(optimistic, perform);
|
2363 | }
|
2364 | else if (optimistic === false) {
|
2365 | perform(this.data);
|
2366 | }
|
2367 | else {
|
2368 | perform();
|
2369 | }
|
2370 | if (typeof removeOptimistic === "string") {
|
2371 | this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);
|
2372 | }
|
2373 | if (onWatchUpdated && alreadyDirty.size) {
|
2374 | this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch, diff) {
|
2375 | var result = onWatchUpdated.call(this, watch, diff);
|
2376 | if (result !== false) {
|
2377 | alreadyDirty.delete(watch);
|
2378 | }
|
2379 | return result;
|
2380 | } }));
|
2381 | if (alreadyDirty.size) {
|
2382 | alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
|
2383 | }
|
2384 | }
|
2385 | else {
|
2386 | this.broadcastWatches(options);
|
2387 | }
|
2388 | return updateResult;
|
2389 | };
|
2390 | InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
|
2391 | return this.batch({
|
2392 | update: update,
|
2393 | optimistic: optimisticId || optimisticId !== null,
|
2394 | });
|
2395 | };
|
2396 | InMemoryCache.prototype.transformDocument = function (document) {
|
2397 | return this.addTypenameToDocument(this.addFragmentsToDocument(document));
|
2398 | };
|
2399 | InMemoryCache.prototype.broadcastWatches = function (options) {
|
2400 | var _this = this;
|
2401 | if (!this.txCount) {
|
2402 | this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
|
2403 | }
|
2404 | };
|
2405 | InMemoryCache.prototype.addFragmentsToDocument = function (document) {
|
2406 | var fragments = this.config.fragments;
|
2407 | return fragments ? fragments.transform(document) : document;
|
2408 | };
|
2409 | InMemoryCache.prototype.addTypenameToDocument = function (document) {
|
2410 | if (this.addTypename) {
|
2411 | return this.addTypenameTransform.transformDocument(document);
|
2412 | }
|
2413 | return document;
|
2414 | };
|
2415 | InMemoryCache.prototype.broadcastWatch = function (c, options) {
|
2416 | var lastDiff = c.lastDiff;
|
2417 | var diff = this.diff(c);
|
2418 | if (options) {
|
2419 | if (c.optimistic && typeof options.optimistic === "string") {
|
2420 | diff.fromOptimisticTransaction = true;
|
2421 | }
|
2422 | if (options.onWatchUpdated &&
|
2423 | options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {
|
2424 | return;
|
2425 | }
|
2426 | }
|
2427 | if (!lastDiff || !equality.equal(lastDiff.result, diff.result)) {
|
2428 | c.callback((c.lastDiff = diff), lastDiff);
|
2429 | }
|
2430 | };
|
2431 | return InMemoryCache;
|
2432 | }(ApolloCache));
|
2433 | if (globalThis.__DEV__ !== false) {
|
2434 | InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;
|
2435 | }
|
2436 |
|
2437 | function createFragmentRegistry() {
|
2438 | var fragments = [];
|
2439 | for (var _i = 0; _i < arguments.length; _i++) {
|
2440 | fragments[_i] = arguments[_i];
|
2441 | }
|
2442 | return new (FragmentRegistry.bind.apply(FragmentRegistry, tslib.__spreadArray([void 0], fragments, false)))();
|
2443 | }
|
2444 | var FragmentRegistry = (function () {
|
2445 | function FragmentRegistry() {
|
2446 | var fragments = [];
|
2447 | for (var _i = 0; _i < arguments.length; _i++) {
|
2448 | fragments[_i] = arguments[_i];
|
2449 | }
|
2450 | this.registry = Object.create(null);
|
2451 | this.resetCaches();
|
2452 | if (fragments.length) {
|
2453 | this.register.apply(this, fragments);
|
2454 | }
|
2455 | }
|
2456 | FragmentRegistry.prototype.register = function () {
|
2457 | var _this = this;
|
2458 | var fragments = [];
|
2459 | for (var _i = 0; _i < arguments.length; _i++) {
|
2460 | fragments[_i] = arguments[_i];
|
2461 | }
|
2462 | var definitions = new Map();
|
2463 | fragments.forEach(function (doc) {
|
2464 | utilities.getFragmentDefinitions(doc).forEach(function (node) {
|
2465 | definitions.set(node.name.value, node);
|
2466 | });
|
2467 | });
|
2468 | definitions.forEach(function (node, name) {
|
2469 | if (node !== _this.registry[name]) {
|
2470 | _this.registry[name] = node;
|
2471 | _this.invalidate(name);
|
2472 | }
|
2473 | });
|
2474 | return this;
|
2475 | };
|
2476 | FragmentRegistry.prototype.invalidate = function (name) { };
|
2477 | FragmentRegistry.prototype.resetCaches = function () {
|
2478 | var proto = FragmentRegistry.prototype;
|
2479 | this.invalidate = (this.lookup = optimism.wrap(proto.lookup.bind(this), {
|
2480 | makeCacheKey: function (arg) { return arg; },
|
2481 | max: utilities.cacheSizes["fragmentRegistry.lookup"] ||
|
2482 | 1000 ,
|
2483 | })).dirty;
|
2484 | this.transform = optimism.wrap(proto.transform.bind(this), {
|
2485 | cache: caches.WeakCache,
|
2486 | max: utilities.cacheSizes["fragmentRegistry.transform"] ||
|
2487 | 2000 ,
|
2488 | });
|
2489 | this.findFragmentSpreads = optimism.wrap(proto.findFragmentSpreads.bind(this), {
|
2490 | cache: caches.WeakCache,
|
2491 | max: utilities.cacheSizes["fragmentRegistry.findFragmentSpreads"] ||
|
2492 | 4000 ,
|
2493 | });
|
2494 | };
|
2495 | FragmentRegistry.prototype.lookup = function (fragmentName) {
|
2496 | return this.registry[fragmentName] || null;
|
2497 | };
|
2498 | FragmentRegistry.prototype.transform = function (document) {
|
2499 | var _this = this;
|
2500 | var defined = new Map();
|
2501 | utilities.getFragmentDefinitions(document).forEach(function (def) {
|
2502 | defined.set(def.name.value, def);
|
2503 | });
|
2504 | var unbound = new Set();
|
2505 | var enqueue = function (spreadName) {
|
2506 | if (!defined.has(spreadName)) {
|
2507 | unbound.add(spreadName);
|
2508 | }
|
2509 | };
|
2510 | var enqueueChildSpreads = function (node) {
|
2511 | return Object.keys(_this.findFragmentSpreads(node)).forEach(enqueue);
|
2512 | };
|
2513 | enqueueChildSpreads(document);
|
2514 | var missing = [];
|
2515 | var map = Object.create(null);
|
2516 | unbound.forEach(function (fragmentName) {
|
2517 | var knownFragmentDef = defined.get(fragmentName);
|
2518 | if (knownFragmentDef) {
|
2519 | enqueueChildSpreads((map[fragmentName] = knownFragmentDef));
|
2520 | }
|
2521 | else {
|
2522 | missing.push(fragmentName);
|
2523 | var def = _this.lookup(fragmentName);
|
2524 | if (def) {
|
2525 | enqueueChildSpreads((map[fragmentName] = def));
|
2526 | }
|
2527 | }
|
2528 | });
|
2529 | if (missing.length) {
|
2530 | var defsToAppend_1 = [];
|
2531 | missing.forEach(function (name) {
|
2532 | var def = map[name];
|
2533 | if (def) {
|
2534 | defsToAppend_1.push(def);
|
2535 | }
|
2536 | });
|
2537 | if (defsToAppend_1.length) {
|
2538 | document = tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.concat(defsToAppend_1) });
|
2539 | }
|
2540 | }
|
2541 | return document;
|
2542 | };
|
2543 | FragmentRegistry.prototype.findFragmentSpreads = function (root) {
|
2544 | var spreads = Object.create(null);
|
2545 | graphql.visit(root, {
|
2546 | FragmentSpread: function (node) {
|
2547 | spreads[node.name.value] = node;
|
2548 | },
|
2549 | });
|
2550 | return spreads;
|
2551 | };
|
2552 | return FragmentRegistry;
|
2553 | }());
|
2554 |
|
2555 | exports.canonicalStringify = utilities.canonicalStringify;
|
2556 | exports.isReference = utilities.isReference;
|
2557 | exports.makeReference = utilities.makeReference;
|
2558 | exports.ApolloCache = ApolloCache;
|
2559 | exports.InMemoryCache = InMemoryCache;
|
2560 | exports.MissingFieldError = MissingFieldError;
|
2561 | exports.Policies = Policies;
|
2562 | exports.cacheSlot = cacheSlot;
|
2563 | exports.createFragmentRegistry = createFragmentRegistry;
|
2564 | exports.defaultDataIdFromObject = defaultDataIdFromObject;
|
2565 | exports.fieldNameFromStoreName = fieldNameFromStoreName;
|
2566 | exports.makeVar = makeVar;
|
2567 |
|