@jbrowse/plugin-wiggle 1.6.7 → 1.7.0

package/dist/util.js

@@ -0,0 +1,178 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNiceDomain = getNiceDomain;
+exports.getOrigin = getOrigin;
+exports.getScale = getScale;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _d3Scale = require("d3-scale");
+
+/**
+ * produces a d3-scale from arguments. applies a "nice domain" adjustment
+ *
+ * @param object - containing attributes
+ *   - domain [min,max]
+ *   - range [min,max]
+ *   - bounds [min,max]
+ *   - scaleType (linear or log)
+ *   - pivotValue (number)
+ *   - inverted (boolean)
+ */
+function getScale(_ref) {
+  var _ref$domain = _ref.domain,
+      domain = _ref$domain === void 0 ? [] : _ref$domain,
+      _ref$range = _ref.range,
+      range = _ref$range === void 0 ? [] : _ref$range,
+      scaleType = _ref.scaleType,
+      pivotValue = _ref.pivotValue,
+      inverted = _ref.inverted;
+  var scale;
+
+  var _domain = (0, _slicedToArray2["default"])(domain, 2),
+      min = _domain[0],
+      max = _domain[1];
+
+  if (min === undefined || max === undefined) {
+    throw new Error('invalid domain');
+  }
+
+  if (scaleType === 'linear') {
+    scale = (0, _d3Scale.scaleLinear)();
+  } else if (scaleType === 'log') {
+    scale = (0, _d3Scale.scaleLog)();
+    scale.base(2);
+  } else if (scaleType === 'quantize') {
+    scale = (0, _d3Scale.scaleQuantize)();
+  } else {
+    throw new Error('undefined scaleType');
+  }
+
+  scale.domain(pivotValue !== undefined ? [min, pivotValue, max] : [min, max]);
+  scale.nice();
+
+  var _range = (0, _slicedToArray2["default"])(range, 2),
+      rangeMin = _range[0],
+      rangeMax = _range[1];
+
+  if (rangeMin === undefined || rangeMax === undefined) {
+    throw new Error('invalid range');
+  }
+
+  scale.range(inverted ? range.slice().reverse() : range);
+  return scale;
+}
+/**
+ * gets the origin for drawing the graph. for linear this is 0, for log this is arbitrarily set to log(1)==0
+ *
+ * @param scaleType -
+ */
+
+
+function getOrigin(scaleType) {
+  // if (pivot) {
+  //   if (pivot === 'mean') {
+  //     return stats.scoreMean || 0
+  //   }
+  //   if (pivot === 'zero') {
+  //     return 0
+  //   }
+  //   return parseFloat()
+  // }
+  // if (scaleType === 'z_score') {
+  //   return stats.scoreMean || 0
+  // }
+  if (scaleType === 'log') {
+    return 1;
+  }
+
+  return 0;
+}
+/**
+ * produces a "nice" domain that actually rounds down to 0 for the min
+ * or 0 to the max depending on if all values are positive or negative
+ *
+ * @param object - containing attributes
+ *   - domain [min,max]
+ *   - bounds [min,max]
+ *   - mean
+ *   - stddev
+ *   - scaleType (linear or log)
+ */
+
+
+function getNiceDomain(_ref2) {
+  var scaleType = _ref2.scaleType,
+      domain = _ref2.domain,
+      bounds = _ref2.bounds;
+
+  var _bounds = (0, _slicedToArray2["default"])(bounds, 2),
+      minScore = _bounds[0],
+      maxScore = _bounds[1];
+
+  var _domain2 = (0, _slicedToArray2["default"])(domain, 2),
+      min = _domain2[0],
+      max = _domain2[1];
+
+  if (scaleType === 'linear') {
+    if (max < 0) {
+      max = 0;
+    }
+
+    if (min > 0) {
+      min = 0;
+    }
+  }
+
+  if (scaleType === 'log') {
+    // if the min is 0, assume that it's just something
+    // with no read coverage and that we should ignore it in calculations
+    // if it's greater than 1 pin to 1 for the full range also
+    // otherwise, we may see bigwigs with fractional values
+    if (min === 0 || min > 1) {
+      min = 1;
+    }
+  }
+
+  if (min === undefined || max === undefined) {
+    throw new Error('invalid domain supplied to stats function');
+  }
+
+  if (minScore !== undefined && minScore !== Number.MIN_VALUE) {
+    min = minScore;
+  }
+
+  if (maxScore !== undefined && maxScore !== Number.MAX_VALUE) {
+    max = maxScore;
+  }
+
+  var getScaleType = function getScaleType(type) {
+    if (type === 'linear') {
+      return (0, _d3Scale.scaleLinear)();
+    }
+
+    if (type === 'log') {
+      var _scale = (0, _d3Scale.scaleLog)();
+
+      _scale.base(2);
+
+      return _scale;
+    }
+
+    if (type === 'quantize') {
+      return (0, _d3Scale.scaleQuantize)();
+    }
+
+    throw new Error("undefined scaleType ".concat(type));
+  };
+
+  var scale = getScaleType(scaleType);
+  scale.domain([min, max]);
+  scale.nice();
+  return scale.domain();
+}

