@apollo/client 3.6.3 → 3.6.6

package/errors/errors.cjs.native.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+require('../utilities/globals');
+var utilities = require('../utilities');
+
+function isApolloError(err) {
+    return err.hasOwnProperty('graphQLErrors');
+}
+var generateErrorMessage = function (err) {
+    var message = '';
+    if (utilities.isNonEmptyArray(err.graphQLErrors) || utilities.isNonEmptyArray(err.clientErrors)) {
+        var errors = (err.graphQLErrors || [])
+            .concat(err.clientErrors || []);
+        errors.forEach(function (error) {
+            var errorMessage = error
+                ? error.message
+                : 'Error message not found.';
+            message += "".concat(errorMessage, "\n");
+        });
+    }
+    if (err.networkError) {
+        message += "".concat(err.networkError.message, "\n");
+    }
+    message = message.replace(/\n$/, '');
+    return message;
+};
+var ApolloError = (function (_super) {
+    tslib.__extends(ApolloError, _super);
+    function ApolloError(_a) {
+        var graphQLErrors = _a.graphQLErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
+        var _this = _super.call(this, errorMessage) || this;
+        _this.graphQLErrors = graphQLErrors || [];
+        _this.clientErrors = clientErrors || [];
+        _this.networkError = networkError || null;
+        _this.message = errorMessage || generateErrorMessage(_this);
+        _this.extraInfo = extraInfo;
+        _this.__proto__ = ApolloError.prototype;
+        return _this;
+    }
+    return ApolloError;
+}(Error));
+
+exports.ApolloError = ApolloError;
+exports.isApolloError = isApolloError;
+//# sourceMappingURL=errors.cjs.map

package/invariantErrorCodes.js

