@jbrowse/core 1.4.1 → 1.5.2

package/pluggableElementTypes/RpcMethodType.js

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
@@ -29,8 +33,16 @@ var _PluggableElementBase2 = _interopRequireDefault(require("./PluggableElementB
 
 var _tracks = require("../util/tracks");
 
+var _types = require("../util/types");
+
 var _remoteAbortSignals = require("../rpc/remoteAbortSignals");
 
+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; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -67,16 +79,20 @@ var RpcMethodType = /*#__PURE__*/function (_PluggableElementBase) {
             switch (_context.prev = _context.next) {
               case 0:
                 blobMap = (0, _tracks.getBlobMap)();
+                _context.next = 3;
+                return this.augmentLocationObjects(args);
+
+              case 3:
                 return _context.abrupt("return", _objectSpread(_objectSpread({}, args), {}, {
                   blobMap: blobMap
                 }));
 
-              case 2:
+              case 4:
               case "end":
                 return _context.stop();
             }
           }
-        }, _callee);
+        }, _callee, this);
       }));
 
       function serializeArguments(_x, _x2) {
@@ -86,13 +102,63 @@ var RpcMethodType = /*#__PURE__*/function (_PluggableElementBase) {
       return serializeArguments;
     }()
   }, {
-    key: "deserializeArguments",
+    key: "serializeNewAuthArguments",
     value: function () {
-      var _deserializeArguments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(serializedArgs, _rpcDriverClassName) {
-        var signal;
+      var _serializeNewAuthArguments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(location) {
+        var rootModel, account, modifiedPreAuth;
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) {
             switch (_context2.prev = _context2.next) {
+              case 0:
+                rootModel = this.pluginManager.rootModel; // args dont need auth or already have auth
+
+                if (!(!(0, _types.isAppRootModel)(rootModel) || location.internetAccountPreAuthorization)) {
+                  _context2.next = 3;
+                  break;
+                }
+
+                return _context2.abrupt("return", location);
+
+              case 3:
+                account = rootModel === null || rootModel === void 0 ? void 0 : rootModel.findAppropriateInternetAccount(location);
+
+                if (!account) {
+                  _context2.next = 9;
+                  break;
+                }
+
+                _context2.next = 7;
+                return account.getPreAuthorizationInformation(location);
+
+              case 7:
+                modifiedPreAuth = _context2.sent;
+                location.internetAccountPreAuthorization = modifiedPreAuth;
+
+              case 9:
+                return _context2.abrupt("return", location);
+
+              case 10:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function serializeNewAuthArguments(_x3) {
+        return _serializeNewAuthArguments.apply(this, arguments);
+      }
+
+      return serializeNewAuthArguments;
+    }()
+  }, {
+    key: "deserializeArguments",
+    value: function () {
+      var _deserializeArguments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(serializedArgs, _rpcDriverClassName) {
+        var signal;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
               case 0:
                 if (serializedArgs.blobMap) {
                   (0, _tracks.setBlobMap)(serializedArgs.blobMap);
@@ -101,28 +167,28 @@ var RpcMethodType = /*#__PURE__*/function (_PluggableElementBase) {
                 signal = serializedArgs.signal;
 
                 if (!(signal && (0, _remoteAbortSignals.isRemoteAbortSignal)(signal))) {
-                  _context2.next = 4;
+                  _context3.next = 4;
                   break;
                 }
 
-                return _context2.abrupt("return", _objectSpread(_objectSpread({}, serializedArgs), {}, {
+                return _context3.abrupt("return", _objectSpread(_objectSpread({}, serializedArgs), {}, {
                   signal: (0, _remoteAbortSignals.deserializeAbortSignal)(signal)
                 }));
 
               case 4:
-                return _context2.abrupt("return", _objectSpread(_objectSpread({}, serializedArgs), {}, {
+                return _context3.abrupt("return", _objectSpread(_objectSpread({}, serializedArgs), {}, {
                   signal: undefined
                 }));
 
               case 5:
               case "end":
-                return _context2.stop();
+                return _context3.stop();
             }
           }
-        }, _callee2);
+        }, _callee3);
       }));
 
-      function deserializeArguments(_x3, _x4) {
+      function deserializeArguments(_x4, _x5) {
         return _deserializeArguments.apply(this, arguments);
       }
 
@@ -131,22 +197,22 @@ var RpcMethodType = /*#__PURE__*/function (_PluggableElementBase) {
   }, {
     key: "serializeReturn",
     value: function () {
-      var _serializeReturn = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(originalReturn, _args, _rpcDriverClassName) {
-        return _regenerator.default.wrap(function _callee3$(_context3) {
+      var _serializeReturn = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(originalReturn, _args, _rpcDriverClassName) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
           while (1) {
-            switch (_context3.prev = _context3.next) {
+            switch (_context4.prev = _context4.next) {
               case 0:
-                return _context3.abrupt("return", originalReturn);
+                return _context4.abrupt("return", originalReturn);
 
               case 1:
               case "end":
-                return _context3.stop();
+                return _context4.stop();
             }
           }
-        }, _callee3);
+        }, _callee4);
       }));
 
-      function serializeReturn(_x5, _x6, _x7) {
+      function serializeReturn(_x6, _x7, _x8) {
         return _serializeReturn.apply(this, arguments);
       }
 
@@ -155,27 +221,204 @@ var RpcMethodType = /*#__PURE__*/function (_PluggableElementBase) {
   }, {
     key: "deserializeReturn",
     value: function () {
-      var _deserializeReturn = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(serializedReturn, _args, _rpcDriverClassName) {
-        return _regenerator.default.wrap(function _callee4$(_context4) {
+      var _deserializeReturn = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(serializedReturn, _args, _rpcDriverClassName) {
+        var r, _this$pluginManager, _this$pluginManager$r, retryAccount;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
           while (1) {
-            switch (_context4.prev = _context4.next) {
+            switch (_context5.prev = _context5.next) {
               case 0:
-                return _context4.abrupt("return", serializedReturn);
+                _context5.prev = 0;
+                _context5.next = 3;
+                return serializedReturn;
 
-              case 1:
+              case 3:
+                r = _context5.sent;
+                _context5.next = 12;
+                break;
+
+              case 6:
+                _context5.prev = 6;
+                _context5.t0 = _context5["catch"](0);
+
+                if (!(0, _types.isAuthNeededException)(_context5.t0)) {
+                  _context5.next = 11;
+                  break;
+                }
+
+                retryAccount = // @ts-ignore
+                (_this$pluginManager = this.pluginManager) === null || _this$pluginManager === void 0 ? void 0 : (_this$pluginManager$r = _this$pluginManager.rootModel) === null || _this$pluginManager$r === void 0 ? void 0 : _this$pluginManager$r.createEphemeralInternetAccount("HTTPBasicInternetAccount-".concat(new URL(_context5.t0.location.uri).origin), {}, _context5.t0.location);
+                throw new _types.RetryError('Retrying with created internet account', retryAccount.internetAccountId);
+
+              case 11:
+                throw _context5.t0;
+
+              case 12:
+                return _context5.abrupt("return", r);
+
+              case 13:
               case "end":
-                return _context4.stop();
+                return _context5.stop();
             }
           }
-        }, _callee4);
+        }, _callee5, this, [[0, 6]]);
       }));
 
-      function deserializeReturn(_x8, _x9, _x10) {
+      function deserializeReturn(_x9, _x10, _x11) {
         return _deserializeReturn.apply(this, arguments);
       }
 
       return deserializeReturn;
     }()
+  }, {
+    key: "augmentLocationObjects",
+    value: function () {
+      var _augmentLocationObjects = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(thing) {
+        var _iterator, _step, val, _i, _Object$entries, _Object$entries$_i, key, value, _iterator2, _step2, _val;
+
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                if (!(0, _types.isUriLocation)(thing)) {
+                  _context6.next = 3;
+                  break;
+                }
+
+                _context6.next = 3;
+                return this.serializeNewAuthArguments(thing);
+
+              case 3:
+                if (!Array.isArray(thing)) {
+                  _context6.next = 21;
+                  break;
+                }
+
+                _iterator = _createForOfIteratorHelper(thing);
+                _context6.prev = 5;
+
+                _iterator.s();
+
+              case 7:
+                if ((_step = _iterator.n()).done) {
+                  _context6.next = 13;
+                  break;
+                }
+
+                val = _step.value;
+                _context6.next = 11;
+                return this.augmentLocationObjects(val);
+
+              case 11:
+                _context6.next = 7;
+                break;
+
+              case 13:
+                _context6.next = 18;
+                break;
+
+              case 15:
+                _context6.prev = 15;
+                _context6.t0 = _context6["catch"](5);
+
+                _iterator.e(_context6.t0);
+
+              case 18:
+                _context6.prev = 18;
+
+                _iterator.f();
+
+                return _context6.finish(18);
+
+              case 21:
+                if (!((0, _typeof2.default)(thing) === 'object' && thing !== null)) {
+                  _context6.next = 51;
+                  break;
+                }
+
+                _i = 0, _Object$entries = Object.entries(thing);
+
+              case 23:
+                if (!(_i < _Object$entries.length)) {
+                  _context6.next = 51;
+                  break;
+                }
+
+                _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
+
+                if (!Array.isArray(value)) {
+                  _context6.next = 45;
+                  break;
+                }
+
+                _iterator2 = _createForOfIteratorHelper(thing[key]);
+                _context6.prev = 27;
+
+                _iterator2.s();
+
+              case 29:
+                if ((_step2 = _iterator2.n()).done) {
+                  _context6.next = 35;
+                  break;
+                }
+
+                _val = _step2.value;
+                _context6.next = 33;
+                return this.augmentLocationObjects(_val);
+
+              case 33:
+                _context6.next = 29;
+                break;
+
+              case 35:
+                _context6.next = 40;
+                break;
+
+              case 37:
+                _context6.prev = 37;
+                _context6.t1 = _context6["catch"](27);
+
+                _iterator2.e(_context6.t1);
+
+              case 40:
+                _context6.prev = 40;
+
+                _iterator2.f();
+
+                return _context6.finish(40);
+
+              case 43:
+                _context6.next = 48;
+                break;
+
+              case 45:
+                if (!((0, _typeof2.default)(value) === 'object' && value !== null)) {
+                  _context6.next = 48;
+                  break;
+                }
+
+                _context6.next = 48;
+                return this.augmentLocationObjects(thing[key]);
+
+              case 48:
+                _i++;
+                _context6.next = 23;
+                break;
+
+              case 51:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this, [[5, 15, 18, 21], [27, 37, 40, 43]]);
+      }));
+
+      function augmentLocationObjects(_x12) {
+        return _augmentLocationObjects.apply(this, arguments);
+      }
+
+      return augmentLocationObjects;
+    }()
   }]);
   return RpcMethodType;
 }(_PluggableElementBase2.default);

