@trpc/client 10.0.0-alpha.15 → 10.0.0-alpha.18

package/{dist/links/wsLink.js → links/wsLink/dist/trpc-client-links-wsLink.cjs.dev.js}

@@ -2,35 +2,20 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _createClass = require('@babel/runtime/helpers/createClass');
 var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
 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 _createSuper = require('@babel/runtime/helpers/createSuper');
 var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
-var observable = require('../observable-85669100.js');
-var TRPCClientError = require('../TRPCClientError-ec6bd2ca.js');
-require('@babel/runtime/helpers/defineProperty');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-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 TRPCClientError = require('../../../dist/TRPCClientError-bfee2bf5.cjs.dev.js');
 
 /* 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,
@@ -163,19 +148,24 @@ function createWSClient(opts) {
       }
     };
 
-    var handleIncomingResponse = function handleIncomingResponse(data) {
-      var _req$callbacks$next, _req$callbacks;
+    var handleIncomingResponse = function handleIncomingResponse(res) {
+      var _req$callbacks$onNext, _req$callbacks2;
 
-      var req = data.id !== null && pendingRequests[data.id];
+      var req = res.id !== null && pendingRequests[res.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 ('error' in res) {
+        var _req$callbacks$onErro, _req$callbacks;
+
+        (_req$callbacks$onErro = (_req$callbacks = req.callbacks).onError) === null || _req$callbacks$onErro === void 0 ? void 0 : _req$callbacks$onErro.call(_req$callbacks, res);
+        return;
+      }
+
+      (_req$callbacks$onNext = (_req$callbacks2 = req.callbacks).onNext) === null || _req$callbacks$onNext === void 0 ? void 0 : _req$callbacks$onNext.call(_req$callbacks2, res.result);
 
       if (req.ws !== activeConnection && conn === activeConnection) {
         var oldWs = req.ws; // gracefully replace old connection with this
@@ -184,8 +174,10 @@ function createWSClient(opts) {
         closeIfNoPending(oldWs);
       }
 
-      if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
-        req.callbacks.complete();
+      if (res.result.type === 'stopped' && conn === activeConnection) {
+        var _req$callbacks$onDone, _req$callbacks3;
+
+        (_req$callbacks$onDone = (_req$callbacks3 = req.callbacks).onDone) === null || _req$callbacks$onDone === void 0 ? void 0 : _req$callbacks$onDone.call(_req$callbacks3);
       }
     };
 
@@ -211,7 +203,7 @@ function createWSClient(opts) {
       }
 
       for (var key in pendingRequests) {
-        var _req$callbacks$error, _req$callbacks2;
+        var _req$callbacks$onErro2, _req$callbacks4;
 
         var req = pendingRequests[key];
 
@@ -219,13 +211,13 @@ function createWSClient(opts) {
           continue;
         }
 
-        (_req$callbacks$error = (_req$callbacks2 = req.callbacks).error) === null || _req$callbacks$error === void 0 ? void 0 : _req$callbacks$error.call(_req$callbacks2, TRPCClientError.TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+        (_req$callbacks$onErro2 = (_req$callbacks4 = req.callbacks).onError) === null || _req$callbacks$onErro2 === void 0 ? void 0 : _req$callbacks$onErro2.call(_req$callbacks4, TRPCClientError.TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
 
         if (req.type !== 'subscription') {
-          var _req$callbacks$comple, _req$callbacks3;
+          var _req$callbacks$onDone2, _req$callbacks5;
 
           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);
+          (_req$callbacks$onDone2 = (_req$callbacks5 = req.callbacks).onDone) === null || _req$callbacks$onDone2 === void 0 ? void 0 : _req$callbacks$onDone2.call(_req$callbacks5);
         } else if (state !== 'closed') {
           // request restart of sub with next connection
           resumeSubscriptionOnReconnect(req);
@@ -259,14 +251,14 @@ function createWSClient(opts) {
     outgoing.push(envelope);
     dispatch();
     return function () {
-      var _pendingRequests$id, _callbacks$complete;
+      var _pendingRequests$id, _callbacks$onDone;
 
       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);
+      callbacks === null || callbacks === void 0 ? void 0 : (_callbacks$onDone = callbacks.onDone) === null || _callbacks$onDone === void 0 ? void 0 : _callbacks$onDone.call(callbacks);
 
       if (op.type === 'subscription') {
         outgoing.push({
@@ -292,90 +284,108 @@ function createWSClient(opts) {
 }
 
 var TRPCWebSocketClosedError = /*#__PURE__*/function (_Error) {
-  _inherits__default["default"](TRPCWebSocketClosedError, _Error);
+  _inherits(TRPCWebSocketClosedError, _Error);
 
   var _super = /*#__PURE__*/_createSuper(TRPCWebSocketClosedError);
 
   function TRPCWebSocketClosedError(message) {
     var _this;
 
-    _classCallCheck__default["default"](this, TRPCWebSocketClosedError);
+    _classCallCheck(this, TRPCWebSocketClosedError);
 
     _this = _super.call(this, message);
     _this.name = 'TRPCWebSocketClosedError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), TRPCWebSocketClosedError.prototype);
+    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCWebSocketClosedError.prototype);
     return _this;
   }
 
