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.
285 lines
10 KiB
285 lines
10 KiB
4 months ago
|
'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
|