You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
284 lines
10 KiB
284 lines
10 KiB
'use strict'; |
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
var trie = require('@wry/trie'); |
|
var utilities = require('../../utilities'); |
|
var tslib = require('tslib'); |
|
var equality = require('@wry/equality'); |
|
|
|
var QUERY_REFERENCE_SYMBOL = Symbol(); |
|
var PROMISE_SYMBOL = Symbol(); |
|
function wrapQueryRef(internalQueryRef) { |
|
var _a; |
|
var ref = (_a = { |
|
toPromise: function () { |
|
return getWrappedPromise(ref).then(function () { return ref; }); |
|
} |
|
}, |
|
_a[QUERY_REFERENCE_SYMBOL] = internalQueryRef, |
|
_a[PROMISE_SYMBOL] = internalQueryRef.promise, |
|
_a); |
|
return ref; |
|
} |
|
function getWrappedPromise(queryRef) { |
|
var internalQueryRef = unwrapQueryRef(queryRef); |
|
return internalQueryRef.promise.status === "fulfilled" ? |
|
internalQueryRef.promise |
|
: queryRef[PROMISE_SYMBOL]; |
|
} |
|
function unwrapQueryRef(queryRef) { |
|
return queryRef[QUERY_REFERENCE_SYMBOL]; |
|
} |
|
function updateWrappedQueryRef(queryRef, promise) { |
|
queryRef[PROMISE_SYMBOL] = promise; |
|
} |
|
var OBSERVED_CHANGED_OPTIONS = [ |
|
"canonizeResults", |
|
"context", |
|
"errorPolicy", |
|
"fetchPolicy", |
|
"refetchWritePolicy", |
|
"returnPartialData", |
|
]; |
|
var InternalQueryReference = (function () { |
|
function InternalQueryReference(observable, options) { |
|
var _this = this; |
|
this.key = {}; |
|
this.listeners = new Set(); |
|
this.references = 0; |
|
this.handleNext = this.handleNext.bind(this); |
|
this.handleError = this.handleError.bind(this); |
|
this.dispose = this.dispose.bind(this); |
|
this.observable = observable; |
|
if (options.onDispose) { |
|
this.onDispose = options.onDispose; |
|
} |
|
this.setResult(); |
|
this.subscribeToQuery(); |
|
var startDisposeTimer = function () { |
|
var _a; |
|
if (!_this.references) { |
|
_this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000); |
|
} |
|
}; |
|
this.promise.then(startDisposeTimer, startDisposeTimer); |
|
} |
|
Object.defineProperty(InternalQueryReference.prototype, "disposed", { |
|
get: function () { |
|
return this.subscription.closed; |
|
}, |
|
enumerable: false, |
|
configurable: true |
|
}); |
|
Object.defineProperty(InternalQueryReference.prototype, "watchQueryOptions", { |
|
get: function () { |
|
return this.observable.options; |
|
}, |
|
enumerable: false, |
|
configurable: true |
|
}); |
|
InternalQueryReference.prototype.reinitialize = function () { |
|
var observable = this.observable; |
|
var originalFetchPolicy = this.watchQueryOptions.fetchPolicy; |
|
try { |
|
if (originalFetchPolicy !== "no-cache") { |
|
observable.resetLastResults(); |
|
observable.silentSetOptions({ fetchPolicy: "cache-first" }); |
|
} |
|
else { |
|
observable.silentSetOptions({ fetchPolicy: "standby" }); |
|
} |
|
this.subscribeToQuery(); |
|
if (originalFetchPolicy === "no-cache") { |
|
return; |
|
} |
|
observable.resetDiff(); |
|
this.setResult(); |
|
} |
|
finally { |
|
observable.silentSetOptions({ fetchPolicy: originalFetchPolicy }); |
|
} |
|
}; |
|
InternalQueryReference.prototype.retain = function () { |
|
var _this = this; |
|
this.references++; |
|
clearTimeout(this.autoDisposeTimeoutId); |
|
var disposed = false; |
|
return function () { |
|
if (disposed) { |
|
return; |
|
} |
|
disposed = true; |
|
_this.references--; |
|
setTimeout(function () { |
|
if (!_this.references) { |
|
_this.dispose(); |
|
} |
|
}); |
|
}; |
|
}; |
|
InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) { |
|
var _this = this; |
|
return OBSERVED_CHANGED_OPTIONS.some(function (option) { |
|
return !equality.equal(_this.watchQueryOptions[option], watchQueryOptions[option]); |
|
}); |
|
}; |
|
InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) { |
|
var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults; |
|
if (currentFetchPolicy === "standby" && |
|
currentFetchPolicy !== watchQueryOptions.fetchPolicy) { |
|
this.initiateFetch(this.observable.reobserve(watchQueryOptions)); |
|
} |
|
else { |
|
this.observable.silentSetOptions(watchQueryOptions); |
|
if (currentCanonizeResults !== watchQueryOptions.canonizeResults) { |
|
this.result = tslib.__assign(tslib.__assign({}, this.result), this.observable.getCurrentResult()); |
|
this.promise = utilities.createFulfilledPromise(this.result); |
|
} |
|
} |
|
return this.promise; |
|
}; |
|
InternalQueryReference.prototype.listen = function (listener) { |
|
var _this = this; |
|
this.listeners.add(listener); |
|
return function () { |
|
_this.listeners.delete(listener); |
|
}; |
|
}; |
|
InternalQueryReference.prototype.refetch = function (variables) { |
|
return this.initiateFetch(this.observable.refetch(variables)); |
|
}; |
|
InternalQueryReference.prototype.fetchMore = function (options) { |
|
return this.initiateFetch(this.observable.fetchMore(options)); |
|
}; |
|
InternalQueryReference.prototype.dispose = function () { |
|
this.subscription.unsubscribe(); |
|
this.onDispose(); |
|
}; |
|
InternalQueryReference.prototype.onDispose = function () { |
|
}; |
|
InternalQueryReference.prototype.handleNext = function (result) { |
|
var _a; |
|
switch (this.promise.status) { |
|
case "pending": { |
|
if (result.data === void 0) { |
|
result.data = this.result.data; |
|
} |
|
this.result = result; |
|
(_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result); |
|
break; |
|
} |
|
default: { |
|
if (result.data === this.result.data && |
|
result.networkStatus === this.result.networkStatus) { |
|
return; |
|
} |
|
if (result.data === void 0) { |
|
result.data = this.result.data; |
|
} |
|
this.result = result; |
|
this.promise = utilities.createFulfilledPromise(result); |
|
this.deliver(this.promise); |
|
break; |
|
} |
|
} |
|
}; |
|
InternalQueryReference.prototype.handleError = function (error) { |
|
var _a; |
|
this.subscription.unsubscribe(); |
|
this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError); |
|
switch (this.promise.status) { |
|
case "pending": { |
|
(_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error); |
|
break; |
|
} |
|
default: { |
|
this.promise = utilities.createRejectedPromise(error); |
|
this.deliver(this.promise); |
|
} |
|
} |
|
}; |
|
InternalQueryReference.prototype.deliver = function (promise) { |
|
this.listeners.forEach(function (listener) { return listener(promise); }); |
|
}; |
|
InternalQueryReference.prototype.initiateFetch = function (returnedPromise) { |
|
var _this = this; |
|
this.promise = this.createPendingPromise(); |
|
this.promise.catch(function () { }); |
|
returnedPromise |
|
.then(function (result) { |
|
var _a; |
|
if (_this.promise.status === "pending") { |
|
_this.result = result; |
|
(_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, result); |
|
} |
|
}) |
|
.catch(function () { }); |
|
return returnedPromise; |
|
}; |
|
InternalQueryReference.prototype.subscribeToQuery = function () { |
|
var _this = this; |
|
this.subscription = this.observable |
|
.filter(function (result) { return !equality.equal(result.data, {}) && !equality.equal(result, _this.result); }) |
|
.subscribe(this.handleNext, this.handleError); |
|
}; |
|
InternalQueryReference.prototype.setResult = function () { |
|
var result = this.observable.getCurrentResult(false); |
|
if (equality.equal(result, this.result)) { |
|
return; |
|
} |
|
this.result = result; |
|
this.promise = |
|
(result.data && |
|
(!result.partial || this.watchQueryOptions.returnPartialData)) ? |
|
utilities.createFulfilledPromise(result) |
|
: this.createPendingPromise(); |
|
}; |
|
InternalQueryReference.prototype.createPendingPromise = function () { |
|
var _this = this; |
|
return utilities.wrapPromiseWithState(new Promise(function (resolve, reject) { |
|
_this.resolve = resolve; |
|
_this.reject = reject; |
|
})); |
|
}; |
|
return InternalQueryReference; |
|
}()); |
|
|
|
var SuspenseCache = (function () { |
|
function SuspenseCache(options) { |
|
if (options === void 0) { options = Object.create(null); } |
|
this.queryRefs = new trie.Trie(utilities.canUseWeakMap); |
|
this.options = options; |
|
} |
|
SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) { |
|
var ref = this.queryRefs.lookupArray(cacheKey); |
|
if (!ref.current) { |
|
ref.current = new InternalQueryReference(createObservable(), { |
|
autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs, |
|
onDispose: function () { |
|
delete ref.current; |
|
}, |
|
}); |
|
} |
|
return ref.current; |
|
}; |
|
return SuspenseCache; |
|
}()); |
|
|
|
var suspenseCacheSymbol = Symbol.for("apollo.suspenseCache"); |
|
function getSuspenseCache(client) { |
|
var _a; |
|
if (!client[suspenseCacheSymbol]) { |
|
client[suspenseCacheSymbol] = new SuspenseCache((_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense); |
|
} |
|
return client[suspenseCacheSymbol]; |
|
} |
|
|
|
exports.InternalQueryReference = InternalQueryReference; |
|
exports.getSuspenseCache = getSuspenseCache; |
|
exports.getWrappedPromise = getWrappedPromise; |
|
exports.unwrapQueryRef = unwrapQueryRef; |
|
exports.updateWrappedQueryRef = updateWrappedQueryRef; |
|
exports.wrapQueryRef = wrapQueryRef; |
|
//# sourceMappingURL=internal.cjs.map
|
|
|