@trpc/client 10.0.0-alpha.2 → 10.0.0-alpha.22

package/dist/index.js

@@ -0,0 +1,1417 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var observable = require('@trpc/server/observable');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
+var _inherits = require('@babel/runtime/helpers/inherits');
+var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
+var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
+var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
+var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
+var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
+var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
+var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
+var _wrapNativeSuper__default = /*#__PURE__*/_interopDefaultLegacy(_wrapNativeSuper);
+var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
+
+function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
+
+function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var TRPCClientError = /*#__PURE__*/function (_Error) {
+  _inherits__default["default"](TRPCClientError, _Error);
+
+  var _super = /*#__PURE__*/_createSuper$1(TRPCClientError);
+
+  function TRPCClientError(message, opts) {
+    var _opts$result, _opts$result2;
+
+    var _this;
+
+    _classCallCheck__default["default"](this, TRPCClientError);
+
+    var cause = opts === null || opts === void 0 ? void 0 : opts.cause; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore https://github.com/tc39/proposal-error-cause
+
+    _this = _super.call(this, message, {
+      cause: cause
+    });
+    _this.cause = void 0;
+    _this.shape = void 0;
+    _this.data = void 0;
+    _this.meta = void 0;
+    _this.meta = opts === null || opts === void 0 ? void 0 : opts.meta;
+    _this.cause = cause;
+    _this.shape = opts === null || opts === void 0 ? void 0 : (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
+    _this.data = opts === null || opts === void 0 ? void 0 : (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
+    _this.name = 'TRPCClientError';
+    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), TRPCClientError.prototype);
+    return _this;
+  }
+
+  _createClass__default["default"](TRPCClientError, null, [{
+    key: "from",
+    value: function from(cause) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (!(cause instanceof Error)) {
+        var _message;
+
+        return new TRPCClientError((_message = cause.error.message) !== null && _message !== void 0 ? _message : '', _objectSpread$3(_objectSpread$3({}, opts), {}, {
+          cause: null,
+          result: cause
+        }));
+      }
+
+      if (cause.name === 'TRPCClientError') {
+        return cause;
+      }
+
+      return new TRPCClientError(cause.message, _objectSpread$3(_objectSpread$3({}, opts), {}, {
+        cause: cause,
+        result: null
+      }));
+    }
+  }]);
+
+  return TRPCClientError;
+}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
+
+function getWindow() {
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+
+  return global;
+}
+function getAbortController(ac) {
+  var win = getWindow();
+  return ac || win.AbortController || null;
+}
+
+function getFetch(f) {
+  if (f) {
+    return f;
+  }
+
+  var win = getWindow();
+
+  if (win.fetch) {
+    return typeof win.fetch.bind === 'function' ? win.fetch.bind(win) : win.fetch;
+  }
+
+  throw new Error('No fetch implementation found');
+}
+
+function dedupeLink() {
+  // initialized config
+  return function () {
+    // initialized in app
+    var pending = {};
+    return function (_ref) {
+      var op = _ref.op,
+          next = _ref.next;
+
+      // initialized for request
+      if (op.type !== 'query') {
+        // pass through
+        return next(op);
+      }
+
+      var key = JSON.stringify([op.path, op.input]);
+
+      if (pending[key]) {
+        // console.log('hooking into pending', { op });
+        return observable.observable(function (observer) {
+          return pending[key].subscribe(observer);
+        });
+      }
+
+      var shared$ = observable.observable(function (observer) {
+        function reset() {
+          delete pending[key];
+        }
+
+        var subscription = next(op).subscribe({
+          next: function next(v) {
+            observer.next(v);
+          },
+          error: function error(e) {
+            reset();
+            observer.error(e);
+          },
+          complete: function complete() {
+            reset();
+            observer.complete();
+          }
+        });
+        return function () {
+          reset();
+          subscription.unsubscribe();
+        };
+      }).pipe(observable.share());
+      pending[key] = shared$;
+      return shared$;
+    };
+  };
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ * A function that should never be called unless we messed something up.
+ */
+var throwFatalError = function throwFatalError() {
+  throw new Error('Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new');
+};
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * Less configuration, no caching, and allows you to cancel requests
+ * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
+ */
+
+
+function dataLoader(batchLoader) {
+  var pendingItems = null;
+  var dispatchTimer = null;
+
+  var destroyTimerAndPendingItems = function destroyTimerAndPendingItems() {
+    clearTimeout(dispatchTimer);
+    dispatchTimer = null;
+    pendingItems = null;
+  };
+  /**
+   * Iterate through the items and split them into groups based on the `batchLoader`'s validate function
+   */
+
+
+  function groupItems(items) {
+    var groupedItems = [[]];
+    var index = 0;
+
+    while (true) {
+      var item = items[index];
+
+      if (!item) {
+        // we're done
+        break;
+      }
+
+      var lastGroup = groupedItems[groupedItems.length - 1];
+
+      if (item.aborted) {
+        // Item was aborted before it was dispatched
+        item.reject(new Error('Aborted'));
+        index++;
+        continue;
+      }
+
+      var isValid = batchLoader.validate(lastGroup.concat(item).map(function (it) {
+        return it.key;
+      }));
+
+      if (isValid) {
+        lastGroup.push(item);
+        index++;
+        continue;
+      }
+
+      if (lastGroup.length === 0) {
+        item.reject(new Error('Input is too big for a single dispatch'));
+        index++;
+        continue;
+      } // Create new group, next iteration will try to add the item to that
+
+
+      groupedItems.push([]);
+    }
+
+    return groupedItems;
+  }
+
+  function dispatch() {
+    var groupedItems = groupItems(pendingItems);
+    destroyTimerAndPendingItems(); // Create batches for each group of items
+
+    var _iterator = _createForOfIteratorHelper(groupedItems),
+        _step;
+
+    try {
+      var _loop = function _loop() {
+        var items = _step.value;
+
+        if (!items.length) {
+          return "continue";
+        }
+
+        var batch = {
+          items: items,
+          cancel: throwFatalError
+        };
+
+        var _iterator2 = _createForOfIteratorHelper(items),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var item = _step2.value;
+            item.batch = batch;
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        var _batchLoader$fetch = batchLoader.fetch(batch.items.map(function (_item) {
+          return _item.key;
+        })),
+            promise = _batchLoader$fetch.promise,
+            cancel = _batchLoader$fetch.cancel;
+
+        batch.cancel = cancel;
+        promise.then(function (result) {
+          for (var i = 0; i < result.length; i++) {
+            var _value = result[i];
+            var item = batch.items[i];
+            item.resolve(_value);
+            item.batch = null;
+          }
+        }).catch(function (cause) {
+          var _iterator3 = _createForOfIteratorHelper(batch.items),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var item = _step3.value;
+              item.reject(cause);
+              item.batch = null;
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        });
+      };
+
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _ret = _loop();
+
+        if (_ret === "continue") continue;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  function load(key) {
+    var item = {
+      aborted: false,
+      key: key,
+      batch: null,
+      resolve: throwFatalError,
+      reject: throwFatalError
+    };
+    var promise = new Promise(function (resolve, reject) {
+      item.reject = reject;
+      item.resolve = resolve;
+
+      if (!pendingItems) {
+        pendingItems = [];
+      }
+
+      pendingItems.push(item);
+    });
+
+    if (!dispatchTimer) {
+      dispatchTimer = setTimeout(dispatch);
+    }
+
+    var cancel = function cancel() {
+      var _item$batch;
+
+      item.aborted = true;
+
+      if ((_item$batch = item.batch) !== null && _item$batch !== void 0 && _item$batch.items.every(function (item) {
+        return item.aborted;
+      })) {
+        // All items in the batch have been cancelled
+        item.batch.cancel();
+        item.batch = null;
+      }
+    };
+
+    return {
+      promise: promise,
+      cancel: cancel
+    };
+  }
+
+  return {
+    load: load
+  };
+}
+
+function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+// https://github.com/trpc/trpc/pull/669
+function arrayToDict(array) {
+  var dict = {};
+
+  for (var index = 0; index < array.length; index++) {
+    var element = array[index];
+    dict[index] = element;
+  }
+
+  return dict;
+}
+
+var METHOD = {
+  query: 'GET',
+  mutation: 'POST',
+  subscription: 'PATCH'
+};
+
+function getInput(opts) {
+  return 'input' in opts ? opts.runtime.transformer.serialize(opts.input) : arrayToDict(opts.inputs.map(function (_input) {
+    return opts.runtime.transformer.serialize(_input);
+  }));
+}
+
+function getUrl(opts) {
+  var url = opts.url + '/' + opts.path;
+  var queryParts = [];
+
+  if ('inputs' in opts) {
+    queryParts.push('batch=1');
+  }
+
+  if (opts.type === 'query') {
+    var input = getInput(opts);
+
+    if (input !== undefined) {
+      queryParts.push("input=".concat(encodeURIComponent(JSON.stringify(input))));
+    }
+  }
+
+  if (queryParts.length) {
+    url += '?' + queryParts.join('&');
+  }
+
+  return url;
+}
+function getBody(opts) {
+  if (opts.type === 'query') {
+    return undefined;
+  }
+
+  var input = getInput(opts);
+  return input !== undefined ? JSON.stringify(input) : undefined;
+}
+function httpRequest(opts) {
+  var type = opts.type,
+      runtime = opts.runtime;
+  var ac = runtime.AbortController ? new runtime.AbortController() : null;
+  var promise = new Promise(function (resolve, reject) {
+    var url = getUrl(opts);
+    var body = getBody(opts);
+    var meta = {};
+    Promise.resolve(runtime.headers()).then(function (headers) {
+      return runtime.fetch(url, {
+        method: METHOD[type],
+        signal: ac === null || ac === void 0 ? void 0 : ac.signal,
+        body: body,
+        headers: _objectSpread$2({
+          'content-type': 'application/json'
+        }, headers)
+      });
+    }).then(function (_res) {
+      meta.response = _res;
+      return _res.json();
+    }).then(function (json) {
+      resolve({
+        json: json,
+        meta: meta
+      });
+    }).catch(reject);
+  });
+
+  var cancel = function cancel() {
+    ac === null || ac === void 0 ? void 0 : ac.abort();
+  };
+
+  return {
+    promise: promise,
+    cancel: cancel
+  };
+}
+
+function httpBatchLink(opts) {
+  // initialized config
+  return function (runtime) {
+    var maxURLLength = opts.maxURLLength || Infinity;
+
+    var batchLoader = function batchLoader(type) {
+      var validate = function validate(batchOps) {
+        if (maxURLLength === Infinity) {
+          // escape hatch for quick calcs
+          return true;
+        }
+
+        var path = batchOps.map(function (op) {
+          return op.path;
+        }).join(',');
+        var inputs = batchOps.map(function (op) {
+          return op.input;
+        });
+        var url = getUrl({
+          url: opts.url,
+          runtime: runtime,
+          type: type,
+          path: path,
+          inputs: inputs
+        });
+        return url.length <= maxURLLength;
+      };
+
+      var fetch = function fetch(batchOps) {
+        var path = batchOps.map(function (op) {
+          return op.path;
+        }).join(',');
+        var inputs = batchOps.map(function (op) {
+          return op.input;
+        });
+
+        var _httpRequest = httpRequest({
+          url: opts.url,
+          runtime: runtime,
+          type: type,
+          path: path,
+          inputs: inputs
+        }),
+            promise = _httpRequest.promise,
+            cancel = _httpRequest.cancel;
+
+        return {
+          promise: promise.then(function (res) {
+            var resJSON = Array.isArray(res.json) ? res.json : batchOps.map(function () {
+              return res.json;
+            });
+            var result = resJSON.map(function (item) {
+              return {
+                meta: res.meta,
+                json: item
+              };
+            });
+            return result;
+          }),
+          cancel: cancel
+        };
+      };
+
+      return {
+        validate: validate,
+        fetch: fetch
+      };
+    };
+
+    var query = dataLoader(batchLoader('query'));
+    var mutation = dataLoader(batchLoader('mutation'));
+    var subscription = dataLoader(batchLoader('subscription'));
+    var loaders = {
+      query: query,
+      subscription: subscription,
+      mutation: mutation
+    };
+    return function (_ref) {
+      var op = _ref.op;
+      return observable.observable(function (observer) {
+        var loader = loaders[op.type];
+
+        var _loader$load = loader.load(op),
+            promise = _loader$load.promise,
+            cancel = _loader$load.cancel;
+
+        promise.then(function (res) {
+          observer.next({
+            context: res.meta,
+            data: res.json
+          });
+          observer.complete();
+        }).catch(function (err) {
+          return observer.error(err);
+        });
+        return function () {
+          cancel();
+        };
+      });
+    };
+  };
+}
+
+function httpLink(opts) {
+  var url = opts.url;
+  return function (runtime) {
+    return function (_ref) {
+      var op = _ref.op;
+      return observable.observable(function (observer) {
+        var path = op.path,
+            input = op.input,
+            type = op.type;
+
+        var _httpRequest = httpRequest({
+          url: url,
+          runtime: runtime,
+          type: type,
+          path: path,
+          input: input
+        }),
+            promise = _httpRequest.promise,
+            cancel = _httpRequest.cancel;
+
+        promise.then(function (res) {
+          observer.next({
+            context: res.meta,
+            data: res.json
+          });
+          observer.complete();
+        }).catch(observer.error);
+        return function () {
+          cancel();
+        };
+      });
+    };
+  };
+}
+
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var palette = {
+  query: ['72e3ff', '3fb0d8'],
+  mutation: ['c5a3fc', '904dfc'],
+  subscription: ['ff49e1', 'd83fbe']
+};
+
+// maybe this should be moved to it's own package
+var defaultLogger = function defaultLogger() {
+  var c = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : console;
+  return function (props) {
+    var direction = props.direction,
+        input = props.input,
+        type = props.type,
+        path = props.path,
+        context = props.context,
+        id = props.id;
+
+    var _palette$type = _slicedToArray__default["default"](palette[type], 2),
+        light = _palette$type[0],
+        dark = _palette$type[1];
+
+    var css = "\n    background-color: #".concat(direction === 'up' ? light : dark, "; \n    color: ").concat(direction === 'up' ? 'black' : 'white', ";\n    padding: 2px;\n  ");
+    var parts = ['%c', direction === 'up' ? '>>' : '<<', type, "#".concat(id), "%c".concat(path, "%c"), '%O'];
+    var args = [css, "".concat(css, "; font-weight: bold;"), "".concat(css, "; font-weight: normal;")];
+
+    if (props.direction === 'up') {
+      args.push({
+        input: input,
+        context: context
+      });
+    } else {
+      args.push({
+        input: input,
+        result: props.result,
+        elapsedMs: props.elapsedMs,
+        context: context
+      });
+    }
+
+    var fn = props.direction === 'down' && props.result && (props.result instanceof Error || 'error' in props.result.data) ? 'error' : 'log';
+    c[fn].apply(null, [parts.join(' ')].concat(args));
+  };
+};
+
+function loggerLink() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _opts$enabled = opts.enabled,
+      enabled = _opts$enabled === void 0 ? function () {
+    return true;
+  } : _opts$enabled;
+  var _opts$logger = opts.logger,
+      logger = _opts$logger === void 0 ? defaultLogger(opts.console) : _opts$logger;
+  return function () {
+    return function (_ref) {
+      var op = _ref.op,
+          next = _ref.next;
+      return observable.observable(function (observer) {
+        // ->
+        enabled(_objectSpread$1(_objectSpread$1({}, op), {}, {
+          direction: 'up'
+        })) && logger(_objectSpread$1(_objectSpread$1({}, op), {}, {
+          direction: 'up'
+        }));
+        var requestStartTime = Date.now();
+
+        function logResult(result) {
+          var elapsedMs = Date.now() - requestStartTime;
+          enabled(_objectSpread$1(_objectSpread$1({}, op), {}, {
+            direction: 'down',
+            result: result
+          })) && logger(_objectSpread$1(_objectSpread$1({}, op), {}, {
+            direction: 'down',
+            elapsedMs: elapsedMs,
+            result: result
+          }));
+        }
+
+        return next(op).pipe(observable.tap({
+          next: function next(result) {
+            logResult(result);
+          },
+          error: function error(result) {
+            logResult(result);
+          }
+        })).subscribe(observer);
+      });
+    };
+  };
+}
+
+function retryLink(opts) {
+  // initialized config
+  return function () {
+    // initialized in app
+    return function (_ref) {
+      var op = _ref.op,
+          next = _ref.next;
+      // initialized for request
+      return observable.observable(function (observer) {
+        var next$ = null;
+        var attempts = 0;
+        var isDone = false;
+
+        function attempt() {
+          var _next$;
+
+          attempts++;
+          (_next$ = next$) === null || _next$ === void 0 ? void 0 : _next$.unsubscribe();
+          next$ = next(op).subscribe({
+            error: function error(_error) {
+              if (attempts >= opts.attempts) {
+                observer.error(_error);
+                return;
+              }
+
+              attempt();
+            },
+            next: function next(result) {
+              if ('result' in result.data) {
+                isDone = true;
+                observer.next(result);
+                return;
+              }
+
+              if (attempts >= opts.attempts) {
+                isDone = true;
+                observer.next(result);
+                return;
+              }
+
+              attempt();
+            },
+            complete: function complete() {
+              if (isDone) {
+                observer.complete();
+              }
+            }
+          });
+        }
+
+        attempt();
+        return function () {
+          var _next$2;
+
+          isDone = true;
+          (_next$2 = next$) === null || _next$2 === void 0 ? void 0 : _next$2.unsubscribe();
+        };
+      });
+    };
+  };
+}
+
+/** @internal */
+function createChain(opts) {
+  return observable.observable(function (observer) {
+    function execute() {
+      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var op = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : opts.op;
+      var next = opts.links[index];
+      var subscription = next({
+        op: op,
+        next: function next(nextOp) {
+          var nextObserver = execute(index + 1, nextOp);
+          return nextObserver;
+        }
+      });
+      return subscription;
+    }
+
+    var obs$ = execute();
+    return obs$.subscribe(observer);
+  });
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+function splitLink(opts) {
+  return function (runtime) {
+    var yes = asArray(opts.true).map(function (link) {
+      return link(runtime);
+    });
+    var no = asArray(opts.false).map(function (link) {
+      return link(runtime);
+    });
+    return function (props) {
+      return observable.observable(function (observer) {
+        var links = opts.condition(props.op) ? yes : no;
+        return createChain({
+          op: props.op,
+          links: links
+        }).subscribe(observer);
+      });
+    };
+  };
+}
+
+/* istanbul ignore next */
+var retryDelay = function retryDelay(attemptIndex) {
+  return attemptIndex === 0 ? 0 : Math.min(1000 * Math.pow(2, attemptIndex), 30000);
+};
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function createWSClient(opts) {
+  var url = opts.url,
+      _opts$WebSocket = opts.WebSocket,
+      WebSocketImpl = _opts$WebSocket === void 0 ? WebSocket : _opts$WebSocket,
+      _opts$retryDelayMs = opts.retryDelayMs,
+      retryDelayFn = _opts$retryDelayMs === void 0 ? retryDelay : _opts$retryDelayMs;
+  /* istanbul ignore next */
+
+  if (!WebSocketImpl) {
+    throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+  }
+  /**
+   * outgoing messages buffer whilst not open
+   */
+
+
+  var outgoing = [];
+  /**
+   * pending outgoing requests that are awaiting callback
+   */
+
+  var pendingRequests = Object.create(null);
+  var connectAttempt = 0;
+  var dispatchTimer = null;
+  var connectTimer = null;
+  var activeConnection = createWS();
+  var state = 'connecting';
+  /**
+   * tries to send the list of messages
+   */
+
+  function dispatch() {
+    if (state !== 'open' || dispatchTimer) {
+      return;
+    }
+
+    dispatchTimer = setTimeout(function () {
+      dispatchTimer = null;
+
+      if (outgoing.length === 1) {
+        // single send
+        activeConnection.send(JSON.stringify(outgoing.pop()));
+      } else {
+        // batch send
+        activeConnection.send(JSON.stringify(outgoing));
+      } // clear
+
+
+      outgoing = [];
+    });
+  }
+
+  function tryReconnect() {
+    if (connectTimer || state === 'closed') {
+      return;
+    }
+
+    var timeout = retryDelayFn(connectAttempt++);
+    reconnectInMs(timeout);
+  }
+
+  function reconnect() {
+    state = 'connecting';
+    var oldConnection = activeConnection;
+    activeConnection = createWS();
+    closeIfNoPending(oldConnection);
+  }
+
+  function reconnectInMs(ms) {
+    if (connectTimer) {
+      return;
+    }
+
+    state = 'connecting';
+    connectTimer = setTimeout(reconnect, ms);
+  }
+
+  function closeIfNoPending(conn) {
+    // disconnect as soon as there are are no pending result
+    var hasPendingRequests = Object.values(pendingRequests).some(function (p) {
+      return p.ws === conn;
+    });
+
+    if (!hasPendingRequests) {
+      conn.close();
+    }
+  }
+
+  function resumeSubscriptionOnReconnect(req) {
+    if (outgoing.some(function (r) {
+      return r.id === req.op.id;
+    })) {
+      return;
+    }
+
+    request(req.op, req.callbacks);
+  }
+
+  function createWS() {
+    var conn = new WebSocket(url);
+    clearTimeout(connectTimer);
+    connectTimer = null;
+    conn.addEventListener('open', function () {
+      /* istanbul ignore next */
+      if (conn !== activeConnection) {
+        return;
+      }
+
+      connectAttempt = 0;
+      state = 'open';
+      dispatch();
+    });
+    conn.addEventListener('error', function () {
+      if (conn === activeConnection) {
+        tryReconnect();
+      }
+    });
+
+    var handleIncomingRequest = function handleIncomingRequest(req) {
+      if (req.method === 'reconnect' && conn === activeConnection) {
+        reconnect(); // notify subscribers
+
+        for (var _i = 0, _Object$values = Object.values(pendingRequests); _i < _Object$values.length; _i++) {
+          var pendingReq = _Object$values[_i];
+
+          if (pendingReq.type === 'subscription') {
+            resumeSubscriptionOnReconnect(pendingReq);
+          }
+        }
+      }
+    };
+
+    var handleIncomingResponse = function handleIncomingResponse(data) {
+      var _req$callbacks$next, _req$callbacks;
+
+      var req = data.id !== null && pendingRequests[data.id];
+
+      if (!req) {
+        // do something?
+        return;
+      }
+
+      (_req$callbacks$next = (_req$callbacks = req.callbacks).next) === null || _req$callbacks$next === void 0 ? void 0 : _req$callbacks$next.call(_req$callbacks, {
+        data: data
+      });
+
+      if (req.ws !== activeConnection && conn === activeConnection) {
+        var oldWs = req.ws; // gracefully replace old connection with this
+
+        req.ws = activeConnection;
+        closeIfNoPending(oldWs);
+      }
+
+      if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
+        req.callbacks.complete();
+      }
+    };
+
+    conn.addEventListener('message', function (_ref) {
+      var data = _ref.data;
+      var msg = JSON.parse(data);
+
+      if ('method' in msg) {
+        handleIncomingRequest(msg);
+      } else {
+        handleIncomingResponse(msg);
+      }
+
+      if (conn !== activeConnection || state === 'closed') {
+        // when receiving a message, we close old connection that has no pending requests
+        closeIfNoPending(conn);
+      }
+    });
+    conn.addEventListener('close', function () {
+      if (activeConnection === conn) {
+        // connection might have been replaced already
+        tryReconnect();
+      }
+
+      for (var key in pendingRequests) {
+        var _req$callbacks$error, _req$callbacks2;
+
+        var req = pendingRequests[key];
+
+        if (req.ws !== conn) {
+          continue;
+        }
+
+        (_req$callbacks$error = (_req$callbacks2 = req.callbacks).error) === null || _req$callbacks$error === void 0 ? void 0 : _req$callbacks$error.call(_req$callbacks2, TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+
+        if (req.type !== 'subscription') {
+          var _req$callbacks$comple, _req$callbacks3;
+
+          delete pendingRequests[key];
+          (_req$callbacks$comple = (_req$callbacks3 = req.callbacks).complete) === null || _req$callbacks$comple === void 0 ? void 0 : _req$callbacks$comple.call(_req$callbacks3);
+        } else if (state !== 'closed') {
+          // request restart of sub with next connection
+          resumeSubscriptionOnReconnect(req);
+        }
+      }
+    });
+    return conn;
+  }
+
+  function request(op, callbacks) {
+    var type = op.type,
+        input = op.input,
+        path = op.path,
+        id = op.id;
+    var envelope = {
+      id: id,
+      method: type,
+      params: {
+        input: input,
+        path: path
+      }
+    };
+    pendingRequests[id] = {
+      ws: activeConnection,
+      type: type,
+      callbacks: callbacks,
+      op: op
+    }; // enqueue message
+
+    outgoing.push(envelope);
+    dispatch();
+    return function () {
+      var _pendingRequests$id, _callbacks$complete;
+
+      var callbacks = (_pendingRequests$id = pendingRequests[id]) === null || _pendingRequests$id === void 0 ? void 0 : _pendingRequests$id.callbacks;
+      delete pendingRequests[id];
+      outgoing = outgoing.filter(function (msg) {
+        return msg.id !== id;
+      });
+      callbacks === null || callbacks === void 0 ? void 0 : (_callbacks$complete = callbacks.complete) === null || _callbacks$complete === void 0 ? void 0 : _callbacks$complete.call(callbacks);
+
+      if (op.type === 'subscription') {
+        outgoing.push({
+          id: id,
+          method: 'subscription.stop'
+        });
+        dispatch();
+      }
+    };
+  }
+
+  return {
+    close: function close() {
+      state = 'closed';
+      closeIfNoPending(activeConnection);
+    },
+    request: request,
+    getConnection: function getConnection() {
+      return activeConnection;
+    }
+  };
+}
+
+var TRPCWebSocketClosedError = /*#__PURE__*/function (_Error) {
+  _inherits__default["default"](TRPCWebSocketClosedError, _Error);
+
+  var _super = /*#__PURE__*/_createSuper(TRPCWebSocketClosedError);
+
+  function TRPCWebSocketClosedError(message) {
+    var _this;
+
+    _classCallCheck__default["default"](this, TRPCWebSocketClosedError);
+
+    _this = _super.call(this, message);
+    _this.name = 'TRPCWebSocketClosedError';
+    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), TRPCWebSocketClosedError.prototype);
+    return _this;
+  }
+
+  return _createClass__default["default"](TRPCWebSocketClosedError);
+}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
+
+var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
+  _inherits__default["default"](TRPCSubscriptionEndedError, _Error2);
+
+  var _super2 = /*#__PURE__*/_createSuper(TRPCSubscriptionEndedError);
+
+  function TRPCSubscriptionEndedError(message) {
+    var _this2;
+
+    _classCallCheck__default["default"](this, TRPCSubscriptionEndedError);
+
+    _this2 = _super2.call(this, message);
+    _this2.name = 'TRPCSubscriptionEndedError';
+    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this2), TRPCSubscriptionEndedError.prototype);
+    return _this2;
+  }
+
+  return _createClass__default["default"](TRPCSubscriptionEndedError);
+}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
+
+function wsLink(opts) {
+  return function (runtime) {
+    var client = opts.client;
+    return function (_ref2) {
+      var op = _ref2.op;
+      return observable.observable(function (observer) {
+        var type = op.type,
+            path = op.path,
+            id = op.id,
+            context = op.context;
+        var input = runtime.transformer.serialize(op.input);
+        var isDone = false;
+        var unsub = client.request({
+          type: type,
+          path: path,
+          input: input,
+          id: id,
+          context: context
+        }, {
+          error: function error(err) {
+            isDone = true;
+            observer.error(err);
+            unsub();
+          },
+          complete: function complete() {
+            if (!isDone) {
+              isDone = true;
+              observer.error(TRPCClientError.from(new TRPCSubscriptionEndedError('Operation ended prematurely')));
+            } else {
+              observer.complete();
+            }
+          },
+          next: function next(result) {
+            observer.next(result);
+
+            if (op.type !== 'subscription') {
+              // if it isn't a subscription we don't care about next response
+              isDone = true;
+              unsub();
+              observer.complete();
+            }
+          }
+        });
+        return function () {
+          isDone = true;
+          unsub();
+        };
+      });
+    };
+  };
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/** @internal */
+function transformOperationResult(result, runtime) {
+  var context = result.context;
+
+  if ('error' in result.data) {
+    var error = TRPCClientError.from(_objectSpread(_objectSpread({}, result.data), {}, {
+      error: runtime.transformer.deserialize(result.data.error)
+    }));
+    return {
+      ok: false,
+      error: error,
+      context: context
+    };
+  }
+
+  var data = runtime.transformer.deserialize(result.data.result.data);
+  return {
+    ok: true,
+    data: data,
+    context: context
+  };
+}
+/** @internal */
+
+function transformSubscriptionOperationResult(result, runtime) {
+  var context = result.context;
+
+  if ('error' in result.data) {
+    var error = TRPCClientError.from(_objectSpread(_objectSpread({}, result.data), {}, {
+      error: runtime.transformer.deserialize(result.data.error)
+    }), {
+      meta: context
+    });
+    return {
+      ok: false,
+      error: error,
+      context: context
+    };
+  }
+
+  var data = _objectSpread(_objectSpread({}, result.data.result), result.data.result.type === 'data' && {
+    data: runtime.transformer.deserialize(result.data.result.data)
+  });
+
+  return {
+    ok: true,
+    data: data,
+    context: context
+  };
+}
+
+var idCounter = 0;
+
+function getRequestId() {
+  return ++idCounter;
+}
+
+var TRPCClient = /*#__PURE__*/function () {
+  function TRPCClient(opts) {
+    var _this = this;
+
+    _classCallCheck__default["default"](this, TRPCClient);
+
+    this.links = void 0;
+    this.runtime = void 0;
+
+    var _fetch = getFetch(opts === null || opts === void 0 ? void 0 : opts.fetch);
+
+    var AC = getAbortController(opts === null || opts === void 0 ? void 0 : opts.AbortController);
+
+    function getHeadersFn() {
+      if (opts.headers) {
+        var headers = opts.headers;
+        return typeof headers === 'function' ? headers : function () {
+          return headers;
+        };
+      }
+
+      return function () {
+        return {};
+      };
+    }
+
+    var transformer = opts.transformer ? 'input' in opts.transformer ? {
+      serialize: opts.transformer.input.serialize,
+      deserialize: opts.transformer.output.deserialize
+    } : opts.transformer : {
+      serialize: function serialize(data) {
+        return data;
+      },
+      deserialize: function deserialize(data) {
+        return data;
+      }
+    };
+    this.runtime = {
+      AbortController: AC,
+      fetch: _fetch,
+      headers: getHeadersFn(),
+      transformer: transformer
+    };
+
+    if ('links' in opts) {
+      this.links = opts.links.map(function (link) {
+        return link(_this.runtime);
+      });
+    } else {
+      this.links = [httpBatchLink({
+        url: opts.url
+      })(this.runtime)];
+    }
+  }
+
+  _createClass__default["default"](TRPCClient, [{
+    key: "$request",
+    value: function $request(_ref) {
+      var type = _ref.type,
+          input = _ref.input,
+          path = _ref.path,
+          _ref$context = _ref.context,
+          context = _ref$context === void 0 ? {} : _ref$context;
+      var chain$ = createChain({
+        links: this.links,
+        op: {
+          id: getRequestId(),
+          type: type,
+          path: path,
+          input: input,
+          context: context
+        }
+      });
+      return chain$.pipe(observable.share());
+    }
+  }, {
+    key: "requestAsPromise",
+    value: function requestAsPromise(opts) {
+      var _this2 = this;
+
+      var req$ = this.$request(opts);
+
+      var _observableToPromise = observable.observableToPromise(req$),
+          promise = _observableToPromise.promise,
+          abort = _observableToPromise.abort;
+
+      var cancellablePromise = new Promise(function (resolve, reject) {
+        promise.then(function (result) {
+          var transformed = transformOperationResult(result, _this2.runtime);
+
+          if (transformed.ok) {
+            resolve(transformed.data);
+            return;
+          }
+
+          reject(transformed.error);
+        }).catch(function (err) {
+          reject(TRPCClientError.from(err));
+        });
+      });
+      cancellablePromise.cancel = abort;
+      return cancellablePromise;
+    }
+  }, {
+    key: "query",
+    value: function query(path) {
+      var _ref2;
+
+      var context = (_ref2 = arguments.length <= 2 ? undefined : arguments[2]) === null || _ref2 === void 0 ? void 0 : _ref2.context;
+      return this.requestAsPromise({
+        type: 'query',
+        path: path,
+        input: arguments.length <= 1 ? undefined : arguments[1],
+        context: context
+      });
+    }
+  }, {
+    key: "mutation",
+    value: function mutation(path) {
+      var _ref3;
+
+      var context = (_ref3 = arguments.length <= 2 ? undefined : arguments[2]) === null || _ref3 === void 0 ? void 0 : _ref3.context;
+      return this.requestAsPromise({
+        type: 'mutation',
+        path: path,
+        input: arguments.length <= 1 ? undefined : arguments[1],
+        context: context
+      });
+    }
+  }, {
+    key: "subscription",
+    value: function subscription(path, input, opts) {
+      var observable$ = this.$request({
+        type: 'subscription',
+        path: path,
+        input: input,
+        context: opts.context
+      });
+      var runtime = this.runtime;
+      return observable$.subscribe({
+        next: function next(result) {
+          var _opts$error;
+
+          var transformed = transformSubscriptionOperationResult(result, runtime);
+
+          if (transformed.ok) {
+            var _opts$next;
+
+            (_opts$next = opts.next) === null || _opts$next === void 0 ? void 0 : _opts$next.call(opts, transformed.data);
+            return;
+          }
+
+          (_opts$error = opts.error) === null || _opts$error === void 0 ? void 0 : _opts$error.call(opts, transformed.error);
+        },
+        error: function error(err) {
+          var _opts$error2;
+
+          (_opts$error2 = opts.error) === null || _opts$error2 === void 0 ? void 0 : _opts$error2.call(opts, err);
+        },
+        complete: function complete() {
+          var _opts$complete;
+
+          (_opts$complete = opts.complete) === null || _opts$complete === void 0 ? void 0 : _opts$complete.call(opts);
+        }
+      });
+    }
+  }]);
+
+  return TRPCClient;
+}();
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function createTRPCClient(opts) {
+  return new TRPCClient(opts);
+}
+
+exports.TRPCClientError = TRPCClientError;
+exports.createTRPCClient = createTRPCClient;
+exports.createWSClient = createWSClient;
+exports.dedupeLink = dedupeLink;
+exports.getFetch = getFetch;
+exports.httpBatchLink = httpBatchLink;
+exports.httpLink = httpLink;
+exports.loggerLink = loggerLink;
+exports.retryLink = retryLink;
+exports.splitLink = splitLink;
+exports.wsLink = wsLink;