package/dist/util.test.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _util = require("./util");
+
+test('linear scale', function () {
+  var scaleType = 'linear';
+  var domain = [0, 100];
+  var range = [0, 100];
+  var scale = (0, _util.getScale)({
+    scaleType: scaleType,
+    domain: domain,
+    range: range
+  });
+  expect(scale.domain()).toEqual(domain);
+});
+test('log scale', function () {
+  var scaleType = 'log';
+  var domain = [1, 100];
+  var range = [0, 100];
+  var scale = (0, _util.getScale)({
+    scaleType: scaleType,
+    domain: domain,
+    range: range
+  });
+  expect(scale.domain()).toEqual([1, 128]);
+});
+test('test inverted', function () {
+  var scaleType = 'log';
+  var inverted = true;
+  var domain = [1, 100];
+  var range = [0, 100];
+  var scale = (0, _util.getScale)({
+    scaleType: scaleType,
+    domain: domain,
+    range: range,
+    inverted: inverted
+  });
+  expect(scale.domain()).toEqual([1, 128]);
+  expect(scale.range()).toEqual(range.reverse());
+});
+test('test minScore', function () {
+  var scaleType = 'linear';
+  var domain = [0, 100];
+  var range = [0, 100];
+  var bounds = [50, undefined];
+  var ret = (0, _util.getNiceDomain)({
+    scaleType: scaleType,
+    domain: domain,
+    range: range,
+    bounds: bounds
+  });
+  expect(ret).toEqual([50, 100]);
+});
+test('test min and max score', function () {
+  var scaleType = 'linear';
+  var domain = [1, 100];
+  var range = [0, 100];
+  var bounds = [undefined, 70];
+  var ret = (0, _util.getNiceDomain)({
+    scaleType: scaleType,
+    domain: domain,
+    range: range,
+    bounds: bounds
+  });
+  expect(ret).toEqual([0, 70]);
+});

package/package.json

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

package/src/LinearWiggleDisplay/components/Tooltip.tsx

@@ -40,7 +40,7 @@ const useStyles = makeStyles(theme => ({
     border: 'none',
     width: 1,
     height: '100%',
-    top: 0,
+    top: YSCALEBAR_LABEL_OFFSET,
     cursor: 'default',
     position: 'absolute',
     pointerEvents: 'none',

package/src/LinearWiggleDisplay/models/model.tsx

@@ -558,7 +558,7 @@ const stateModelFactory = (
           try {
             stats = await getStats({
               signal: aborter.signal,
-              filters: self.filters,
+              ...self.renderProps(),
             })
             if (isAlive(self)) {
               self.updateStats(stats)
@@ -591,7 +591,7 @@ const stateModelFactory = (
 
                   const wiggleStats = await getStats({
                     signal: aborter.signal,
-                    filters: self.filters,
+                    ...self.renderProps(),
                   })
 
                   if (isAlive(self)) {

package/src/WiggleBaseRenderer.tsx

@@ -69,6 +69,7 @@ export default abstract class WiggleBaseRenderer extends FeatureRendererType {
       ...results,
       ...res,
       features,
+      containsNoTransferables: true,
       height,
       width,
     }