@jbrowse/plugin-circular-view 1.6.7 → 1.7.0

package/dist/CircularView/models/viewportVisibleRegion.js

@@ -0,0 +1,280 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cartesianToPolar = cartesianToPolar;
+exports.thetaRangesOverlap = thetaRangesOverlap;
+exports.viewportVisibleSection = viewportVisibleSection;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+function findCircleIntersectionX(y, cx, cy, r, resultArray) {
+  var d = Math.abs(y - cy);
+
+  if (d > r) {
+    return;
+  }
+
+  if (d === r) {
+    resultArray.push([cx, y]);
+  }
+
+  var solution = Math.sqrt(r * r - d * d);
+  resultArray.push([cx - solution, y]);
+  resultArray.push([cx + solution, y]);
+}
+
+function findCircleIntersectionY(x, cx, cy, r, resultArray) {
+  var d = Math.abs(x - cx);
+
+  if (d > r) {
+    return;
+  }
+
+  if (d === r) {
+    resultArray.push([x, cy]);
+  }
+
+  var solution = Math.sqrt(r * r - d * d);
+  resultArray.push([x, cy - solution]);
+  resultArray.push([x, cy + solution]);
+}
+
+function cartesianToTheta(x, y) {
+  var theta = (Math.atan(y / x) + 2 * Math.PI) % (2 * Math.PI);
+
+  if (x < 0) {
+    if (y <= 0) {
+      theta += Math.PI;
+    } else {
+      theta -= Math.PI;
+    }
+  }
+
+  return theta;
+}
+
+function cartesianToPolar(x, y) {
+  var rho = Math.sqrt(x * x + y * y);
+
+  if (rho === 0) {
+    return [0, 0];
+  }
+
+  var theta = cartesianToTheta(x, y);
+  return [rho, theta];
+}
+
+var twoPi = 2 * Math.PI;
+
+function thetaRangesOverlap(r1start, r1length, r2start, r2length) {
+  if (r1length <= 0 || r2length <= 0) {
+    return false;
+  }
+
+  if (r1length + 0.0001 >= twoPi || r2length + 0.0001 >= twoPi) {
+    return true;
+  } // put both range starts between 2π and 4π
+
+
+  r1start = (r1start % twoPi + twoPi) % twoPi + twoPi;
+  r2start = (r2start % twoPi + twoPi) % twoPi + twoPi;
+
+  if (r1start < r2start + r2length && r1start + r1length > r2start) {
+    return true;
+  } // move r2 2π to the left and check
+
+
+  r2start -= twoPi;
+
+  if (r1start < r2start + r2length && r1start + r1length > r2start) {
+    return true;
+  } // move it 2π to the right and check
+
+
+  r2start += twoPi + twoPi;
+  return r1start < r2start + r2length && r1start + r1length > r2start;
+} // return which arc range has any part of the circle visible in the viewport
+
+
+function viewportVisibleSection(viewSides, circleCenter, circleRadius) {
+  var _viewSides = (0, _slicedToArray2["default"])(viewSides, 4),
+      viewL = _viewSides[0],
+      viewR = _viewSides[1],
+      viewT = _viewSides[2],
+      viewB = _viewSides[3];
+
+  var _circleCenter = (0, _slicedToArray2["default"])(circleCenter, 2),
+      cx = _circleCenter[0],
+      cy = _circleCenter[1]; // transform coordinate system to center of circle
+
+
+  viewL -= cx;
+  viewR -= cx;
+  viewT -= cy;
+  viewB -= cy;
+  var centerIsInsideViewport = viewL < 0 && viewR > 0 && viewT < 0 && viewB > 0;
+
+  if (centerIsInsideViewport) {
+    var _vertices = [[viewL, viewT], [viewR, viewT], [viewL, viewB], [viewR, viewB]];
+    var maxRho = -Infinity;
+
+    for (var i = 0; i < _vertices.length; i += 1) {
+      var _vertices$i = (0, _slicedToArray2["default"])(_vertices[i], 2),
+          x = _vertices$i[0],
+          y = _vertices$i[1];
+
+      var rho = Math.sqrt(x * x + y * y);
+
+      if (rho > maxRho) {
+        maxRho = rho;
+      }
+    }
+
+    return {
+      rho: [0, Math.min(circleRadius, maxRho)],
+      theta: [0, 2 * Math.PI]
+    };
+  } // const viewportCompletelyContainsCircle =
+  //   circleCenter[0] - viewL >= circleRadius &&
+  //   viewR - circleCenter[0] >= circleRadius &&
+  //   circleCenter[1] - viewT >= circleRadius &&
+  //   viewB - circleCenter[1] >= circleRadius
+  // if (viewportCompletelyContainsCircle) {
+  //   return [0, 2 * Math.PI]
+  // }
+  // const distToCenterSquared = ([x, y]) => {
+  //   const [cx, cy] = circleCenter
+  //   const sq = n => n * n
+  //   return sq(x - cx) + sq(y - cy)
+  // }
+  // const circleRadiusSquared = circleRadius * circleRadius
+  // const tlInside = distToCenterSquared([viewL, viewT]) <= circleRadiusSquared
+  // const trInside = distToCenterSquared([viewR, viewT]) <= circleRadiusSquared
+  // const blInside = distToCenterSquared([viewL, viewB]) <= circleRadiusSquared
+  // const brInside = distToCenterSquared([viewR, viewB]) <= circleRadiusSquared
+  // const noIntersection = !tlInside && !trInside && !blInside && !brInside
+  // if (noIntersection) return undefined
+  // const circleCompletelyContainsViewport =
+  //   tlInside && trInside && blInside && brInside
+  // if (circleCompletelyContainsViewport) {
+  //   // viewport is in the circle, but the center is not in it, so take max
+  //   // and min of thetas to the center
+  //   const thetas = [
+  //     Math.atan(viewT / viewL),
+  //     Math.atan(viewT / viewR),
+  //     Math.atan(viewB / viewL),
+  //     Math.atan(viewB / viewR),
+  //   ]
+  //   return [Math.min(...thetas), Math.max(...thetas)]
+  // }
+  // if we get here, the viewport is partly in, partly out of the circle
+  // const viewLIntersects = Math.abs(viewL - circleCenter[0]) <= circleRadius
+  // const viewRIntersects = Math.abs(viewR - circleCenter[0]) <= circleRadius
+  // const viewTIntersects = Math.abs(viewT - circleCenter[1]) <= circleRadius
+  // const viewBIntersects = Math.abs(viewB - circleCenter[1]) <= circleRadius
+  // const numIntersectingSides =
+  //   Number(viewLIntersects) +
+  //   Number(viewRIntersects) +
+  //   Number(viewTIntersects) +
+  //   Number(viewBIntersects)
+  // if (numIntersectingSides === 4) return [0, 2 * Math.PI]
+  // if (numIntersectingSides === 3) {
+  //   // TODO calculate the thetas of the
+  // } else if (numIntersectingSides === 2) {
+  //   // TODO calculate the thetas of the 2 intersection points
+  // } else if (numIntersectingSides === 1) {
+  //   // TODO calculate the thetas of the 1-2 intersection points of the line, and the angle between
+  // }
+  // make a list of vertices-of-interest that lie inside both shapes to examine
+  // to determine the range covered by their intersection
+  // transform coordinates to have the circle as the origin and find the intersections
+  // of the circle and the view rectangle
+
+
+  var vertices = [[viewL, viewT], [viewR, viewT], [viewL, viewB], [viewR, viewB]];
+  findCircleIntersectionY(viewL, 0, 0, circleRadius, vertices);
+  findCircleIntersectionY(viewR, 0, 0, circleRadius, vertices);
+  findCircleIntersectionX(viewT, 0, 0, circleRadius, vertices);
+  findCircleIntersectionX(viewB, 0, 0, circleRadius, vertices); // for each edge, also look at the closest point to center if it is inside the circle
+
+  if (-viewL < circleRadius) {
+    vertices.push([viewL, 0]);
+  }
+
+  if (viewR < circleRadius) {
+    vertices.push([viewR, 0]);
+  }
+
+  if (-viewT < circleRadius) {
+    vertices.push([0, viewT]);
+  }
+
+  if (viewB < circleRadius) {
+    vertices.push([0, viewB]);
+  } // const verticesOriginal = vertices.map(([x, y]) => [x + cx, y + cy])
+  // now convert them all to polar and take the max and min of rho and theta
+  // const viewportCenterTheta = cartesianToTheta(viewR + viewL, viewT + viewB)
+
+
+  var reflect = viewL >= 0 ? -1 : 1; // viewportCenterTheta < Math.PI / 2 || viewportCenterTheta > 1.5 * Math.PI
+  //   ? -1
+  //   : 1
+
+  var rhoMin = Infinity;
+  var rhoMax = -Infinity;
+  var thetaMin = Infinity;
+  var thetaMax = -Infinity;
+
+  for (var _i = 0; _i < vertices.length; _i += 1) {
+    // ignore vertex if outside the viewport
+    var _vertices$_i = (0, _slicedToArray2["default"])(vertices[_i], 2),
+        vx = _vertices$_i[0],
+        vy = _vertices$_i[1];
+
+    if (vx >= viewL && vx <= viewR && vy >= viewT && vy <= viewB) {
+      var _cartesianToPolar = cartesianToPolar(vx * reflect, vy * reflect),
+          _cartesianToPolar2 = (0, _slicedToArray2["default"])(_cartesianToPolar, 2),
+          _rho = _cartesianToPolar2[0],
+          theta = _cartesianToPolar2[1]; // ignore vertex if outside the circle
+
+
+      if (_rho <= circleRadius + 0.001) {
+        // ignore theta if rho is 0
+        if (theta < thetaMin && _rho > 0.0001) {
+          thetaMin = theta;
+        }
+
+        if (theta > thetaMax && _rho > 0.0001) {
+          thetaMax = theta;
+        }
+
+        if (_rho < rhoMin) {
+          rhoMin = _rho;
+        }
+
+        if (_rho > rhoMax) {
+          rhoMax = _rho;
+        }
+      }
+    }
+  }
+
+  if (reflect === -1) {
+    thetaMin += Math.PI;
+    thetaMax += Math.PI;
+  }
+
+  if (thetaMin > 2 * Math.PI && thetaMax > 2 * Math.PI) {
+    thetaMin -= 2 * Math.PI;
+    thetaMax -= 2 * Math.PI;
+  }
+
+  return {
+    rho: [rhoMin, Math.min(circleRadius, rhoMax)],
+    theta: [thetaMin, thetaMax]
+  };
+}