@@ -5,7 +5,7 @@
 // consult the @apollo/client/invariantErrorCodes.js file specific to
 // your @apollo/client version. This file is not meant to be imported.
 {
-  "@apollo/client version": "3.6.3",
+  "@apollo/client version": "3.6.6",
 
   1: {
     file: "@apollo/client/cache/inmemory/entityStore.js",

package/link/batch/batch.cjs.native.js

@@ -0,0 +1,161 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+var OperationBatcher = (function () {
+    function OperationBatcher(_a) {
+        var batchDebounce = _a.batchDebounce, batchInterval = _a.batchInterval, batchMax = _a.batchMax, batchHandler = _a.batchHandler, batchKey = _a.batchKey;
+        this.batchesByKey = new Map();
+        this.batchDebounce = batchDebounce;
+        this.batchInterval = batchInterval;
+        this.batchMax = batchMax || 0;
+        this.batchHandler = batchHandler;
+        this.batchKey = batchKey || (function () { return ''; });
+    }
+    OperationBatcher.prototype.enqueueRequest = function (request) {
+        var _this = this;
+        var requestCopy = tslib.__assign(tslib.__assign({}, request), { next: [], error: [], complete: [], subscribers: new Set() });
+        var key = this.batchKey(request.operation);
+        if (!requestCopy.observable) {
+            requestCopy.observable = new utilities.Observable(function (observer) {
+                var batch = _this.batchesByKey.get(key);
+                if (!batch)
+                    _this.batchesByKey.set(key, batch = new Set());
+                var isFirstEnqueuedRequest = batch.size === 0;
+                var isFirstSubscriber = requestCopy.subscribers.size === 0;
+                requestCopy.subscribers.add(observer);
+                if (isFirstSubscriber) {
+                    batch.add(requestCopy);
+                }
+                if (observer.next) {
+                    requestCopy.next.push(observer.next.bind(observer));
+                }
+                if (observer.error) {
+                    requestCopy.error.push(observer.error.bind(observer));
+                }
+                if (observer.complete) {
+                    requestCopy.complete.push(observer.complete.bind(observer));
+                }
+                if (isFirstEnqueuedRequest) {
+                    _this.scheduleQueueConsumption(key);
+                }
+                else if (_this.batchDebounce) {
+                    clearTimeout(_this.scheduledBatchTimer);
+                    _this.scheduleQueueConsumption(key);
+                }
+                if (batch.size === _this.batchMax) {
+                    _this.consumeQueue(key);
+                }
+                return function () {
+                    var _a;
+                    if (requestCopy.subscribers.delete(observer) &&
+                        requestCopy.subscribers.size < 1) {
+                        if (batch.delete(requestCopy) && batch.size < 1) {
+                            clearTimeout(_this.scheduledBatchTimer);
+                            _this.batchesByKey.delete(key);
+                            (_a = batch.subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+                        }
+                    }
+                };
+            });
+        }
+        return requestCopy.observable;
+    };
+    OperationBatcher.prototype.consumeQueue = function (key) {
+        if (key === void 0) { key = ''; }
+        var batch = this.batchesByKey.get(key);
+        this.batchesByKey.delete(key);
+        if (!batch || !batch.size) {
+            return;
+        }
+        var operations = [];
+        var forwards = [];
+        var observables = [];
+        var nexts = [];
+        var errors = [];
+        var completes = [];
+        batch.forEach(function (request) {
+            operations.push(request.operation);
+            forwards.push(request.forward);
+            observables.push(request.observable);
+            nexts.push(request.next);
+            errors.push(request.error);
+            completes.push(request.complete);
+        });
+        var batchedObservable = this.batchHandler(operations, forwards) || utilities.Observable.of();
+        var onError = function (error) {
+            errors.forEach(function (rejecters) {
+                if (rejecters) {
+                    rejecters.forEach(function (e) { return e(error); });
+                }
+            });
+        };
+        batch.subscription = batchedObservable.subscribe({
+            next: function (results) {
+                if (!Array.isArray(results)) {
+                    results = [results];
+                }
+                if (nexts.length !== results.length) {
+                    var error = new Error("server returned results with length ".concat(results.length, ", expected length of ").concat(nexts.length));
+                    error.result = results;
+                    return onError(error);
+                }
+                results.forEach(function (result, index) {
+                    if (nexts[index]) {
+                        nexts[index].forEach(function (next) { return next(result); });
+                    }
+                });
+            },
+            error: onError,
+            complete: function () {
+                completes.forEach(function (complete) {
+                    if (complete) {
+                        complete.forEach(function (c) { return c(); });
+                    }
+                });
+            },
+        });
+        return observables;
+    };
+    OperationBatcher.prototype.scheduleQueueConsumption = function (key) {
+        var _this = this;
+        this.scheduledBatchTimer = setTimeout(function () {
+            _this.consumeQueue(key);
+        }, this.batchInterval);
+    };
+    return OperationBatcher;
+}());
+
+var BatchLink = (function (_super) {
+    tslib.__extends(BatchLink, _super);
+    function BatchLink(fetchParams) {
+        var _this = _super.call(this) || this;
+        var _a = fetchParams || {}, batchDebounce = _a.batchDebounce, _b = _a.batchInterval, batchInterval = _b === void 0 ? 10 : _b, _c = _a.batchMax, batchMax = _c === void 0 ? 0 : _c, _d = _a.batchHandler, batchHandler = _d === void 0 ? function () { return null; } : _d, _e = _a.batchKey, batchKey = _e === void 0 ? function () { return ''; } : _e;
+        _this.batcher = new OperationBatcher({
+            batchDebounce: batchDebounce,
+            batchInterval: batchInterval,
+            batchMax: batchMax,
+            batchHandler: batchHandler,
+            batchKey: batchKey,
+        });
+        if (fetchParams.batchHandler.length <= 1) {
+            _this.request = function (operation) { return _this.batcher.enqueueRequest({ operation: operation }); };
+        }
+        return _this;
+    }
+    BatchLink.prototype.request = function (operation, forward) {
+        return this.batcher.enqueueRequest({
+            operation: operation,
+            forward: forward,
+        });
+    };
+    return BatchLink;
+}(core.ApolloLink));
+
+exports.BatchLink = BatchLink;
+exports.OperationBatcher = OperationBatcher;
+//# sourceMappingURL=batch.cjs.map

package/link/batch-http/batch-http.cjs.native.js

@@ -0,0 +1,127 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('../core');
+var utilities = require('../../utilities');
+var utils = require('../utils');
+var http = require('../http');
+var batch = require('../batch');
+
+var BatchHttpLink = (function (_super) {
+    tslib.__extends(BatchHttpLink, _super);
+    function BatchHttpLink(fetchParams) {
+        var _this = _super.call(this) || this;
+        var _a = fetchParams || {}, _b = _a.uri, uri = _b === void 0 ? '/graphql' : _b, fetcher = _a.fetch, _c = _a.print, print = _c === void 0 ? http.defaultPrinter : _c, includeExtensions = _a.includeExtensions, batchInterval = _a.batchInterval, batchDebounce = _a.batchDebounce, batchMax = _a.batchMax, batchKey = _a.batchKey, requestOptions = tslib.__rest(_a, ["uri", "fetch", "print", "includeExtensions", "batchInterval", "batchDebounce", "batchMax", "batchKey"]);
+        http.checkFetcher(fetcher);
+        if (!fetcher) {
+            fetcher = fetch;
+        }
+        var linkConfig = {
+            http: { includeExtensions: includeExtensions },
+            options: requestOptions.fetchOptions,
+            credentials: requestOptions.credentials,
+            headers: requestOptions.headers,
+        };
+        _this.batchDebounce = batchDebounce;
+        _this.batchInterval = batchInterval || 10;
+        _this.batchMax = batchMax || 10;
+        var batchHandler = function (operations) {
+            var chosenURI = http.selectURI(operations[0], uri);
+            var context = operations[0].getContext();
+            var clientAwarenessHeaders = {};
+            if (context.clientAwareness) {
+                var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;
+                if (name_1) {
+                    clientAwarenessHeaders['apollographql-client-name'] = name_1;
+                }
+                if (version) {
+                    clientAwarenessHeaders['apollographql-client-version'] = version;
+                }
+            }
+            var contextConfig = {
+                http: context.http,
+                options: context.fetchOptions,
+                credentials: context.credentials,
+                headers: tslib.__assign(tslib.__assign({}, clientAwarenessHeaders), context.headers),
+            };
+            var optsAndBody = operations.map(function (operation) {
+                return http.selectHttpOptionsAndBodyInternal(operation, print, http.fallbackHttpConfig, linkConfig, contextConfig);
+            });
+            var loadedBody = optsAndBody.map(function (_a) {
+                var body = _a.body;
+                return body;
+            });
+            var options = optsAndBody[0].options;
+            if (options.method === 'GET') {
+                return utils.fromError(new Error('apollo-link-batch-http does not support GET requests'));
+            }
+            try {
+                options.body = http.serializeFetchParameter(loadedBody, 'Payload');
+            }
+            catch (parseError) {
+                return utils.fromError(parseError);
+            }
+            var controller;
+            if (!options.signal) {
+                var _b = http.createSignalIfSupported(), _controller = _b.controller, signal = _b.signal;
+                controller = _controller;
+                if (controller)
+                    options.signal = signal;
+            }
+            return new utilities.Observable(function (observer) {
+                fetcher(chosenURI, options)
+                    .then(function (response) {
+                    operations.forEach(function (operation) { return operation.setContext({ response: response }); });
+                    return response;
+                })
+                    .then(http.parseAndCheckHttpResponse(operations))
+                    .then(function (result) {
+                    observer.next(result);
+                    observer.complete();
+                    return result;
+                })
+                    .catch(function (err) {
+                    if (err.name === 'AbortError')
+                        return;
+                    if (err.result && err.result.errors && err.result.data) {
+                        observer.next(err.result);
+                    }
+                    observer.error(err);
+                });
+                return function () {
+                    if (controller)
+                        controller.abort();
+                };
+            });
+        };
+        batchKey =
+            batchKey ||
+                (function (operation) {
+                    var context = operation.getContext();
+                    var contextConfig = {
+                        http: context.http,
+                        options: context.fetchOptions,
+                        credentials: context.credentials,
+                        headers: context.headers,
+                    };
+                    return http.selectURI(operation, uri) + JSON.stringify(contextConfig);
+                });
+        _this.batcher = new batch.BatchLink({
+            batchDebounce: _this.batchDebounce,
+            batchInterval: _this.batchInterval,
+            batchMax: _this.batchMax,
+            batchKey: batchKey,
+            batchHandler: batchHandler,
+        });
+        return _this;
+    }
+    BatchHttpLink.prototype.request = function (operation) {
+        return this.batcher.request(operation);
+    };
+    return BatchHttpLink;
+}(core.ApolloLink));
+
+exports.BatchHttpLink = BatchHttpLink;
+//# sourceMappingURL=batch-http.cjs.map

package/link/context/context.cjs.native.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+function setContext(setter) {
+    return new core.ApolloLink(function (operation, forward) {
+        var request = tslib.__rest(operation, []);
+        return new utilities.Observable(function (observer) {
+            var handle;
+            var closed = false;
+            Promise.resolve(request)
+                .then(function (req) { return setter(req, operation.getContext()); })
+                .then(operation.setContext)
+                .then(function () {
+                if (closed)
+                    return;
+                handle = forward(operation).subscribe({
+                    next: observer.next.bind(observer),
+                    error: observer.error.bind(observer),
+                    complete: observer.complete.bind(observer),
+                });
+            })
+                .catch(observer.error.bind(observer));
+            return function () {
+                closed = true;
+                if (handle)
+                    handle.unsubscribe();
+            };
+        });
+    });
+}
+
+exports.setContext = setContext;
+//# sourceMappingURL=context.cjs.map

package/link/core/core.cjs.native.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var tslib = require('tslib');
+var utilities = require('../../utilities');
+var utils = require('../utils');
+
+function passthrough(op, forward) {
+    return (forward ? forward(op) : utilities.Observable.of());
+}
+function toLink(handler) {
+    return typeof handler === 'function' ? new ApolloLink(handler) : handler;
+}
+function isTerminating(link) {
+    return link.request.length <= 1;
+}
+var LinkError = (function (_super) {
+    tslib.__extends(LinkError, _super);
+    function LinkError(message, link) {
+        var _this = _super.call(this, message) || this;
+        _this.link = link;
+        return _this;
+    }
+    return LinkError;
+}(Error));
+var ApolloLink = (function () {
+    function ApolloLink(request) {
+        if (request)
+            this.request = request;
+    }
+    ApolloLink.empty = function () {
+        return new ApolloLink(function () { return utilities.Observable.of(); });
+    };
+    ApolloLink.from = function (links) {
+        if (links.length === 0)
+            return ApolloLink.empty();
+        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });
+    };
+    ApolloLink.split = function (test, left, right) {
+        var leftLink = toLink(left);
+        var rightLink = toLink(right || new ApolloLink(passthrough));
+        if (isTerminating(leftLink) && isTerminating(rightLink)) {
+            return new ApolloLink(function (operation) {
+                return test(operation)
+                    ? leftLink.request(operation) || utilities.Observable.of()
+                    : rightLink.request(operation) || utilities.Observable.of();
+            });
+        }
+        else {
+            return new ApolloLink(function (operation, forward) {
+                return test(operation)
+                    ? leftLink.request(operation, forward) || utilities.Observable.of()
+                    : rightLink.request(operation, forward) || utilities.Observable.of();
+            });
+        }
+    };
+    ApolloLink.execute = function (link, operation) {
+        return (link.request(utils.createOperation(operation.context, utils.transformOperation(utils.validateOperation(operation)))) || utilities.Observable.of());
+    };
+    ApolloLink.concat = function (first, second) {
+        var firstLink = toLink(first);
+        if (isTerminating(firstLink)) {
+            __DEV__ && globals.invariant.warn(new LinkError("You are calling concat on a terminating link, which will have no effect", firstLink));
+            return firstLink;
+        }
+        var nextLink = toLink(second);
+        if (isTerminating(nextLink)) {
+            return new ApolloLink(function (operation) {
+                return firstLink.request(operation, function (op) { return nextLink.request(op) || utilities.Observable.of(); }) || utilities.Observable.of();
+            });
+        }
+        else {
+            return new ApolloLink(function (operation, forward) {
+                return (firstLink.request(operation, function (op) {
+                    return nextLink.request(op, forward) || utilities.Observable.of();
+                }) || utilities.Observable.of());
+            });
+        }
+    };
+    ApolloLink.prototype.split = function (test, left, right) {
+        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));
+    };
+    ApolloLink.prototype.concat = function (next) {
+        return ApolloLink.concat(this, next);
+    };
+    ApolloLink.prototype.request = function (operation, forward) {
+        throw __DEV__ ? new globals.InvariantError('request is not implemented') : new globals.InvariantError(19);
+    };
+    ApolloLink.prototype.onError = function (error, observer) {
+        if (observer && observer.error) {
+            observer.error(error);
+            return false;
+        }
+        throw error;
+    };
+    ApolloLink.prototype.setOnError = function (fn) {
+        this.onError = fn;
+        return this;
+    };
+    return ApolloLink;
+}());
+
+var empty = ApolloLink.empty;
+
+var from = ApolloLink.from;
+
+var split = ApolloLink.split;
+
+var concat = ApolloLink.concat;
+
+var execute = ApolloLink.execute;
+
+exports.ApolloLink = ApolloLink;
+exports.concat = concat;
+exports.empty = empty;
+exports.execute = execute;
+exports.from = from;
+exports.split = split;
+//# sourceMappingURL=core.cjs.map

