@jbrowse/core 2.0.0 → 2.0.1

package/util/Base1DUtils.d.ts

@@ -0,0 +1,32 @@
+import { ViewSnap } from './index';
+export interface BpOffset {
+    refName?: string;
+    index: number;
+    offset: number;
+    start?: number;
+    end?: number;
+}
+export declare function moveTo(self: ViewSnap & {
+    zoomTo: (arg: number) => number;
+    scrollTo: (arg: number) => void;
+}, start?: BpOffset, end?: BpOffset): void;
+export declare function pxToBp(self: ViewSnap, px: number): {
+    coord: number;
+    index: number;
+    refName: string;
+    oob: boolean;
+    assemblyName: string;
+    offset: number;
+    start: number;
+    end: number;
+    reversed: boolean;
+};
+export declare function bpToPx({ refName, coord, regionNumber, self, }: {
+    refName: string;
+    coord: number;
+    regionNumber?: number;
+    self: ViewSnap;
+}): {
+    index: number;
+    offsetPx: number;
+} | undefined;

package/util/Base1DUtils.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bpToPx = bpToPx;
+exports.moveTo = moveTo;
+exports.pxToBp = pxToBp;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+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 lengthBetween(self, start, end) {
+  var bpSoFar = 0;
+  var displayedRegions = self.displayedRegions;
+
+  if (start.index === end.index) {
+    bpSoFar += end.offset - start.offset;
+  } else {
+    var s = displayedRegions[start.index];
+    bpSoFar += s.end - s.start - start.offset;
+
+    if (end.index - start.index >= 2) {
+      for (var i = start.index + 1; i < end.index; i++) {
+        var region = displayedRegions[i];
+        var len = region.end - region.start;
+        bpSoFar += len;
+      }
+    }
+
+    bpSoFar += end.offset;
+  }
+
+  return bpSoFar;
+}
+
+function moveTo(self, start, end) {
+  if (!start || !end) {
+    return;
+  }
+
+  var width = self.width,
+      interRegionPaddingWidth = self.interRegionPaddingWidth;
+  var len = lengthBetween(self, start, end);
+  var numBlocks = end.index - start.index;
+  var targetBpPerPx = len / (width - interRegionPaddingWidth * numBlocks);
+  var newBpPerPx = self.zoomTo(targetBpPerPx); // If our target bpPerPx was smaller than the allowed minBpPerPx, adjust
+  // the scroll so the requested range is in the middle of the screen
+
+  var extraBp = 0;
+
+  if (targetBpPerPx < newBpPerPx) {
+    extraBp = (newBpPerPx - targetBpPerPx) * self.width / 2;
+  }
+
+  var bpToStart = -extraBp;
+
+  for (var i = 0; i < self.displayedRegions.length; i += 1) {
+    var region = self.displayedRegions[i];
+
+    if (start.index === i) {
+      bpToStart += start.offset;
+      break;
+    } else {
+      bpToStart += region.end - region.start;
+    }
+  }
+
+  self.scrollTo(Math.round(bpToStart / self.bpPerPx));
+} // manual return type since getSnapshot hard to infer here
+
+
+function pxToBp(self, px) {
+  var bpSoFar = 0;
+  var bpPerPx = self.bpPerPx,
+      offsetPx = self.offsetPx,
+      displayedRegions = self.displayedRegions,
+      interRegionPaddingWidth = self.interRegionPaddingWidth,
+      staticBlocks = self.staticBlocks;
+  var blocks = staticBlocks.contentBlocks;
+  var bp = (offsetPx + px) * bpPerPx;
+
+  if (bp < 0) {
+    var region = displayedRegions[0];
+    var snap = (0, _mobxStateTree.getSnapshot)(region); // @ts-ignore
+
+    return _objectSpread(_objectSpread({}, snap), {}, {
+      oob: true,
+      coord: region.reversed ? Math.floor(region.end - bp) + 1 : Math.floor(region.start + bp) + 1,
+      offset: bp,
+      index: 0
+    });
+  }
+
+  var interRegionPaddingBp = interRegionPaddingWidth * bpPerPx;
+  var currBlock = 0;
+
+  for (var i = 0; i < displayedRegions.length; i++) {
+    var _blocks$currBlock;
+
+    var _region = displayedRegions[i];
+    var len = _region.end - _region.start;
+    var offset = bp - bpSoFar;
+
+    if (len + bpSoFar > bp && bpSoFar <= bp) {
+      var _snap = (0, _mobxStateTree.getSnapshot)(_region); // @ts-ignore
+
+
+      return _objectSpread(_objectSpread({}, _snap), {}, {
+        oob: false,
+        offset: offset,
+        coord: _region.reversed ? Math.floor(_region.end - offset) + 1 : Math.floor(_region.start + offset) + 1,
+        index: i
+      });
+    } // add the interRegionPaddingWidth if the boundary is in the screen e.g. in
+    // a static block
+
+
+    if (((_blocks$currBlock = blocks[currBlock]) === null || _blocks$currBlock === void 0 ? void 0 : _blocks$currBlock.regionNumber) === i) {
+      bpSoFar += len + interRegionPaddingBp;
+      currBlock++;
+    } else {
+      bpSoFar += len;
+    }
+  }
+
+  if (bp >= bpSoFar) {
+    var _region2 = displayedRegions[displayedRegions.length - 1];
+
+    var _len = _region2.end - _region2.start;
+
+    var _offset = bp - bpSoFar + _len;
+
+    var _snap2 = (0, _mobxStateTree.getSnapshot)(_region2); // @ts-ignore
+
+
+    return _objectSpread(_objectSpread({}, _snap2), {}, {
+      oob: true,
+      offset: _offset,
+      coord: _region2.reversed ? Math.floor(_region2.end - _offset) + 1 : Math.floor(_region2.start + _offset) + 1,
+      index: displayedRegions.length - 1
+    });
+  }
+
+  return {
+    coord: 0,
+    index: 0,
+    refName: '',
+    oob: true,
+    assemblyName: '',
+    offset: 0,
+    start: 0,
+    end: 0,
+    reversed: false
+  };
+}
+
+function bpToPx(_ref) {
+  var refName = _ref.refName,
+      coord = _ref.coord,
+      regionNumber = _ref.regionNumber,
+      self = _ref.self;
+  var bpSoFar = 0;
+  var interRegionPaddingWidth = self.interRegionPaddingWidth,
+      bpPerPx = self.bpPerPx,
+      displayedRegions = self.displayedRegions,
+      staticBlocks = self.staticBlocks;
+  var blocks = staticBlocks.contentBlocks;
+  var interRegionPaddingBp = interRegionPaddingWidth * bpPerPx;
+  var currBlock = 0;
+  var i = 0;
+
+  for (; i < displayedRegions.length; i++) {
+    var _blocks$currBlock2;
+
+    var region = displayedRegions[i];
+    var len = region.end - region.start;
+
+    if (refName === region.refName && coord >= region.start && coord <= region.end) {
+      if (regionNumber ? regionNumber === i : true) {
+        bpSoFar += region.reversed ? region.end - coord : coord - region.start;
+        break;
+      }
+    } // add the interRegionPaddingWidth if the boundary is in the screen e.g. in
+    // a static block
+
+
+    if (((_blocks$currBlock2 = blocks[currBlock]) === null || _blocks$currBlock2 === void 0 ? void 0 : _blocks$currBlock2.regionNumber) === i) {
+      bpSoFar += len + interRegionPaddingBp;
+      currBlock++;
+    } else {
+      bpSoFar += len;
+    }
+  }
+
+  var found = displayedRegions[i];
+
+  if (found) {
+    return {
+      index: i,
+      offsetPx: Math.round(bpSoFar / bpPerPx)
+    };
+  }
+
+  return undefined;
+}