package/dist/CircularView/models/viewportVisibleRegion.test.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _viewportVisibleRegion = require("./viewportVisibleRegion");
+
+describe('viewportVisibleSection', function () {
+  // test('circle contained in viewport', () => {
+  //   const result = viewportVisibleSection([0, 1, 0, 1], [0.5, 0.5], 0.3)
+  //   expect(result).toEqual({ rho: [0, 0.3], theta: [0, 2 * Math.PI] })
+  // })
+  // test('viewport completely inside circle', () => {
+  //   const result = viewportVisibleSection([0, 1, 0, 1], [0.5, 0.5], 20)
+  //   expect(result.theta).toEqual([0, 2 * Math.PI])
+  //   expect(result.rho[0]).toEqual(0)
+  //   expect(result.rho[1]).toBeCloseTo(0.7071)
+  // })
+  // test('viewport on left half of circle', () => {
+  //   const result = viewportVisibleSection([200, 500, 0, 1000], [500, 500], 20)
+  //   expect(result).toEqual({
+  //     rho: [0, 20],
+  //     theta: [Math.PI / 2, 1.5 * Math.PI],
+  //   })
+  // })
+  // test('viewport on right half of circle', () => {
+  //   const result = viewportVisibleSection([200, 500, 0, 1000], [200, 500], 20)
+  //   expect(result).toEqual({
+  //     rho: [0, 20],
+  //     theta: [1.5 * Math.PI, 2.5 * Math.PI],
+  //   })
+  // })
+  // test('viewport corner in circle', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [200, 500, 0, 700],
+  //     [199, 701],
+  //     100,
+  //   )
+  //   expect(rho).toEqual([1.4142135623730951, 100])
+  //   expect(theta[0]).toBeCloseTo(1.5 * Math.PI, 1)
+  //   expect(theta[1]).toBeCloseTo(2 * Math.PI, 1)
+  // })
+  // test('viewport on center right', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [1102, 2153, 880, 1280],
+  //     [1068.8119697255406, 1068.8119697255406],
+  //     1048.8119697255406,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(2 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2.5 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[0]).toBeLessThan(2 * Math.PI)
+  // })
+  // test('viewport on center right 2', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [1816, 2937, 1074, 1474],
+  //     [1468.6015446723616, 1468.6015446723616],
+  //     1448.6015446723616,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(2 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2.5 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[0]).toBeLessThan(2 * Math.PI)
+  // })
+  // test('viewport on lower center', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [259, 1350, 1176, 1576],
+  //     [787.7952717090081, 787.7952717090081],
+  //     767.7952717090081,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(Math.PI / 2)
+  //   expect(theta[1]).toBeLessThan(Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(0)
+  //   expect(theta[0]).toBeLessThan(Math.PI / 2)
+  // })
+  // test('viewport on upper center', () => {
+  //   const { theta, rho } = viewportVisibleSection(
+  //     [286, 1377, 0, 400],
+  //     [787.7952717090081, 787.7952717090081],
+  //     767.7952717090081,
+  //   )
+  //   expect(theta[1]).toBeGreaterThan(1.5 * Math.PI)
+  //   expect(theta[1]).toBeLessThan(2 * Math.PI)
+  //   expect(theta[0]).toBeGreaterThan(Math.PI)
+  //   expect(theta[0]).toBeLessThan(1.5 * Math.PI)
+  // })
+  test('viewport on upper center 2', function () {
+    // [180.48708681644143, 359.3411680673888] [4.6042679453532855, 541.6042679453533]
+    // see '~/Desktop/Screen Shot 2019-06-28 at 3.01.22 PM.png'
+    var _viewportVisibleSecti = (0, _viewportVisibleRegion.viewportVisibleSection)([0, 962, 157, 557], [561.6042679453533, 561.6042679453533], 541.6042679453533),
+        theta = _viewportVisibleSecti.theta;
+
+    expect(theta[1]).toBeGreaterThan(1.75 * Math.PI);
+    expect(theta[1]).toBeLessThan(2 * Math.PI);
+    expect(theta[0]).toBeGreaterThan(Math.PI);
+    expect(theta[0]).toBeLessThan(1.1 * Math.PI);
+  });
+});
+describe('cartesian to polar', function () {
+  ;
+  [[[-1, -1], [1.414, 180 + 45]], [[-1, 1], [1.414, 90 + 45]], [[1, 1], [1.414, 45]], [[1, -1], [1.414, 360 - 45]], [[0, 1], [1, 90]], [[0, -1], [1, 270]], [[-1, 0], [1, 180]], [[1, 0], [1, 0]]].forEach(function (testCase) {
+    var _testCase = (0, _slicedToArray2["default"])(testCase, 2),
+        input = _testCase[0],
+        output = _testCase[1];
+
+    test("".concat(input, " -> ").concat(output), function () {
+      var result = _viewportVisibleRegion.cartesianToPolar.apply(void 0, (0, _toConsumableArray2["default"])(input));
+
+      expect(result[0]).toBeCloseTo(output[0]);
+      expect(result[1] * 180 / Math.PI).toBeCloseTo(output[1]);
+    });
+  });
+});
+describe('theta overlap testing', function () {
+  ;
+  [[[0, 2 * Math.PI, 0, 2 * Math.PI], true], [[6.1, Math.PI / 2, 0, Math.PI / 2], true], [[6.1, Math.PI / 2, 0, 0.1], true], [[6.1, 0.1, 6.12, 0.05], true], [[-12, 0.1, -12.05, 0.05], false], [[-12, 0.1, -12.05, 0.06], true]].forEach(function (testCase) {
+    var _testCase2 = (0, _slicedToArray2["default"])(testCase, 2),
+        input = _testCase2[0],
+        output = _testCase2[1];
+
+    test("".concat(input, " -> ").concat(output), function () {
+      var result = _viewportVisibleRegion.thetaRangesOverlap.apply(void 0, (0, _toConsumableArray2["default"])(input));
+
+      expect(result).toBe(output);
+    });
+  });
+});

