@jbrowse/plugin-alignments 1.6.9 → 1.7.3

package/dist/LinearPileupDisplay/model.js

@@ -0,0 +1,602 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _react = require("react");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _tracks = require("@jbrowse/core/util/tracks");
+
+var _util = require("@jbrowse/core/util");
+
+var _Visibility = _interopRequireDefault(require("@material-ui/icons/Visibility"));
+
+var _Icons = require("@jbrowse/core/ui/Icons");
+
+var _pluginLinearGenomeView = require("@jbrowse/plugin-linear-genome-view");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+
+var _MenuOpen = _interopRequireDefault(require("@material-ui/icons/MenuOpen"));
+
+var _Sort = _interopRequireDefault(require("@material-ui/icons/Sort"));
+
+var _Palette = _interopRequireDefault(require("@material-ui/icons/Palette"));
+
+var _ClearAll = _interopRequireDefault(require("@material-ui/icons/ClearAll"));
+
+var _mobx = require("mobx");
+
+var _LinearPileupDisplayBlurb = _interopRequireDefault(require("./components/LinearPileupDisplayBlurb"));
+
+var _shared = require("../shared");
+
+var _excluded = ["uniqueId"];
+
+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 _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 || (0, _typeof2["default"])(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; }
+
+var ColorByTagDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/ColorByTag'));
+  });
+});
+var FilterByTagDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/FilterByTag'));
+  });
+});
+var SortByTagDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/SortByTag'));
+  });
+});
+var SetFeatureHeightDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/SetFeatureHeight'));
+  });
+});
+var SetMaxHeightDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/SetMaxHeight'));
+  });
+});
+var ModificationsDlg = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require('./components/ColorByModifications'));
+  });
+}); // using a map because it preserves order
+
+var rendererTypes = new Map([['pileup', 'PileupRenderer'], ['svg', 'SvgFeatureRenderer']]);
+
+var stateModelFactory = function stateModelFactory(configSchema) {
+  return _mobxStateTree.types.compose('LinearPileupDisplay', _pluginLinearGenomeView.BaseLinearDisplay, _mobxStateTree.types.model({
+    type: _mobxStateTree.types.literal('LinearPileupDisplay'),
+    configuration: (0, _configuration.ConfigurationReference)(configSchema),
+    showSoftClipping: false,
+    featureHeight: _mobxStateTree.types.maybe(_mobxStateTree.types.number),
+    noSpacing: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    fadeLikelihood: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    trackMaxHeight: _mobxStateTree.types.maybe(_mobxStateTree.types.number),
+    mismatchAlpha: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    sortedBy: _mobxStateTree.types.maybe(_mobxStateTree.types.model({
+      type: _mobxStateTree.types.string,
+      pos: _mobxStateTree.types.number,
+      tag: _mobxStateTree.types.maybe(_mobxStateTree.types.string),
+      refName: _mobxStateTree.types.string,
+      assemblyName: _mobxStateTree.types.string
+    })),
+    colorBy: _mobxStateTree.types.maybe(_mobxStateTree.types.model({
+      type: _mobxStateTree.types.string,
+      tag: _mobxStateTree.types.maybe(_mobxStateTree.types.string),
+      extra: _mobxStateTree.types.frozen()
+    })),
+    filterBy: _mobxStateTree.types.optional(_mobxStateTree.types.model({
+      flagInclude: _mobxStateTree.types.optional(_mobxStateTree.types.number, 0),
+      flagExclude: _mobxStateTree.types.optional(_mobxStateTree.types.number, 1540),
+      readName: _mobxStateTree.types.maybe(_mobxStateTree.types.string),
+      tagFilter: _mobxStateTree.types.maybe(_mobxStateTree.types.model({
+        tag: _mobxStateTree.types.string,
+        value: _mobxStateTree.types.string
+      }))
+    }), {})
+  }))["volatile"](function () {
+    return {
+      colorTagMap: _mobx.observable.map({}),
+      modificationTagMap: _mobx.observable.map({}),
+      ready: false
+    };
+  }).actions(function (self) {
+    return {
+      setReady: function setReady(flag) {
+        self.ready = flag;
+      },
+      setMaxHeight: function setMaxHeight(n) {
+        self.trackMaxHeight = n;
+      },
+      setFeatureHeight: function setFeatureHeight(n) {
+        self.featureHeight = n;
+      },
+      setNoSpacing: function setNoSpacing(flag) {
+        self.noSpacing = flag;
+      },
+      setColorScheme: function setColorScheme(colorScheme) {
+        self.colorTagMap = _mobx.observable.map({}); // clear existing mapping
+
+        self.colorBy = (0, _mobxStateTree.cast)(colorScheme);
+        self.ready = false;
+      },
+      updateModificationColorMap: function updateModificationColorMap(uniqueModifications) {
+        var colorPalette = ['red', 'blue', 'green', 'orange', 'purple'];
+        uniqueModifications.forEach(function (value) {
+          if (!self.modificationTagMap.has(value)) {
+            var totalKeys = (0, _toConsumableArray2["default"])(self.modificationTagMap.keys()).length;
+            var newColor = colorPalette[totalKeys];
+            self.modificationTagMap.set(value, newColor);
+          }
+        });
+      },
+      updateColorTagMap: function updateColorTagMap(uniqueTag) {
+        // pale color scheme https://cran.r-project.org/web/packages/khroma/vignettes/tol.html e.g. "tol_light"
+        var colorPalette = ['#BBCCEE', 'pink', '#CCDDAA', '#EEEEBB', '#FFCCCC', 'lightblue', 'lightgreen', 'tan', '#CCEEFF', 'lightsalmon'];
+        uniqueTag.forEach(function (value) {
+          if (!self.colorTagMap.has(value)) {
+            var totalKeys = (0, _toConsumableArray2["default"])(self.colorTagMap.keys()).length;
+            var newColor = colorPalette[totalKeys];
+            self.colorTagMap.set(value, newColor);
+          }
+        });
+      }
+    };
+  }).actions(function (self) {
+    return {
+      afterAttach: function afterAttach() {
+        (0, _mobxStateTree.addDisposer)(self, (0, _mobx.autorun)( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+          var _getSession, rpcManager, sortedBy, colorBy, view, uniqueTagSet, uniqueModificationsSet, pos, refName, assemblyName, region;
+
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.prev = 0;
+                  _getSession = (0, _util.getSession)(self), rpcManager = _getSession.rpcManager;
+                  sortedBy = self.sortedBy, colorBy = self.colorBy;
+                  view = (0, _util.getContainingView)(self); // continually generate the vc pairing, set and rerender if any
+                  // new values seen
+
+                  if (!(colorBy !== null && colorBy !== void 0 && colorBy.tag)) {
+                    _context.next = 9;
+                    break;
+                  }
+
+                  _context.next = 7;
+                  return (0, _shared.getUniqueTagValues)(self, colorBy, view.staticBlocks);
+
+                case 7:
+                  uniqueTagSet = _context.sent;
+                  self.updateColorTagMap(uniqueTagSet);
+
+                case 9:
+                  if (!((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications')) {
+                    _context.next = 14;
+                    break;
+                  }
+
+                  _context.next = 12;
+                  return (0, _shared.getUniqueModificationValues)(self, (0, _configuration.getConf)(self.parentTrack, ['adapter']), colorBy, view.staticBlocks);
+
+                case 12:
+                  uniqueModificationsSet = _context.sent;
+                  self.updateModificationColorMap(uniqueModificationsSet);
+
+                case 14:
+                  if (!sortedBy) {
+                    _context.next = 23;
+                    break;
+                  }
+
+                  pos = sortedBy.pos, refName = sortedBy.refName, assemblyName = sortedBy.assemblyName;
+                  region = {
+                    start: pos,
+                    end: pos + 1,
+                    refName: refName,
+                    assemblyName: assemblyName
+                  }; // render just the sorted region first
+
+                  _context.next = 19;
+                  return self.rendererType.renderInClient(rpcManager, _objectSpread({
+                    assemblyName: assemblyName,
+                    regions: [region],
+                    adapterConfig: self.adapterConfig,
+                    rendererType: self.rendererType.name,
+                    sessionId: (0, _tracks.getRpcSessionId)(self),
+                    timeout: 1000000
+                  }, self.renderProps()));
+
+                case 19:
+                  self.setReady(true);
+                  self.setCurrBpPerPx(view.bpPerPx);
+                  _context.next = 24;
+                  break;
+
+                case 23:
+                  self.setReady(true);
+
+                case 24:
+                  _context.next = 30;
+                  break;
+
+                case 26:
+                  _context.prev = 26;
+                  _context.t0 = _context["catch"](0);
+                  console.error(_context.t0);
+                  self.setError(_context.t0);
+
+                case 30:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee, null, [[0, 26]]);
+        })), {
+          delay: 1000
+        }));
+      },
+      selectFeature: function selectFeature(feature) {
+        var session = (0, _util.getSession)(self);
+
+        if ((0, _util.isSessionModelWithWidgets)(session)) {
+          var featureWidget = session.addWidget('AlignmentsFeatureWidget', 'alignmentFeature', {
+            featureData: feature.toJSON(),
+            view: (0, _util.getContainingView)(self)
+          });
+          session.showWidget(featureWidget);
+        }
+
+        session.setSelection(feature);
+      },
+      clearSelected: function clearSelected() {
+        self.sortedBy = undefined;
+      },
+      // uses copy-to-clipboard and generates notification
+      copyFeatureToClipboard: function copyFeatureToClipboard(feature) {
+        var _feature$toJSON = feature.toJSON(),
+            uniqueId = _feature$toJSON.uniqueId,
+            rest = (0, _objectWithoutProperties2["default"])(_feature$toJSON, _excluded);
+
+        var session = (0, _util.getSession)(self);
+        (0, _copyToClipboard["default"])(JSON.stringify(rest, null, 4));
+        session.notify('Copied to clipboard', 'success');
+      },
+      toggleSoftClipping: function toggleSoftClipping() {
+        self.showSoftClipping = !self.showSoftClipping;
+      },
+      toggleMismatchAlpha: function toggleMismatchAlpha() {
+        self.mismatchAlpha = !self.mismatchAlpha;
+      },
+      setConfig: function setConfig(configuration) {
+        self.configuration = configuration;
+      },
+      setSortedBy: function setSortedBy(type, tag) {
+        var _ref2 = (0, _util.getContainingView)(self),
+            centerLineInfo = _ref2.centerLineInfo;
+
+        if (!centerLineInfo) {
+          return;
+        }
+
+        var refName = centerLineInfo.refName,
+            assemblyName = centerLineInfo.assemblyName,
+            offset = centerLineInfo.offset;
+        var centerBp = Math.round(offset) + 1;
+        var centerRefName = refName;
+
+        if (centerBp < 0) {
+          return;
+        }
+
+        self.sortedBy = {
+          type: type,
+          pos: centerBp,
+          refName: centerRefName,
+          assemblyName: assemblyName,
+          tag: tag
+        };
+        self.ready = false;
+      },
+      setFilterBy: function setFilterBy(filter) {
+        self.filterBy = (0, _mobxStateTree.cast)(filter);
+      }
+    };
+  }).actions(function (self) {
+    // resets the sort object and refresh whole display on reload
+    var superReload = self.reload;
+    return {
+      reload: function reload() {
+        self.clearSelected();
+        superReload();
+      }
+    };
+  }).views(function (self) {
+    return {
+      get maxHeight() {
+        var conf = (0, _configuration.getConf)(self, ['renderers', self.rendererTypeName]) || {};
+        return self.trackMaxHeight !== undefined ? self.trackMaxHeight : conf.maxHeight;
+      },
+
+      get rendererConfig() {
+        var configBlob = (0, _configuration.getConf)(self, ['renderers', self.rendererTypeName]) || {};
+        return self.rendererType.configSchema.create(_objectSpread(_objectSpread({}, configBlob), {}, {
+          height: self.featureHeight,
+          noSpacing: self.noSpacing,
+          maxHeight: this.maxHeight,
+          mismatchAlpha: self.mismatchAlpha
+        }), (0, _mobxStateTree.getEnv)(self));
+      },
+
+      get featureHeightSetting() {
+        return self.featureHeight || (0, _configuration.readConfObject)(this.rendererConfig, 'height');
+      },
+
+      get mismatchAlphaSetting() {
+        return self.mismatchAlpha !== undefined ? self.mismatchAlpha : (0, _configuration.readConfObject)(this.rendererConfig, 'mismatchAlpha');
+      }
+
+    };
+  }).views(function (self) {
+    var superTrackMenuItems = self.trackMenuItems,
+        superRenderProps = self.renderProps;
+    return {
+      get rendererTypeName() {
+        var viewName = (0, _configuration.getConf)(self, 'defaultRendering');
+        var rendererType = rendererTypes.get(viewName);
+
+        if (!rendererType) {
+          throw new Error("unknown alignments view name ".concat(viewName));
+        }
+
+        return rendererType;
+      },
+
+      contextMenuItems: function contextMenuItems() {
+        var feat = self.contextMenuFeature;
+        var contextMenuItems = feat ? [{
+          label: 'Open feature details',
+          icon: _MenuOpen["default"],
+          onClick: function onClick() {
+            self.clearFeatureSelection();
+
+            if (feat) {
+              self.selectFeature(feat);
+            }
+          }
+        }, {
+          label: 'Copy info to clipboard',
+          icon: _Icons.ContentCopy,
+          onClick: function onClick() {
+            if (feat) {
+              self.copyFeatureToClipboard(feat);
+            }
+          }
+        }] : [];
+        return contextMenuItems;
+      },
+
+      get DisplayBlurb() {
+        return _LinearPileupDisplayBlurb["default"];
+      },
+
+      renderProps: function renderProps() {
+        var view = (0, _util.getContainingView)(self);
+        var colorTagMap = self.colorTagMap,
+            modificationTagMap = self.modificationTagMap,
+            sortedBy = self.sortedBy,
+            colorBy = self.colorBy,
+            filterBy = self.filterBy,
+            rpcDriverName = self.rpcDriverName;
+        var superProps = superRenderProps();
+        return _objectSpread(_objectSpread({}, superProps), {}, {
+          notReady: superProps.notReady || !self.ready || sortedBy && self.currBpPerPx !== view.bpPerPx,
+          rpcDriverName: rpcDriverName,
+          displayModel: self,
+          sortedBy: sortedBy,
+          colorBy: colorBy,
+          filterBy: filterBy,
+          colorTagMap: JSON.parse(JSON.stringify(colorTagMap)),
+          modificationTagMap: JSON.parse(JSON.stringify(modificationTagMap)),
+          showSoftClip: self.showSoftClipping,
+          config: self.rendererConfig
+        });
+      },
+      trackMenuItems: function trackMenuItems() {
+        return [].concat((0, _toConsumableArray2["default"])(superTrackMenuItems()), [{
+          label: 'Show soft clipping',
+          icon: _Visibility["default"],
+          type: 'checkbox',
+          checked: self.showSoftClipping,
+          onClick: function onClick() {
+            self.toggleSoftClipping(); // if toggling from off to on, will break sort for this track
+            // so clear it
+
+            if (self.showSoftClipping) {
+              self.clearSelected();
+            }
+          }
+        }, {
+          label: 'Sort by',
+          icon: _Sort["default"],
+          disabled: self.showSoftClipping,
+          subMenu: [].concat((0, _toConsumableArray2["default"])(['Start location', 'Read strand', 'Base pair'].map(function (option) {
+            return {
+              label: option,
+              onClick: function onClick() {
+                return self.setSortedBy(option);
+              }
+            };
+          })), [{
+            label: 'Sort by tag...',
+            onClick: function onClick() {
+              (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+                return [SortByTagDlg, {
+                  model: self,
+                  handleClose: doneCallback
+                }];
+              });
+            }
+          }, {
+            label: 'Clear sort',
+            onClick: function onClick() {
+              return self.clearSelected();
+            }
+          }])
+        }, {
+          label: 'Color scheme',
+          icon: _Palette["default"],
+          subMenu: [{
+            label: 'Normal',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'normal'
+              });
+            }
+          }, {
+            label: 'Mapping quality',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'mappingQuality'
+              });
+            }
+          }, {
+            label: 'Strand',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'strand'
+              });
+            }
+          }, {
+            label: 'Pair orientation',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'pairOrientation'
+              });
+            }
+          }, {
+            label: 'Per-base quality',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'perBaseQuality'
+              });
+            }
+          }, {
+            label: 'Per-base lettering',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'perBaseLettering'
+              });
+            }
+          }, {
+            label: 'Modifications or methylation',
+            onClick: function onClick() {
+              (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+                return [ModificationsDlg, {
+                  model: self,
+                  handleClose: doneCallback
+                }];
+              });
+            }
+          }, {
+            label: 'Insert size',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'insertSize'
+              });
+            }
+          }, {
+            label: 'Stranded paired-end',
+            onClick: function onClick() {
+              self.setColorScheme({
+                type: 'reverseTemplate'
+              });
+            }
+          }, {
+            label: 'Color by tag...',
+            onClick: function onClick() {
+              (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+                return [ColorByTagDlg, {
+                  model: self,
+                  handleClose: doneCallback
+                }];
+              });
+            }
+          }]
+        }, {
+          label: 'Filter by',
+          icon: _ClearAll["default"],
+          onClick: function onClick() {
+            (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+              return [FilterByTagDlg, {
+                model: self,
+                handleClose: doneCallback
+              }];
+            });
+          }
+        }, {
+          label: 'Set feature height',
+          onClick: function onClick() {
+            (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+              return [SetFeatureHeightDlg, {
+                model: self,
+                handleClose: doneCallback
+              }];
+            });
+          }
+        }, {
+          label: 'Set max height',
+          onClick: function onClick() {
+            (0, _util.getSession)(self).queueDialog(function (doneCallback) {
+              return [SetMaxHeightDlg, {
+                model: self,
+                handleClose: doneCallback
+              }];
+            });
+          }
+        }, {
+          label: 'Fade mismatches by quality',
+          type: 'checkbox',
+          checked: self.mismatchAlphaSetting,
+          onClick: function onClick() {
+            self.toggleMismatchAlpha();
+          }
+        }]);
+      }
+    };
+  });
+};
+
+var _default = stateModelFactory;
+exports["default"] = _default;