package/util/Base1DViewModel.d.ts

@@ -1,13 +1,7 @@
 import { Instance } from 'mobx-state-tree';
 import { Feature } from './simpleFeature';
 import { Region as IRegion } from './types';
-export interface BpOffset {
-    refName?: string;
-    index: number;
-    offset: number;
-    start?: number;
-    end?: number;
-}
+import { BpOffset } from './Base1DUtils';
 declare const Base1DView: import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     displayedRegions: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
@@ -38,30 +32,22 @@ declare const Base1DView: import("mobx-state-tree").IModelType<{
     readonly maxOffset: number;
     readonly minOffset: number;
     readonly totalBp: number;
+} & {
+    readonly dynamicBlocks: import("./blockTypes").BlockSet;
+    readonly staticBlocks: import("./blockTypes").BlockSet;
+    readonly currBp: number;
+} & {
     pxToBp(px: number): {
-        oob: boolean;
         coord: number;
-        offset: number;
         index: number;
         refName: string;
-        start: number;
-        end: number;
-        reversed: boolean;
-        assemblyName: string;
-    } | {
-        coord: number;
-        index: number;
-        start: number;
-        refName: string;
         oob: boolean;
         assemblyName: string;
         offset: number;
+        start: number;
+        end: number;
         reversed: boolean;
     };
-} & {
-    readonly dynamicBlocks: import("./blockTypes").BlockSet;
-    readonly staticBlocks: import("./blockTypes").BlockSet;
-    readonly currBp: number;
     bpToPx({ refName, coord, regionNumber, }: {
         refName: string;
         coord: number;
@@ -69,8 +55,14 @@ declare const Base1DView: import("mobx-state-tree").IModelType<{
     }): number | undefined;
 } & {
     setFeatures(features: Feature[]): void;
-    zoomToDisplayedRegions(leftPx: BpOffset | undefined, rightPx: BpOffset | undefined): void;
     showAllRegions(): void;
+    zoomOut(): void;
+    zoomIn(): void;
+    zoomTo(newBpPerPx: number, offset?: number): number;
+    scrollTo(offsetPx: number): number;
+    centerAt(coord: number, refName: string | undefined, regionNumber: number): void;
+    scroll(distance: number): number;
+} & {
     /**
      * offset is the base-pair-offset in the displayed region, index is the index of the
      * displayed region in the linear genome view
@@ -78,13 +70,7 @@ declare const Base1DView: import("mobx-state-tree").IModelType<{
      * @param start - object as `{start, end, offset, index}`
      * @param end - object as `{start, end, offset, index}`
      */
-    moveTo(start: BpOffset, end: BpOffset): void;
-    zoomOut(): void;
-    zoomIn(): void;
-    zoomTo(newBpPerPx: number, offset?: number): void;
-    scrollTo(offsetPx: number): number;
-    centerAt(coord: number, refName: string, regionNumber: number): void;
-    scroll(distance: number): number;
+    moveTo(start?: BpOffset, end?: BpOffset): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export declare type Base1DViewStateModel = typeof Base1DView;
 export declare type Base1DViewModel = Instance<Base1DViewStateModel>;

package/util/Base1DViewModel.js

@@ -7,8 +7,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var _mobxStateTree = require("mobx-state-tree");
@@ -21,9 +19,7 @@ var _calculateDynamicBlocks = _interopRequireDefault(require("./calculateDynamic
 
 var _calculateStaticBlocks = _interopRequireDefault(require("./calculateStaticBlocks"));
 
-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; }
+var _Base1DUtils = require("./Base1DUtils");
 
 var Base1DView = _mobxStateTree.types.model('Base1DView', {
   id: _mst.ElementId,
@@ -83,82 +79,8 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
       }).reduce(function (a, b) {
         return a + b;
       }, 0);
-    },
-
-    pxToBp: function pxToBp(px) {
-      var bpSoFar = 0;
-      var bp = (self.offsetPx + px) * self.bpPerPx;
-      var n = self.displayedRegions.length;
-
-      if (bp < 0) {
-        var region = self.displayedRegions[0];
-        var offset = bp;
-        var snap = (0, _mobxStateTree.getSnapshot)(region);
-        return _objectSpread(_objectSpread({}, snap), {}, {
-          oob: true,
-          coord: region.reversed ? Math.floor(region.end - offset) + 1 : Math.floor(region.start + offset) + 1,
-          offset: offset,
-          index: 0
-        });
-      }
-
-      var interRegionPaddingBp = self.interRegionPaddingWidth * self.bpPerPx;
-      var minimumBlockBp = self.minimumBlockWidth * self.bpPerPx;
-
-      for (var index = 0; index < self.displayedRegions.length; index += 1) {
-        var _region = self.displayedRegions[index];
-        var len = _region.end - _region.start;
-
-        var _offset = bp - bpSoFar;
-
-        if (len + bpSoFar > bp && bpSoFar <= bp) {
-          var _snap = (0, _mobxStateTree.getSnapshot)(_region);
-
-          return _objectSpread(_objectSpread({}, _snap), {}, {
-            oob: false,
-            offset: _offset,
-            coord: _region.reversed ? Math.floor(_region.end - _offset) + 1 : Math.floor(_region.start + _offset) + 1,
-            index: index
-          });
-        } // add the interRegionPaddingWidth if the boundary is in the screen
-        // e.g. offset>0 && offset<width
-
-
-        if (_region.end - _region.start > minimumBlockBp && _offset / self.bpPerPx > 0 && _offset / self.bpPerPx < this.width) {
-          bpSoFar += len + interRegionPaddingBp;
-        } else {
-          bpSoFar += len;
-        }
-      }
-
-      if (bp >= bpSoFar) {
-        var _region2 = self.displayedRegions[n - 1];
-
-        var _len = _region2.end - _region2.start;
-
-        var _offset2 = bp - bpSoFar + _len;
-
-        var _snap2 = (0, _mobxStateTree.getSnapshot)(_region2);
-
-        return _objectSpread(_objectSpread({}, _snap2), {}, {
-          oob: true,
-          offset: _offset2,
-          coord: _region2.reversed ? Math.floor(_region2.end - _offset2) + 1 : Math.floor(_region2.start + _offset2) + 1,
-          index: n - 1
-        });
-      }
-
-      return {
-        coord: 0,
-        index: 0,
-        start: 0,
-        refName: '',
-        oob: true,
-        assemblyName: '',
-        offset: 0,
-        reversed: false
-      };
     }
+
   };
 }).views(function (self) {
   return {
@@ -176,20 +98,26 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
       }).reduce(function (a, b) {
         return a + b;
       }, 0);
-    },
+    }
 
