@jbrowse/plugin-circular-view 1.6.9 → 1.7.0

package/dist/CircularView/models/CircularView.js

@@ -0,0 +1,422 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = CircularView;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _mst = require("@jbrowse/core/util/types/mst");
+
+var _mobx = require("mobx");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _util = require("@jbrowse/core/util");
+
+var _models = require("@jbrowse/core/pluggableElementTypes/models");
+
+var _slices = require("./slices");
+
+var _viewportVisibleRegion = require("./viewportVisibleRegion");
+
+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) { (0, _defineProperty2["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; }
+
+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 CircularView(pluginManager) {
+  var minHeight = 40;
+  var minWidth = 100;
+  var defaultHeight = 400;
+  return _mobxStateTree.types.compose(_models.BaseViewModel, _mobxStateTree.types.model('CircularView', {
+    type: _mobxStateTree.types.literal('CircularView'),
+    offsetRadians: -Math.PI / 2,
+    bpPerPx: 2000000,
+    tracks: _mobxStateTree.types.array(pluginManager.pluggableMstType('track', 'stateModel')),
+    hideVerticalResizeHandle: false,
+    hideTrackSelectorButton: false,
+    lockedFitToWindow: true,
+    disableImportForm: false,
+    height: _mobxStateTree.types.optional(_mobxStateTree.types.refinement('trackHeight', _mobxStateTree.types.number, function (n) {
+      return n >= minHeight;
+    }), defaultHeight),
+    minimumRadiusPx: 25,
+    spacingPx: 10,
+    paddingPx: 80,
+    lockedPaddingPx: 100,
+    minVisibleWidth: 6,
+    minimumBlockWidth: 20,
+    displayedRegions: _mobxStateTree.types.array(_mst.Region),
+    scrollX: 0,
+    scrollY: 0,
+    trackSelectorType: 'hierarchical'
+  })["volatile"](function () {
+    return {
+      width: 0
+    };
+  }).views(function (self) {
+    return {
+      get staticSlices() {
+        return (0, _slices.calculateStaticSlices)(self);
+      },
+
+      get visibleStaticSlices() {
+        return this.staticSlices.filter(_slices.sliceIsVisible.bind(this, self));
+      },
+
+      get visibleSection() {
+        return (0, _viewportVisibleRegion.viewportVisibleSection)([self.scrollX, self.scrollX + self.width, self.scrollY, self.scrollY + self.height], this.centerXY, this.radiusPx);
+      },
+
+      get circumferencePx() {
+        var elidedBp = 0;
+
+        var _iterator = _createForOfIteratorHelper(this.elidedRegions),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var r = _step.value;
+            elidedBp += r.widthBp;
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        return elidedBp / self.bpPerPx + self.spacingPx * this.elidedRegions.length;
+      },
+
+      get radiusPx() {
+        return this.circumferencePx / (2 * Math.PI);
+      },
+
+      get bpPerRadian() {
+        return self.bpPerPx * this.radiusPx;
+      },
+
+      get pxPerRadian() {
+        return this.radiusPx;
+      },
+
+      get centerXY() {
+        return [this.radiusPx + self.paddingPx, this.radiusPx + self.paddingPx];
+      },
+
+      get totalBp() {
+        var total = 0;
+
+        var _iterator2 = _createForOfIteratorHelper(self.displayedRegions),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var region = _step2.value;
+            total += region.end - region.start;
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        return total;
+      },
+
+      get maximumRadiusPx() {
+        return self.lockedFitToWindow ? Math.min(self.width, self.height) / 2 - self.lockedPaddingPx : 1000000;
+      },
+
+      get maxBpPerPx() {
+        var minCircumferencePx = 2 * Math.PI * self.minimumRadiusPx;
+        return this.totalBp / minCircumferencePx;
+      },
+
+      get minBpPerPx() {
+        // min depends on window dimensions, clamp between old min(0.01) and max
+        var maxCircumferencePx = 2 * Math.PI * this.maximumRadiusPx;
+        return (0, _util.clamp)(this.totalBp / maxCircumferencePx, 0.0000000001, this.maxBpPerPx);
+      },
+
+      get atMaxBpPerPx() {
+        return self.bpPerPx >= this.maxBpPerPx;
+      },
+
+      get atMinBpPerPx() {
+        return self.bpPerPx <= this.minBpPerPx;
+      },
+
+      get tooSmallToLock() {
+        return this.minBpPerPx <= 0.0000000001;
+      },
+
+      get figureDimensions() {
+        return [this.radiusPx * 2 + 2 * self.paddingPx, this.radiusPx * 2 + 2 * self.paddingPx];
+      },
+
+      get figureWidth() {
+        return this.figureDimensions[0];
+      },
+
+      get figureHeight() {
+        return this.figureDimensions[1];
+      },
+
+      // this is displayedRegions, post-processed to
+      // elide regions that are too small to see reasonably
+      get elidedRegions() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var visible = [];
+        self.displayedRegions.forEach(function (region) {
+          var widthBp = region.end - region.start;
+          var widthPx = widthBp / self.bpPerPx;
+
+          if (widthPx < self.minVisibleWidth) {
+            // too small to see, collapse into a single elision region
+            var lastVisible = visible[visible.length - 1];
+
+            if (lastVisible && lastVisible.elided) {
+              lastVisible.regions.push(_objectSpread({}, region));
+              lastVisible.widthBp += widthBp;
+            } else {
+              visible.push({
+                elided: true,
+                widthBp: widthBp,
+                regions: [_objectSpread({}, region)]
+              });
+            }
+          } else {
+            // big enough to see, display it
+            visible.push(_objectSpread(_objectSpread({}, region), {}, {
+              widthBp: widthBp
+            }));
+          }
+        }); // remove any single-region elisions
+
+        for (var i = 0; i < visible.length; i += 1) {
+          var v = visible[i];
+
+          if (v.elided && v.regions.length === 1) {
+            delete v.elided;
+            visible[i] = _objectSpread(_objectSpread({}, v), v.regions[0]);
+          }
+        }
+
+        return visible;
+      },
+
+      get assemblyNames() {
+        var assemblyNames = [];
+        self.displayedRegions.forEach(function (displayedRegion) {
+          if (!assemblyNames.includes(displayedRegion.assemblyName)) {
+            assemblyNames.push(displayedRegion.assemblyName);
+          }
+        });
+        return assemblyNames;
+      },
+
+      get initialized() {
+        var _getSession = (0, _util.getSession)(self),
+            assemblyManager = _getSession.assemblyManager;
+
+        return this.assemblyNames.every(function (a) {
+          var _assemblyManager$get;
+
+          return (_assemblyManager$get = assemblyManager.get(a)) === null || _assemblyManager$get === void 0 ? void 0 : _assemblyManager$get.initialized;
+        });
+      }
+
+    };
+  })["volatile"](function () {
+    return {
+      error: undefined
+    };
+  }).actions(function (self) {
+    return {
+      // toggle action with a flag stating which mode it's in
+      setWidth: function setWidth(newWidth) {
+        self.width = Math.max(newWidth, minWidth);
+        return self.width;
+      },
+      setHeight: function setHeight(newHeight) {
+        self.height = Math.max(newHeight, minHeight);
+        return self.height;
+      },
+      resizeHeight: function resizeHeight(distance) {
+        var oldHeight = self.height;
+        var newHeight = this.setHeight(self.height + distance);
+        this.setModelViewWhenAdjust(!self.tooSmallToLock);
+        return newHeight - oldHeight;
+      },
+      resizeWidth: function resizeWidth(distance) {
+        var oldWidth = self.width;
+        var newWidth = this.setWidth(self.width + distance);
+        this.setModelViewWhenAdjust(!self.tooSmallToLock);
+        return newWidth - oldWidth;
+      },
+      rotateClockwiseButton: function rotateClockwiseButton() {
+        this.rotateClockwise(Math.PI / 6);
+      },
+      rotateCounterClockwiseButton: function rotateCounterClockwiseButton() {
+        this.rotateCounterClockwise(Math.PI / 6);
+      },
+      rotateClockwise: function rotateClockwise() {
+        var distance = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.17;
+        self.offsetRadians += distance;
+      },
+      rotateCounterClockwise: function rotateCounterClockwise() {
+        var distance = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.17;
+        self.offsetRadians -= distance;
+      },
+      zoomInButton: function zoomInButton() {
+        this.setBpPerPx(self.bpPerPx / 1.4);
+      },
+      zoomOutButton: function zoomOutButton() {
+        this.setBpPerPx(self.bpPerPx * 1.4);
+      },
+      setBpPerPx: function setBpPerPx(newVal) {
+        self.bpPerPx = (0, _util.clamp)(newVal, self.minBpPerPx, self.maxBpPerPx);
+      },
+      setModelViewWhenAdjust: function setModelViewWhenAdjust(secondCondition) {
+        if (self.lockedFitToWindow && secondCondition) {
+          this.setBpPerPx(self.minBpPerPx);
+        }
+      },
+      closeView: function closeView() {
+        (0, _mobxStateTree.getParent)(self, 2).removeView(self);
+      },
+      setDisplayedRegions: function setDisplayedRegions(regions) {
+        var previouslyEmpty = self.displayedRegions.length === 0;
+        self.displayedRegions = (0, _mobxStateTree.cast)(regions);
+
+        if (previouslyEmpty) {
+          this.setBpPerPx(self.minBpPerPx);
+        } else {
+          this.setBpPerPx(self.bpPerPx);
+        }
+      },
+      activateTrackSelector: function activateTrackSelector() {
+        if (self.trackSelectorType === 'hierarchical') {
+          var session = (0, _util.getSession)(self);
+
+          if ((0, _util.isSessionModelWithWidgets)(session)) {
+            var selector = session.addWidget('HierarchicalTrackSelectorWidget', 'hierarchicalTrackSelector', {
+              view: self
+            });
+            session.showWidget(selector);
+            return selector;
+          }
+        }
+
+        throw new Error("invalid track selector type ".concat(self.trackSelectorType));
+      },
+      toggleTrack: function toggleTrack(trackId) {
+        // if we have any tracks with that configuration, turn them off
+        var hiddenCount = this.hideTrack(trackId); // if none had that configuration, turn one on
+
+        if (!hiddenCount) {
+          this.showTrack(trackId);
+        }
+      },
+      setError: function setError(error) {
+        console.error(error);
+        self.error = error;
+      },
+      showTrack: function showTrack(trackId) {
+        var initialSnapshot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var trackConfigSchema = pluginManager.pluggableConfigSchemaType('track');
+        var configuration = (0, _mobxStateTree.resolveIdentifier)(trackConfigSchema, (0, _mobxStateTree.getRoot)(self), trackId);
+        var trackType = pluginManager.getTrackType(configuration.type);
+
+        if (!trackType) {
+          throw new Error("unknown track type ".concat(configuration.type));
+        }
+
+        var viewType = pluginManager.getViewType(self.type);
+        var supportedDisplays = viewType.displayTypes.map(function (displayType) {
+          return displayType.name;
+        });
+        var displayConf = configuration.displays.find(function (d) {
+          return supportedDisplays.includes(d.type);
+        });
+        var track = trackType.stateModel.create(_objectSpread(_objectSpread({}, initialSnapshot), {}, {
+          type: configuration.type,
+          configuration: configuration,
+          displays: [{
+            type: displayConf.type,
+            configuration: displayConf
+          }]
+        }));
+        self.tracks.push(track);
+      },
+      addTrackConf: function addTrackConf(configuration) {
+        var initialSnapshot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var type = configuration.type;
+        var name = (0, _configuration.readConfObject)(configuration, 'name');
+        var trackType = pluginManager.getTrackType(type);
+
+        if (!trackType) {
+          throw new Error("unknown track type ".concat(configuration.type));
+        }
+
+        var viewType = pluginManager.getViewType(self.type);
+        var supportedDisplays = viewType.displayTypes.map(function (displayType) {
+          return displayType.name;
+        });
+        var displayConf = configuration.displays.find(function (d) {
+          return supportedDisplays.includes(d.type);
+        });
+        var track = trackType.stateModel.create(_objectSpread(_objectSpread({}, initialSnapshot), {}, {
+          name: name,
+          type: type,
+          configuration: configuration,
+          displays: [{
+            type: displayConf.type,
+            configuration: displayConf
+          }]
+        }));
+        self.tracks.push(track);
+      },
+      hideTrack: function hideTrack(trackId) {
+        var trackConfigSchema = pluginManager.pluggableConfigSchemaType('track');
+        var configuration = (0, _mobxStateTree.resolveIdentifier)(trackConfigSchema, (0, _mobxStateTree.getRoot)(self), trackId); // if we have any tracks with that configuration, turn them off
+
+        var shownTracks = self.tracks.filter(function (t) {
+          return t.configuration === configuration;
+        });
+        (0, _mobx.transaction)(function () {
+          return shownTracks.forEach(function (t) {
+            return self.tracks.remove(t);
+          });
+        });
+        return shownTracks.length;
+      },
+      toggleFitToWindowLock: function toggleFitToWindowLock() {
+        self.lockedFitToWindow = !self.lockedFitToWindow; // when going unlocked -> locked and circle is cut off, set to the locked minBpPerPx
+
+        this.setModelViewWhenAdjust(self.atMinBpPerPx);
+        return self.lockedFitToWindow;
+      }
+    };
+  }));
+}
+/*
+PLANS
+
+- tracks
+- ruler tick marks
+- set viewport scroll from state snapshot
+
+*/

package/dist/CircularView/models/slices.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Slice = void 0;
+exports.calculateStaticSlices = calculateStaticSlices;
+exports.sliceIsVisible = sliceIsVisible;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _util = require("@jbrowse/core/util");
+
+var _viewportVisibleRegion = require("./viewportVisibleRegion");
+
+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; }
+
+var Slice = /*#__PURE__*/function () {
+  function Slice(view, region, currentRadianOffset, radianWidth) {
+    (0, _classCallCheck2["default"])(this, Slice);
+    this.region = region;
+    this.radianWidth = radianWidth;
+    (0, _defineProperty2["default"])(this, "key", void 0);
+    (0, _defineProperty2["default"])(this, "offsetRadians", void 0);
+    (0, _defineProperty2["default"])(this, "startRadians", void 0);
+    (0, _defineProperty2["default"])(this, "endRadians", void 0);
+    (0, _defineProperty2["default"])(this, "bpPerRadian", void 0);
+    (0, _defineProperty2["default"])(this, "flipped", void 0);
+    var bpPerRadian = view.bpPerRadian;
+    this.key = (0, _util.assembleLocString)(region);
+    this.offsetRadians = currentRadianOffset;
+    this.bpPerRadian = bpPerRadian;
+    this.flipped = false;
+    this.startRadians = this.offsetRadians;
+    this.endRadians = region.widthBp / this.bpPerRadian + this.offsetRadians;
+    Object.freeze(this);
+  }
+
+  (0, _createClass2["default"])(Slice, [{
+    key: "bpToXY",
+    value: function bpToXY(bp, radiusPx) {
+      var offsetBp;
+
+      if (this.region.elided) {
+        offsetBp = this.region.widthBp / 2;
+      } else if (this.flipped) {
+        offsetBp = this.region.end - bp;
+      } else {
+        offsetBp = bp - this.region.start;
+      }
+
+      var totalRadians = offsetBp / this.bpPerRadian + this.offsetRadians;
+      return (0, _util.polarToCartesian)(radiusPx, totalRadians);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return (0, _util.objectFromEntries)(Object.entries(this));
+    }
+  }]);
+  return Slice;
+}(); // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+exports.Slice = Slice;
+
+function calculateStaticSlices(self) {
+  var slices = [];
+  var currentRadianOffset = 0;
+
+  var _iterator = _createForOfIteratorHelper(self.elidedRegions),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _region = _step.value;
+
+      var _radianWidth = _region.widthBp / self.bpPerRadian + self.spacingPx / self.pxPerRadian;
+
+      slices.push(new Slice(self, _region, currentRadianOffset, _radianWidth));
+      currentRadianOffset += _radianWidth;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return slices;
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function sliceIsVisible(self, slice) {
+  var _self$visibleSection$ = (0, _slicedToArray2["default"])(self.visibleSection.theta, 2),
+      visibleThetaMin = _self$visibleSection$[0],
+      visibleThetaMax = _self$visibleSection$[1];
+
+  return (0, _viewportVisibleRegion.thetaRangesOverlap)(slice.offsetRadians + self.offsetRadians, slice.radianWidth, visibleThetaMin, visibleThetaMax - visibleThetaMin);
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _slices2 = require("./slices");
+
+test('one slice', function () {
+  var view = {
+    elidedRegions: [{
+      refName: 'toast',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    totalBp: 10000,
+    bpPerRadian: 10000 / (2 * Math.PI),
+    pxPerRadian: 1000
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(1);
+
+  var _slices = (0, _slicedToArray2["default"])(slices, 1),
+      slice = _slices[0]; // expect(slices).toMatchSnapshot()
+
+
+  expect(slice).toMatchSnapshot();
+});
+test('two slices', function () {
+  var view = {
+    elidedRegions: [{
+      refName: 'toast',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }, {
+      refName: 'teest',
+      start: 0,
+      end: 10000,
+      widthBp: 10000
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    pxPerRadian: 1000,
+    totalBp: 20000,
+    bpPerRadian: 20000 / (2 * Math.PI)
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(2);
+  expect(slices).toMatchSnapshot();
+});
+test('volvox', function () {
+  var totalBp = 50001 + 6079;
+  var view = {
+    elidedRegions: [{
+      refName: 'ctgA',
+      start: 0,
+      end: 50001,
+      assemblyName: 'volvox',
+      widthBp: 50001
+    }, {
+      refName: 'ctgB',
+      start: 0,
+      end: 6079,
+      assemblyName: 'volvox',
+      widthBp: 6079
+    }],
+    spacingPx: 5,
+    radiusPx: 1000,
+    pxPerRadian: 1000,
+    totalBp: totalBp,
+    bpPerRadian: totalBp / (2 * Math.PI)
+  };
+  var slices = (0, _slices2.calculateStaticSlices)(view); // console.log(slices)
+
+  expect(slices.length).toBe(2);
+  expect(slices).toMatchSnapshot();
+});