package/link/error/error.cjs.native.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var utilities = require('../../utilities');
+var core = require('../core');
+
+function onError(errorHandler) {
+    return new core.ApolloLink(function (operation, forward) {
+        return new utilities.Observable(function (observer) {
+            var sub;
+            var retriedSub;
+            var retriedResult;
+            try {
+                sub = forward(operation).subscribe({
+                    next: function (result) {
+                        if (result.errors) {
+                            retriedResult = errorHandler({
+                                graphQLErrors: result.errors,
+                                response: result,
+                                operation: operation,
+                                forward: forward,
+                            });
+                            if (retriedResult) {
+                                retriedSub = retriedResult.subscribe({
+                                    next: observer.next.bind(observer),
+                                    error: observer.error.bind(observer),
+                                    complete: observer.complete.bind(observer),
+                                });
+                                return;
+                            }
+                        }
+                        observer.next(result);
+                    },
+                    error: function (networkError) {
+                        retriedResult = errorHandler({
+                            operation: operation,
+                            networkError: networkError,
+                            graphQLErrors: networkError &&
+                                networkError.result &&
+                                networkError.result.errors,
+                            forward: forward,
+                        });
+                        if (retriedResult) {
+                            retriedSub = retriedResult.subscribe({
+                                next: observer.next.bind(observer),
+                                error: observer.error.bind(observer),
+                                complete: observer.complete.bind(observer),
+                            });
+                            return;
+                        }
+                        observer.error(networkError);
+                    },
+                    complete: function () {
+                        if (!retriedResult) {
+                            observer.complete.bind(observer)();
+                        }
+                    },
+                });
+            }
+            catch (e) {
+                errorHandler({ networkError: e, operation: operation, forward: forward });
+                observer.error(e);
+            }
+            return function () {
+                if (sub)
+                    sub.unsubscribe();
+                if (retriedSub)
+                    sub.unsubscribe();
+            };
+        });
+    });
+}
+var ErrorLink = (function (_super) {
+    tslib.__extends(ErrorLink, _super);
+    function ErrorLink(errorHandler) {
+        var _this = _super.call(this) || this;
+        _this.link = onError(errorHandler);
+        return _this;
+    }
+    ErrorLink.prototype.request = function (operation, forward) {
+        return this.link.request(operation, forward);
+    };
+    return ErrorLink;
+}(core.ApolloLink));
+
+exports.ErrorLink = ErrorLink;
+exports.onError = onError;
+//# sourceMappingURL=error.cjs.map