-  return _createClass__default["default"](TRPCWebSocketClosedError);
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
+  return _createClass(TRPCWebSocketClosedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
 
 var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
-  _inherits__default["default"](TRPCSubscriptionEndedError, _Error2);
+  _inherits(TRPCSubscriptionEndedError, _Error2);
 
   var _super2 = /*#__PURE__*/_createSuper(TRPCSubscriptionEndedError);
 
   function TRPCSubscriptionEndedError(message) {
     var _this2;
 
-    _classCallCheck__default["default"](this, TRPCSubscriptionEndedError);
+    _classCallCheck(this, TRPCSubscriptionEndedError);
 
     _this2 = _super2.call(this, message);
     _this2.name = 'TRPCSubscriptionEndedError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this2), TRPCSubscriptionEndedError.prototype);
+    Object.setPrototypeOf(_assertThisInitialized(_this2), TRPCSubscriptionEndedError.prototype);
     return _this2;
   }
 
-  return _createClass__default["default"](TRPCSubscriptionEndedError);
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
+  return _createClass(TRPCSubscriptionEndedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
 
 function wsLink(opts) {
-  return function () {
+  // initialized config
+  return function (rt) {
     var client = opts.client;
     return function (_ref2) {
-      var op = _ref2.op;
-      return observable.observable(function (observer) {
-        var type = op.type,
-            input = op.input,
-            path = op.path,
-            id = op.id,
-            context = op.context;
-        var isDone = false;
-        var unsub = client.request({
-          type: type,
-          path: path,
-          input: input,
-          id: id,
-          context: context
-        }, {
-          error: function error(err) {
+      var op = _ref2.op,
+          prev = _ref2.prev,
+          onDestroy = _ref2.onDestroy;
+      var type = op.type,
+          rawInput = op.input,
+          path = op.path,
+          id = op.id;
+      var input = rt.transformer.serialize(rawInput);
+      var isDone = false;
+      var unsub = client.request({
+        type: type,
+        path: path,
+        input: input,
+        id: id
+      }, {
+        onNext: function onNext(result) {
+          if (isDone) {
+            return;
+          }
+
+          if ('data' in result) {
+            var data = rt.transformer.deserialize(result.data);
+            prev({
+              type: 'data',
+              data: data
+            });
+          } else {
+            prev(result);
+          }
+
+          if (op.type !== 'subscription') {
+            // if it isn't a subscription we don't care about next response
             isDone = true;
-            observer.error(err);
             unsub();
-          },
-          complete: function complete() {
-            if (!isDone) {
-              isDone = true;
-              observer.error(TRPCClientError.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 () {
+        },
+        onError: function onError(err) {
+          if (isDone) {
+            return;
+          }
+
+          prev(err instanceof Error ? err : TRPCClientError.TRPCClientError.from(_objectSpread(_objectSpread({}, err), {}, {
+            error: rt.transformer.deserialize(err.error)
+          })));
+        },
+        onDone: function onDone() {
+          if (isDone) {
+            return;
+          }
+
+          var result = new TRPCSubscriptionEndedError('Operation ended prematurely');
+          prev(TRPCClientError.TRPCClientError.from(result, {
+            isDone: true
+          }));
           isDone = true;
-          unsub();
-        };
+        }
+      });
+      onDestroy(function () {
+        isDone = true;
+        unsub();
       });
     };
   };

package/links/wsLink/dist/trpc-client-links-wsLink.cjs.js

@@ -1,16 +1,7 @@
-"use strict";
-// this file might look strange and you might be wondering what it's for
-// it's lets you import your source files by importing this entrypoint
-// as you would import it if it was built with preconstruct build
-// this file is slightly different to some others though
-// it has a require hook which compiles your code with Babel
-// this means that you don't have to set up @babel/register or anything like that
-// but you can still require this module and it'll be compiled
+'use strict';
 
-// this bit of code imports the require hook and registers it
-let unregister = require("../../../../../node_modules/@preconstruct/hook").___internalHook(typeof __dirname === 'undefined' ? undefined : __dirname, "../../../../..", "../../..");
-
-// this re-exports the source file
-module.exports = require("../../../src/links/wsLink.ts");
-
-unregister();
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./trpc-client-links-wsLink.cjs.prod.js");
+} else {
+  module.exports = require("./trpc-client-links-wsLink.cjs.dev.js");
+}