+  };
+}).views(function (self) {
+  return {
+    pxToBp: function pxToBp(px) {
+      return (0, _Base1DUtils.pxToBp)(self, px);
+    },
     bpToPx: function bpToPx(_ref) {
-      var _viewBpToPx;
+      var _bpToPx2;
 
       var refName = _ref.refName,
           coord = _ref.coord,
           regionNumber = _ref.regionNumber;
-      return (_viewBpToPx = (0, _index.viewBpToPx)({
+      return (_bpToPx2 = (0, _Base1DUtils.bpToPx)({
         refName: refName,
         coord: coord,
         regionNumber: regionNumber,
         self: self
-      })) === null || _viewBpToPx === void 0 ? void 0 : _viewBpToPx.offsetPx;
+      })) === null || _bpToPx2 === void 0 ? void 0 : _bpToPx2.offsetPx;
     }
   };
 }).actions(function (self) {
@@ -197,88 +125,12 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
     setFeatures: function setFeatures(features) {
       self.features = features;
     },
-    zoomToDisplayedRegions: function zoomToDisplayedRegions(leftPx, rightPx) {
-      if (leftPx === undefined || rightPx === undefined) {
-        return;
-      }
-
-      var singleRefSeq = leftPx.refName === rightPx.refName && leftPx.index === rightPx.index; // zooming into one displayed Region
-
-      if (singleRefSeq && rightPx.offset < leftPx.offset || leftPx.index > rightPx.index) {
-        ;
-        var _ref2 = [rightPx, leftPx];
-        leftPx = _ref2[0];
-        rightPx = _ref2[1];
-      }
-
-      var startOffset = {
-        start: leftPx.start,
-        end: leftPx.end,
-        index: leftPx.index,
-        offset: leftPx.offset
-      };
-      var endOffset = {
-        start: rightPx.start,
-        end: rightPx.end,
-        index: rightPx.index,
-        offset: rightPx.offset
-      };
-
-      if (startOffset && endOffset) {
-        this.moveTo(startOffset, endOffset);
-      } else {
-        throw new Error('regions not found');
-      }
-    },
     // this makes a zoomed out view that shows all displayedRegions
     // that makes the overview bar square with the scale bar
     showAllRegions: function showAllRegions() {
       self.bpPerPx = self.totalBp / self.width;
       self.offsetPx = 0;
     },
-
-    /**
-     * offset is the base-pair-offset in the displayed region, index is the index of the
-     * displayed region in the linear genome view
-     *
-     * @param start - object as `{start, end, offset, index}`
-     * @param end - object as `{start, end, offset, index}`
-     */
-    moveTo: function moveTo(start, end) {
-      // find locations in the modellist
-      var bpSoFar = 0;
-
-      if (start.index === end.index) {
-        bpSoFar += end.offset - start.offset;
-      } else {
-        var s = self.displayedRegions[start.index];
-        bpSoFar += s.end - s.start - start.offset;
-
-        if (end.index - start.index >= 2) {
-          for (var i = start.index + 1; i < end.index; i += 1) {
-            bpSoFar += self.displayedRegions[i].end - self.displayedRegions[i].start;
-          }
-        }
-
-        bpSoFar += end.offset;
-      }
-
-      this.zoomTo(bpSoFar / (self.width - self.interRegionPaddingWidth * (end.index - start.index)));
-      var bpToStart = 0;
-
-      for (var _i = 0; _i < self.displayedRegions.length; _i += 1) {
-        var region = self.displayedRegions[_i];
-
-        if (start.index === _i) {
-          bpToStart += start.offset;
-          break;
-        } else {
-          bpToStart += region.end - region.start;
-        }
-      }
-
-      self.offsetPx = Math.round(bpToStart / self.bpPerPx) + self.interRegionPaddingWidth * start.index;
-    },
     zoomOut: function zoomOut() {
       this.zoomTo(self.bpPerPx * 2);
     },
@@ -290,13 +142,14 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
       var bpPerPx = newBpPerPx;
 
       if (bpPerPx === self.bpPerPx) {
-        return;
+        return self.bpPerPx;
       }
 
       var oldBpPerPx = self.bpPerPx;
       self.bpPerPx = bpPerPx; // tweak the offset so that the center of the view remains at the same coordinate
 
       self.offsetPx = (0, _index.clamp)(Math.round((self.offsetPx + offset) * oldBpPerPx / bpPerPx - offset), self.minOffset, self.maxOffset);
+      return self.bpPerPx;
     },
     scrollTo: function scrollTo(offsetPx) {
       var newOffsetPx = (0, _index.clamp)(offsetPx, self.minOffset, self.maxOffset);
@@ -304,6 +157,10 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
       return newOffsetPx;
     },
     centerAt: function centerAt(coord, refName, regionNumber) {
+      if (!refName) {
+        return;
+      }
+
       var centerPx = self.bpToPx({
         refName: refName,
         coord: coord,
@@ -322,6 +179,19 @@ var Base1DView = _mobxStateTree.types.model('Base1DView', {
       return newOffsetPx - oldOffsetPx;
     }
   };
+}).actions(function (self) {
+  return {
+    /**
+     * offset is the base-pair-offset in the displayed region, index is the index of the
+     * displayed region in the linear genome view
+     *
+     * @param start - object as `{start, end, offset, index}`
+     * @param end - object as `{start, end, offset, index}`
+     */
+    moveTo: function moveTo(start, end) {
+      (0, _Base1DUtils.moveTo)(self, start, end);
+    }
+  };
 });
 
 var _default = Base1DView;

package/util/index.d.ts

@@ -1,7 +1,8 @@
-import { IAnyStateTreeNode } from 'mobx-state-tree';
+import { IAnyStateTreeNode, IStateTreeNode } from 'mobx-state-tree';
 import { IReactionPublic, IReactionOptions } from 'mobx';
 import SimpleFeature, { Feature, isFeature } from './simpleFeature';
 import { AssemblyManager, Region, TypeTestedByPredicate } from './types';
+import { BaseBlock } from './blockTypes';
 export type { Feature };
 export * from './types';
 export * from './aborting';
@@ -318,22 +319,19 @@ export declare type ViewSnap = {
     interRegionPaddingWidth: number;
     minimumBlockWidth: number;
     width: number;
-    displayedRegions: {
+    offsetPx: number;
+    staticBlocks: {
+        contentBlocks: BaseBlock[];
+        blocks: BaseBlock[];
+    };
+    displayedRegions: (IStateTreeNode & {
         start: number;
         end: number;
         refName: string;
         reversed: boolean;
-    }[];
+        assemblyName: string;
+    })[];
 };
-export declare function viewBpToPx({ refName, coord, regionNumber, self, }: {
-    refName: string;
-    coord: number;
-    regionNumber?: number;
-    self: ViewSnap;
-}): {
-    index: number;
-    offsetPx: number;
-} | undefined;
 export declare function supportedIndexingAdapters(type: string): boolean;
 export declare function getBpDisplayStr(totalBp: number): string;
 export declare function toLocale(n: number): string;