package/dist/index.js

@@ -1,8 +1,182 @@
+"use strict";
 
-'use strict'
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./plugin-circular-view.cjs.production.min.js')
-} else {
-  module.exports = require('./plugin-circular-view.cjs.development.js')
-}
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BaseChordDisplayComponentFactory", {
+  enumerable: true,
+  get: function get() {
+    return _BaseChordDisplay.BaseChordDisplayComponentFactory;
+  }
+});
+Object.defineProperty(exports, "BaseChordDisplayModel", {
+  enumerable: true,
+  get: function get() {
+    return _BaseChordDisplay.BaseChordDisplayModel;
+  }
+});
+Object.defineProperty(exports, "baseChordDisplayConfig", {
+  enumerable: true,
+  get: function get() {
+    return _BaseChordDisplay.baseChordDisplayConfig;
+  }
+});
+exports["default"] = 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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = require("react");
+
+var _mobx = require("mobx");
+
+var _util = require("@jbrowse/core/util");
+
+var _Plugin2 = _interopRequireDefault(require("@jbrowse/core/Plugin"));
+
+var _ViewType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/ViewType"));
+
+var _DataUsage = _interopRequireDefault(require("@material-ui/icons/DataUsage"));
+
+var _CircularView = _interopRequireDefault(require("./CircularView/models/CircularView"));
+
+var _BaseChordDisplay = require("./BaseChordDisplay");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 CircularViewPlugin = /*#__PURE__*/function (_Plugin) {
+  (0, _inherits2["default"])(CircularViewPlugin, _Plugin);
+
+  var _super = _createSuper(CircularViewPlugin);
+
+  function CircularViewPlugin() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, CircularViewPlugin);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "name", 'CircularViewPlugin');
+    return _this;
+  }
+
+  (0, _createClass2["default"])(CircularViewPlugin, [{
+    key: "install",
+    value: function install(pluginManager) {
+      pluginManager.addViewType(function () {
+        return new _ViewType["default"]({
+          ReactComponent: /*#__PURE__*/(0, _react.lazy)(function () {
+            return Promise.resolve().then(function () {
+              return _interopRequireWildcard(require('./CircularView/components/CircularView'));
+            });
+          }),
+          stateModel: (0, _CircularView["default"])(pluginManager),
+          name: 'CircularView'
+        });
+      });
+      pluginManager.addToExtensionPoint('LaunchView-CircularView',
+      /*#__PURE__*/
+      // @ts-ignore
+      function () {
+        var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(_ref) {
+          var session, assembly, loc, _ref$tracks, tracks, assemblyManager, view, asm;
+
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  session = _ref.session, assembly = _ref.assembly, loc = _ref.loc, _ref$tracks = _ref.tracks, tracks = _ref$tracks === void 0 ? [] : _ref$tracks;
+                  assemblyManager = session.assemblyManager;
+                  view = session.addView('CircularView', {});
+                  _context.next = 5;
+                  return (0, _mobx.when)(function () {
+                    return view.initialized;
+                  });
+
+                case 5:
+                  if (assembly) {
+                    _context.next = 7;
+                    break;
+                  }
+
+                  throw new Error('No assembly provided when launching circular genome view');
+
+                case 7:
+                  _context.next = 9;
+                  return assemblyManager.waitForAssembly(assembly);
+
+                case 9:
+                  asm = _context.sent;
+
+                  if (asm) {
+                    _context.next = 12;
+                    break;
+                  }
+
+                  throw new Error("Assembly \"".concat(assembly, "\" not found when launching circular genome view"));
+
+                case 12:
+                  view.setDisplayedRegions(asm.regions || []);
+                  tracks.forEach(function (track) {
+                    return view.showTrack(track);
+                  });
+
+                case 14:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        return function (_x) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+    }
+  }, {
+    key: "configure",
+    value: function configure(pluginManager) {
+      if ((0, _util.isAbstractMenuManager)(pluginManager.rootModel)) {
+        pluginManager.rootModel.appendToSubMenu(['Add'], {
+          label: 'Circular view',
+          icon: _DataUsage["default"],
+          onClick: function onClick(session) {
+            session.addView('CircularView', {});
+          }
+        });
+      }
+    }
+  }]);
+  return CircularViewPlugin;
+}(_Plugin2["default"]);
+
+exports["default"] = CircularViewPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-circular-view",
-  "version": "1.6.7",
+  "version": "1.7.0",
   "description": "JBrowse 2 circular view",
   "keywords": [
     "jbrowse",
@@ -18,15 +18,12 @@
   "distMain": "dist/index.js",
   "srcMain": "src/index.ts",
   "main": "dist/index.js",
-  "distModule": "dist/plugin-circular-view.esm.js",
-  "module": "dist/plugin-circular-view.esm.js",
   "files": [
     "dist",
     "src"
   ],
   "scripts": {
-    "start": "tsdx watch --verbose --noClean",
-    "build": "tsdx build",
+    "build": "babel src --root-mode upward --out-dir dist --extensions .ts,.js,.tsx,.jsx",
     "test": "cd ../..; jest plugins/circular-view",
     "prepublishOnly": "yarn test",
     "prepack": "yarn build; yarn useDist",
@@ -49,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "02012ec299c36647f755316571775d36b0fee5ec"
+  "gitHead": "cc13844074d11881d211342a6a7eea113561b70b"
 }