package/pluggableElementTypes/RpcMethodType.test.d.ts

@@ -0,0 +1,4 @@
+import RpcMethodType from './RpcMethodType';
+export declare class MockRpcMethodType extends RpcMethodType {
+    execute(): Promise<void>;
+}

package/pluggableElementTypes/RpcMethodType.test.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MockRpcMethodType = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _PluginManager = _interopRequireDefault(require("../PluginManager"));
+
+var _RpcMethodType2 = _interopRequireDefault(require("./RpcMethodType"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.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; } }
+
+var pluginManager = new _PluginManager.default();
+
+var MockRpcMethodType = /*#__PURE__*/function (_RpcMethodType) {
+  (0, _inherits2.default)(MockRpcMethodType, _RpcMethodType);
+
+  var _super = _createSuper(MockRpcMethodType);
+
+  function MockRpcMethodType() {
+    (0, _classCallCheck2.default)(this, MockRpcMethodType);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(MockRpcMethodType, [{
+    key: "execute",
+    value: function () {
+      var _execute = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+
+      return execute;
+    }()
+  }]);
+  return MockRpcMethodType;
+}(_RpcMethodType2.default);
+
+exports.MockRpcMethodType = MockRpcMethodType;
+test('test serialize arguments with augmentLocationObject', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+  var mockRpc, locationInAdapter, deeplyNestedLocation;
+  return _regenerator.default.wrap(function _callee2$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          mockRpc = new MockRpcMethodType(pluginManager);
+          mockRpc.serializeNewAuthArguments = jest.fn().mockReturnValue({
+            locationType: 'UriLocation',
+            uri: 'test',
+            internetAccountId: 'HTTPBasicInternetAccount-test'
+          });
+          locationInAdapter = {
+            locationType: 'UriLocation',
+            uri: 'test',
+            internetAccountId: 'HTTPBasicInternetAccount-test'
+          };
+          deeplyNestedLocation = {
+            locationType: 'UriLocation',
+            uri: 'test2',
+            internetAccountId: 'HTTPBasicInternetAccount-test2'
+          };
+          _context2.next = 6;
+          return mockRpc.serializeArguments({
+            adapter: {
+              testLocation: locationInAdapter
+            },
+            filters: [],
+            signal: 'teststring',
+            randomProperty: 'randomstring',
+            parentObject: {
+              nestedObject: {
+                arrayInNestedObject: [deeplyNestedLocation]
+              }
+            }
+          }, '');
+
+        case 6:
+          expect(mockRpc.serializeNewAuthArguments).toHaveBeenCalledTimes(2);
+          expect(mockRpc.serializeNewAuthArguments).toHaveBeenCalledWith(locationInAdapter);
+          expect(mockRpc.serializeNewAuthArguments).toHaveBeenCalledWith(deeplyNestedLocation);
+
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }
+  }, _callee2);
+})));