package/dist/LinearSNPCoverageDisplay/components/Tooltip.d.ts

@@ -1,10 +1,10 @@
-/// <reference types="react" />
-declare type Coord = [number, number];
-declare const SNPCoverageTooltip: (props: {
-    model: any;
-    height: number;
-    offsetMouseCoord: Coord;
-    clientMouseCoord: Coord;
-    clientRect?: DOMRect;
-}) => JSX.Element | null;
-export default SNPCoverageTooltip;
+/// <reference types="react" />
+declare type Coord = [number, number];
+declare const SNPCoverageTooltip: (props: {
+    model: any;
+    height: number;
+    offsetMouseCoord: Coord;
+    clientMouseCoord: Coord;
+    clientRect?: DOMRect;
+}) => JSX.Element | null;
+export default SNPCoverageTooltip;

package/dist/LinearSNPCoverageDisplay/components/Tooltip.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _mobxReact = require("mobx-react");
+
+var _pluginWiggle = require("@jbrowse/plugin-wiggle");
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var en = function en(n) {
+  return n.toLocaleString('en-US');
+};
+
+var TooltipContents = /*#__PURE__*/_react["default"].forwardRef(function (_ref, ref) {
+  var feature = _ref.feature;
+  var start = feature.get('start');
+  var end = feature.get('end');
+  var name = feature.get('refName');
+  var info = feature.get('snpinfo');
+  var loc = [name, start === end ? en(start) : "".concat(en(start), "..").concat(en(end))].filter(function (f) {
+    return !!f;
+  }).join(':');
+  var total = info === null || info === void 0 ? void 0 : info.total;
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    ref: ref
+  }, /*#__PURE__*/_react["default"].createElement("table", null, /*#__PURE__*/_react["default"].createElement("caption", null, loc), /*#__PURE__*/_react["default"].createElement("thead", null, /*#__PURE__*/_react["default"].createElement("tr", null, /*#__PURE__*/_react["default"].createElement("th", null, "Base"), /*#__PURE__*/_react["default"].createElement("th", null, "Count"), /*#__PURE__*/_react["default"].createElement("th", null, "% of Total"), /*#__PURE__*/_react["default"].createElement("th", null, "Strands"), /*#__PURE__*/_react["default"].createElement("th", null, "Source"))), /*#__PURE__*/_react["default"].createElement("tbody", null, /*#__PURE__*/_react["default"].createElement("tr", null, /*#__PURE__*/_react["default"].createElement("td", null, "Total"), /*#__PURE__*/_react["default"].createElement("td", null, total), /*#__PURE__*/_react["default"].createElement("td", null)), Object.entries(info).map(function (_ref2) {
+    var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+        key = _ref3[0],
+        entry = _ref3[1];
+
+    return Object.entries(entry).map(function (_ref4) {
+      var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
+          base = _ref5[0],
+          score = _ref5[1];
+
+      var strands = score.strands;
+      return /*#__PURE__*/_react["default"].createElement("tr", {
+        key: base
+      }, /*#__PURE__*/_react["default"].createElement("td", null, base.toUpperCase()), /*#__PURE__*/_react["default"].createElement("td", null, score.total), /*#__PURE__*/_react["default"].createElement("td", null, base === 'total' || base === 'skip' ? '---' : "".concat(Math.floor(score.total / (total || score.total || 1) * 100), "%")), /*#__PURE__*/_react["default"].createElement("td", null, strands['-1'] ? "".concat(strands['-1'], "(-)") : '', strands['1'] ? "".concat(strands['1'], "(+)") : ''), /*#__PURE__*/_react["default"].createElement("td", null, key));
+    });
+  }))));
+});
+
+var SNPCoverageTooltip = (0, _mobxReact.observer)(function (props) {
+  var model = props.model;
+  var feat = model.featureUnderMouse;
+  return feat && feat.get('type') === 'skip' ? null : /*#__PURE__*/_react["default"].createElement(_pluginWiggle.Tooltip, (0, _extends2["default"])({
+    TooltipContents: TooltipContents
+  }, props));
+});
+var _default = SNPCoverageTooltip;
+exports["default"] = _default;

package/dist/LinearSNPCoverageDisplay/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-export default function register(pluginManager: PluginManager): void;
+import PluginManager from '@jbrowse/core/PluginManager';
+export default function register(pluginManager: PluginManager): void;