@jbrowse/plugin-circular-view 1.6.9 → 1.7.2

package/dist/CircularView/models/CircularView.d.ts

@@ -1,97 +1,97 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration/configurationSchema';
-import PluginManager from '@jbrowse/core/PluginManager';
-import { SnapshotOrInstance, Instance } from 'mobx-state-tree';
-import { Region } from '@jbrowse/core/util/types/mst';
-export default function CircularView(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    displayName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-} & {
-    type: import("mobx-state-tree").ISimpleType<"CircularView">;
-    offsetRadians: import("mobx-state-tree").IType<number | undefined, number, number>;
-    bpPerPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyType>;
-    hideVerticalResizeHandle: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    hideTrackSelectorButton: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    lockedFitToWindow: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    disableImportForm: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    height: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
-    minimumRadiusPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    spacingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    paddingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    lockedPaddingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    minVisibleWidth: import("mobx-state-tree").IType<number | undefined, number, number>;
-    minimumBlockWidth: import("mobx-state-tree").IType<number | undefined, number, number>;
-    displayedRegions: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
-        refName: import("mobx-state-tree").ISimpleType<string>;
-        start: import("mobx-state-tree").ISimpleType<number>;
-        end: import("mobx-state-tree").ISimpleType<number>;
-        reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-    } & {
-        assemblyName: import("mobx-state-tree").ISimpleType<string>;
-    }, {
-        setRefName(newRefName: string): void;
-    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    scrollX: import("mobx-state-tree").IType<number | undefined, number, number>;
-    scrollY: import("mobx-state-tree").IType<number | undefined, number, number>;
-    trackSelectorType: import("mobx-state-tree").IType<string | undefined, string, string>;
-}, {
-    width: number;
-} & {
-    menuItems(): import("@jbrowse/core/ui").MenuItem[];
-} & {
-    setDisplayName(name: string): void;
-    setWidth(newWidth: number): void;
-} & {
-    width: number;
-} & {
-    readonly staticSlices: import("./slices").Slice[];
-    readonly visibleStaticSlices: import("./slices").Slice[];
-    readonly visibleSection: {
-        rho: number[];
-        theta: number[];
-    };
-    readonly circumferencePx: number;
-    readonly radiusPx: number;
-    readonly bpPerRadian: number;
-    readonly pxPerRadian: number;
-    readonly centerXY: [number, number];
-    readonly totalBp: number;
-    readonly maximumRadiusPx: number;
-    readonly maxBpPerPx: number;
-    readonly minBpPerPx: number;
-    readonly atMaxBpPerPx: boolean;
-    readonly atMinBpPerPx: boolean;
-    readonly tooSmallToLock: boolean;
-    readonly figureDimensions: number[];
-    readonly figureWidth: number;
-    readonly figureHeight: number;
-    readonly elidedRegions: any[];
-    readonly assemblyNames: string[];
-    readonly initialized: boolean;
-} & {
-    error: Error | undefined;
-} & {
-    setWidth(newWidth: number): number;
-    setHeight(newHeight: number): number;
-    resizeHeight(distance: number): number;
-    resizeWidth(distance: number): number;
-    rotateClockwiseButton(): void;
-    rotateCounterClockwiseButton(): void;
-    rotateClockwise(distance?: number): void;
-    rotateCounterClockwise(distance?: number): void;
-    zoomInButton(): void;
-    zoomOutButton(): void;
-    setBpPerPx(newVal: number): void;
-    setModelViewWhenAdjust(secondCondition: boolean): void;
-    closeView(): void;
-    setDisplayedRegions(regions: SnapshotOrInstance<typeof Region>[]): void;
-    activateTrackSelector(): import("@jbrowse/core/util").Widget;
-    toggleTrack(trackId: string): void;
-    setError(error: Error): void;
-    showTrack(trackId: string, initialSnapshot?: {}): void;
-    addTrackConf(configuration: AnyConfigurationModel, initialSnapshot?: {}): void;
-    hideTrack(trackId: string): number;
-    toggleFitToWindowLock(): boolean;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export declare type CircularViewStateModel = ReturnType<typeof CircularView>;
-export declare type CircularViewModel = Instance<CircularViewStateModel>;
+import { AnyConfigurationModel } from '@jbrowse/core/configuration/configurationSchema';
+import PluginManager from '@jbrowse/core/PluginManager';
+import { SnapshotOrInstance, Instance } from 'mobx-state-tree';
+import { Region } from '@jbrowse/core/util/types/mst';
+export default function CircularView(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    displayName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+} & {
+    type: import("mobx-state-tree").ISimpleType<"CircularView">;
+    offsetRadians: import("mobx-state-tree").IType<number | undefined, number, number>;
+    bpPerPx: import("mobx-state-tree").IType<number | undefined, number, number>;
+    tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyType>;
+    hideVerticalResizeHandle: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    hideTrackSelectorButton: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    lockedFitToWindow: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    disableImportForm: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    height: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
+    minimumRadiusPx: import("mobx-state-tree").IType<number | undefined, number, number>;
+    spacingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
+    paddingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
+    lockedPaddingPx: import("mobx-state-tree").IType<number | undefined, number, number>;
+    minVisibleWidth: import("mobx-state-tree").IType<number | undefined, number, number>;
+    minimumBlockWidth: import("mobx-state-tree").IType<number | undefined, number, number>;
+    displayedRegions: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+        refName: import("mobx-state-tree").ISimpleType<string>;
+        start: import("mobx-state-tree").ISimpleType<number>;
+        end: import("mobx-state-tree").ISimpleType<number>;
+        reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    } & {
+        assemblyName: import("mobx-state-tree").ISimpleType<string>;
+    }, {
+        setRefName(newRefName: string): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    scrollX: import("mobx-state-tree").IType<number | undefined, number, number>;
+    scrollY: import("mobx-state-tree").IType<number | undefined, number, number>;
+    trackSelectorType: import("mobx-state-tree").IType<string | undefined, string, string>;
+}, {
+    width: number;
+} & {
+    menuItems(): import("@jbrowse/core/ui").MenuItem[];
+} & {
+    setDisplayName(name: string): void;
+    setWidth(newWidth: number): void;
+} & {
+    width: number;
+} & {
+    readonly staticSlices: import("./slices").Slice[];
+    readonly visibleStaticSlices: import("./slices").Slice[];
+    readonly visibleSection: {
+        rho: number[];
+        theta: number[];
+    };
+    readonly circumferencePx: number;
+    readonly radiusPx: number;
+    readonly bpPerRadian: number;
+    readonly pxPerRadian: number;
+    readonly centerXY: [number, number];
+    readonly totalBp: number;
+    readonly maximumRadiusPx: number;
+    readonly maxBpPerPx: number;
+    readonly minBpPerPx: number;
+    readonly atMaxBpPerPx: boolean;
+    readonly atMinBpPerPx: boolean;
+    readonly tooSmallToLock: boolean;
+    readonly figureDimensions: number[];
+    readonly figureWidth: number;
+    readonly figureHeight: number;
+    readonly elidedRegions: any[];
+    readonly assemblyNames: string[];
+    readonly initialized: boolean;
+} & {
+    error: Error | undefined;
+} & {
+    setWidth(newWidth: number): number;
+    setHeight(newHeight: number): number;
+    resizeHeight(distance: number): number;
+    resizeWidth(distance: number): number;
+    rotateClockwiseButton(): void;
+    rotateCounterClockwiseButton(): void;
+    rotateClockwise(distance?: number): void;
+    rotateCounterClockwise(distance?: number): void;
+    zoomInButton(): void;
+    zoomOutButton(): void;
+    setBpPerPx(newVal: number): void;
+    setModelViewWhenAdjust(secondCondition: boolean): void;
+    closeView(): void;
+    setDisplayedRegions(regions: SnapshotOrInstance<typeof Region>[]): void;
+    activateTrackSelector(): import("@jbrowse/core/util").Widget;
+    toggleTrack(trackId: string): void;
+    setError(error: Error): void;
+    showTrack(trackId: string, initialSnapshot?: {}): void;
+    addTrackConf(configuration: AnyConfigurationModel, initialSnapshot?: {}): void;
+    hideTrack(trackId: string): number;
+    toggleFitToWindowLock(): boolean;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export declare type CircularViewStateModel = ReturnType<typeof CircularView>;
+export declare type CircularViewModel = Instance<CircularViewStateModel>;

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.d.ts

@@ -1,27 +1,27 @@
-import { Region } from '@jbrowse/core/util';
-export declare class Slice {
-    region: Region & {
-        widthBp: number;
-        elided: boolean;
-    };
-    radianWidth: number;
-    key: string;
-    offsetRadians: number;
-    startRadians: number;
-    endRadians: number;
-    bpPerRadian: number;
-    flipped: boolean;
-    constructor(view: {
-        bpPerRadian: number;
-    }, region: Region & {
-        widthBp: number;
-        elided: boolean;
-    }, currentRadianOffset: number, radianWidth: number);
-    bpToXY(bp: number, radiusPx: number): [number, number];
-    toJSON(): {
-        [k: string]: any;
-    };
-}
-declare function calculateStaticSlices(self: any): Slice[];
-declare function sliceIsVisible(self: any, slice: Slice): boolean;
-export { calculateStaticSlices, sliceIsVisible };
+import { Region } from '@jbrowse/core/util';
+export declare class Slice {
+    region: Region & {
+        widthBp: number;
+        elided: boolean;
+    };
+    radianWidth: number;
+    key: string;
+    offsetRadians: number;
+    startRadians: number;
+    endRadians: number;
+    bpPerRadian: number;
+    flipped: boolean;
+    constructor(view: {
+        bpPerRadian: number;
+    }, region: Region & {
+        widthBp: number;
+        elided: boolean;
+    }, currentRadianOffset: number, radianWidth: number);
+    bpToXY(bp: number, radiusPx: number): [number, number];
+    toJSON(): {
+        [k: string]: any;
+    };
+}
+declare function calculateStaticSlices(self: any): Slice[];
+declare function sliceIsVisible(self: any, slice: Slice): boolean;
+export { calculateStaticSlices, sliceIsVisible };