package/pluggableElementTypes/ViewType.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
 import DisplayType from './DisplayType';

package/pluggableElementTypes/WidgetType.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 import { ComponentType, LazyExoticComponent } from 'react';
 import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';

package/pluggableElementTypes/index.d.ts

@@ -6,6 +6,10 @@ import TrackType from './TrackType';
 import DisplayType from './DisplayType';
 import ViewType from './ViewType';
 import RpcMethodType from './RpcMethodType';
-import TextSearchAdapter from './TextSearchAdapterType';
-export declare type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | TextSearchAdapter;
-export declare type PluggableElementMember = keyof AdapterType | keyof ConnectionType | keyof RendererType | keyof WidgetType | keyof TrackType | keyof DisplayType | keyof ViewType | keyof RpcMethodType | keyof TextSearchAdapter;
+import InternetAccountType from './InternetAccountType';
+import TextSearchAdapterType from './TextSearchAdapterType';
+export * from './renderers';
+export * from './models';
+export { AdapterType, ConnectionType, RendererType, WidgetType, TrackType, DisplayType, ViewType, RpcMethodType, InternetAccountType, TextSearchAdapterType, };
+export declare type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType;
+export declare type PluggableElementMember = keyof AdapterType | keyof ConnectionType | keyof RendererType | keyof WidgetType | keyof TrackType | keyof DisplayType | keyof ViewType | keyof RpcMethodType | keyof InternetAccountType | keyof TextSearchAdapterType;

package/pluggableElementTypes/index.js

@@ -1 +1,127 @@
-"use strict";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  AdapterType: true,
+  ConnectionType: true,
+  RendererType: true,
+  WidgetType: true,
+  TrackType: true,
+  DisplayType: true,
+  ViewType: true,
+  RpcMethodType: true,
+  InternetAccountType: true,
+  TextSearchAdapterType: true
+};
+Object.defineProperty(exports, "AdapterType", {
+  enumerable: true,
+  get: function get() {
+    return _AdapterType.default;
+  }
+});
+Object.defineProperty(exports, "ConnectionType", {
+  enumerable: true,
+  get: function get() {
+    return _ConnectionType.default;
+  }
+});
+Object.defineProperty(exports, "DisplayType", {
+  enumerable: true,
+  get: function get() {
+    return _DisplayType.default;
+  }
+});
+Object.defineProperty(exports, "InternetAccountType", {
+  enumerable: true,
+  get: function get() {
+    return _InternetAccountType.default;
+  }
+});
+Object.defineProperty(exports, "RendererType", {
+  enumerable: true,
+  get: function get() {
+    return _RendererType.default;
+  }
+});
+Object.defineProperty(exports, "RpcMethodType", {
+  enumerable: true,
+  get: function get() {
+    return _RpcMethodType.default;
+  }
+});
+Object.defineProperty(exports, "TextSearchAdapterType", {
+  enumerable: true,
+  get: function get() {
+    return _TextSearchAdapterType.default;
+  }
+});
+Object.defineProperty(exports, "TrackType", {
+  enumerable: true,
+  get: function get() {
+    return _TrackType.default;
+  }
+});
+Object.defineProperty(exports, "ViewType", {
+  enumerable: true,
+  get: function get() {
+    return _ViewType.default;
+  }
+});
+Object.defineProperty(exports, "WidgetType", {
+  enumerable: true,
+  get: function get() {
+    return _WidgetType.default;
+  }
+});
+
+var _AdapterType = _interopRequireDefault(require("./AdapterType"));
+
+var _ConnectionType = _interopRequireDefault(require("./ConnectionType"));
+
+var _RendererType = _interopRequireDefault(require("./renderers/RendererType"));
+
+var _WidgetType = _interopRequireDefault(require("./WidgetType"));
+
+var _TrackType = _interopRequireDefault(require("./TrackType"));
+
+var _DisplayType = _interopRequireDefault(require("./DisplayType"));
+
+var _ViewType = _interopRequireDefault(require("./ViewType"));
+
+var _RpcMethodType = _interopRequireDefault(require("./RpcMethodType"));
+
+var _InternetAccountType = _interopRequireDefault(require("./InternetAccountType"));
+
+var _TextSearchAdapterType = _interopRequireDefault(require("./TextSearchAdapterType"));
+
+var _renderers = require("./renderers");
+
+Object.keys(_renderers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _renderers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _renderers[key];
+    }
+  });
+});
+
+var _models = require("./models");
+
+Object.keys(_models).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _models[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _models[key];
+    }
+  });
+});