@jbrowse/plugin-wiggle 1.6.8 → 1.7.1

package/dist/index.js

@@ -1,8 +1,253 @@
+"use strict";
 
-'use strict'
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./plugin-wiggle.cjs.production.min.js')
-} else {
-  module.exports = require('./plugin-wiggle.cjs.development.js')
-}
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  WiggleBaseRenderer: true,
+  WiggleRendering: true,
+  linearWiggleDisplayModelFactory: true,
+  LinearWiggleDisplayReactComponent: true,
+  YSCALEBAR_LABEL_OFFSET: true,
+  Tooltip: true
+};
+Object.defineProperty(exports, "LinearWiggleDisplayReactComponent", {
+  enumerable: true,
+  get: function get() {
+    return _LinearWiggleDisplay.ReactComponent;
+  }
+});
+Object.defineProperty(exports, "Tooltip", {
+  enumerable: true,
+  get: function get() {
+    return _Tooltip.Tooltip;
+  }
+});
+Object.defineProperty(exports, "WiggleBaseRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _WiggleBaseRenderer["default"];
+  }
+});
+Object.defineProperty(exports, "WiggleRendering", {
+  enumerable: true,
+  get: function get() {
+    return _WiggleRendering["default"];
+  }
+});
+Object.defineProperty(exports, "YSCALEBAR_LABEL_OFFSET", {
+  enumerable: true,
+  get: function get() {
+    return _LinearWiggleDisplay.YSCALEBAR_LABEL_OFFSET;
+  }
+});
+exports["default"] = void 0;
+Object.defineProperty(exports, "linearWiggleDisplayModelFactory", {
+  enumerable: true,
+  get: function get() {
+    return _LinearWiggleDisplay.modelFactory;
+  }
+});
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _AdapterType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/AdapterType"));
+
+var _TrackType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/TrackType"));
+
+var _Plugin2 = _interopRequireDefault(require("@jbrowse/core/Plugin"));
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _models = require("@jbrowse/core/pluggableElementTypes/models");
+
+var _DisplayType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/DisplayType"));
+
+var _WiggleBaseRenderer = _interopRequireDefault(require("./WiggleBaseRenderer"));
+
+var _WiggleRendering = _interopRequireDefault(require("./WiggleRendering"));
+
+var _BigWigAdapter = require("./BigWigAdapter");
+
+var _DensityRenderer = _interopRequireWildcard(require("./DensityRenderer"));
+
+var utils = _interopRequireWildcard(require("./util"));
+
+Object.keys(utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return utils[key];
+    }
+  });
+});
+
+var _LinearWiggleDisplay = require("./LinearWiggleDisplay");
+
+var _XYPlotRenderer = _interopRequireWildcard(require("./XYPlotRenderer"));
+
+var _LinePlotRenderer = _interopRequireWildcard(require("./LinePlotRenderer"));
+
+var _rpcMethods = require("./WiggleRPC/rpcMethods");
+
+var _tracks = require("@jbrowse/core/util/tracks");
+
+var _Tooltip = require("./LinearWiggleDisplay/components/Tooltip");
+
+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 || _typeof(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; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var WigglePlugin = /*#__PURE__*/function (_Plugin) {
+  (0, _inherits2["default"])(WigglePlugin, _Plugin);
+
+  var _super = _createSuper(WigglePlugin);
+
+  function WigglePlugin() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, WigglePlugin);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "name", 'WigglePlugin');
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "exports", {
+      LinearWiggleDisplayReactComponent: _LinearWiggleDisplay.ReactComponent,
+      XYPlotRendererReactComponent: _XYPlotRenderer.ReactComponent,
+      XYPlotRenderer: _XYPlotRenderer["default"],
+      xyPlotRendererConfigSchema: _XYPlotRenderer.configSchema,
+      utils: utils,
+      WiggleBaseRenderer: _WiggleBaseRenderer["default"],
+      linearWiggleDisplayModelFactory: _LinearWiggleDisplay.modelFactory
+    });
+    return _this;
+  }
+
+  (0, _createClass2["default"])(WigglePlugin, [{
+    key: "install",
+    value: function install(pluginManager) {
+      pluginManager.addTrackType(function () {
+        var configSchema = (0, _configuration.ConfigurationSchema)('QuantitativeTrack', {}, {
+          baseConfiguration: (0, _models.createBaseTrackConfig)(pluginManager)
+        });
+        return new _TrackType["default"]({
+          name: 'QuantitativeTrack',
+          configSchema: configSchema,
+          stateModel: (0, _models.createBaseTrackModel)(pluginManager, 'QuantitativeTrack', configSchema)
+        });
+      });
+      pluginManager.addDisplayType(function () {
+        var configSchema = (0, _LinearWiggleDisplay.configSchemaFactory)(pluginManager);
+        return new _DisplayType["default"]({
+          name: 'LinearWiggleDisplay',
+          configSchema: configSchema,
+          stateModel: (0, _LinearWiggleDisplay.modelFactory)(pluginManager, configSchema),
+          trackType: 'QuantitativeTrack',
+          viewType: 'LinearGenomeView',
+          ReactComponent: _LinearWiggleDisplay.ReactComponent
+        });
+      });
+      pluginManager.addAdapterType(function () {
+        return new _AdapterType["default"]({
+          name: 'BigWigAdapter',
+          configSchema: _BigWigAdapter.configSchema,
+          adapterCapabilities: ['hasResolution', 'hasLocalStats', 'hasGlobalStats'],
+          getAdapterClass: function getAdapterClass() {
+            return Promise.resolve().then(function () {
+              return _interopRequireWildcard(require('./BigWigAdapter/BigWigAdapter'));
+            }).then(function (r) {
+              return r["default"];
+            });
+          }
+        });
+      });
+      pluginManager.addToExtensionPoint('Core-guessAdapterForLocation', function (adapterGuesser) {
+        return function (file, index, adapterHint) {
+          var regexGuess = /\.(bw|bigwig)$/i;
+          var adapterName = 'BigWigAdapter';
+          var fileName = (0, _tracks.getFileName)(file);
+          var obj = {
+            type: adapterName,
+            bigWigLocation: file
+          };
+
+          if (regexGuess.test(fileName) && !adapterHint) {
+            return obj;
+          } else if (adapterHint === adapterName) {
+            return obj;
+          }
+
+          return adapterGuesser(file, index, adapterHint);
+        };
+      });
+      pluginManager.addToExtensionPoint('Core-guessTrackTypeForLocation', function (trackTypeGuesser) {
+        return function (adapterName) {
+          if (adapterName === 'BigWigAdapter') {
+            return 'QuantitativeTrack';
+          }
+
+          return trackTypeGuesser(adapterName);
+        };
+      });
+      pluginManager.addRendererType(function () {
+        return new _DensityRenderer["default"]({
+          name: 'DensityRenderer',
+          ReactComponent: _DensityRenderer.ReactComponent,
+          configSchema: _DensityRenderer.configSchema,
+          pluginManager: pluginManager
+        });
+      });
+      pluginManager.addRendererType(function () {
+        return new _LinePlotRenderer["default"]({
+          name: 'LinePlotRenderer',
+          ReactComponent: _LinePlotRenderer.ReactComponent,
+          configSchema: _LinePlotRenderer.configSchema,
+          pluginManager: pluginManager
+        });
+      });
+      pluginManager.addRendererType(function () {
+        return new _XYPlotRenderer["default"]({
+          name: 'XYPlotRenderer',
+          ReactComponent: _XYPlotRenderer.ReactComponent,
+          configSchema: _XYPlotRenderer.configSchema,
+          pluginManager: pluginManager
+        });
+      });
+      pluginManager.addRpcMethod(function () {
+        return new _rpcMethods.WiggleGetGlobalStats(pluginManager);
+      });
+      pluginManager.addRpcMethod(function () {
+        return new _rpcMethods.WiggleGetMultiRegionStats(pluginManager);
+      });
+    }
+  }]);
+  return WigglePlugin;
+}(_Plugin2["default"]);
+
+exports["default"] = WigglePlugin;

package/dist/index.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _PluginManager = _interopRequireDefault(require("@jbrowse/core/PluginManager"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _ = _interopRequireDefault(require("."));
+
+test('plugin in a stock JBrowse', function () {
+  console.warn = jest.fn();
+  var pluginManager = new _PluginManager["default"]([new _["default"]()]);
+  pluginManager.createPluggableElements();
+  pluginManager.configure();
+  expect(function () {
+    return pluginManager.addPlugin(new _["default"]());
+  }).toThrow(/JBrowse already configured, cannot add plugins/);
+  var BigWigAdapter = pluginManager.getAdapterType('BigWigAdapter');
+  var config = BigWigAdapter.configSchema.create({
+    type: 'BigWigAdapter'
+  });
+  expect((0, _mobxStateTree.getSnapshot)(config)).toMatchSnapshot();
+});

package/dist/util.d.ts

@@ -1,41 +1,41 @@
-export interface ScaleOpts {
-    domain: number[];
-    range: number[];
-    scaleType: string;
-    pivotValue?: number;
-    inverted: boolean;
-}
-/**
- * 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)
- */
-export declare function getScale({ domain, range, scaleType, pivotValue, inverted, }: ScaleOpts): import("d3-scale").ScaleLinear<number, number> | import("d3-scale").ScaleQuantize<number>;
-/**
- * gets the origin for drawing the graph. for linear this is 0, for log this is arbitrarily set to log(1)==0
- *
- * @param scaleType -
- */
-export declare function getOrigin(scaleType: string): 1 | 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)
- */
-export declare function getNiceDomain({ scaleType, domain, bounds, }: {
-    scaleType: string;
-    domain: number[];
-    bounds: number[];
-}): [number, number];
+export interface ScaleOpts {
+    domain: number[];
+    range: number[];
+    scaleType: string;
+    pivotValue?: number;
+    inverted: boolean;
+}
+/**
+ * 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)
+ */
+export declare function getScale({ domain, range, scaleType, pivotValue, inverted, }: ScaleOpts): import("d3-scale").ScaleLinear<number, number> | import("d3-scale").ScaleQuantize<number>;
+/**
+ * gets the origin for drawing the graph. for linear this is 0, for log this is arbitrarily set to log(1)==0
+ *
+ * @param scaleType -
+ */
+export declare function getOrigin(scaleType: string): 1 | 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)
+ */
+export declare function getNiceDomain({ scaleType, domain, bounds, }: {
+    scaleType: string;
+    domain: number[];
+    bounds: number[];
+}): [number, number];

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.8",
+  "version": "1.7.1",
   "description": "JBrowse 2 wiggle adapters, tracks, etc.",
   "keywords": [
     "jbrowse",
@@ -18,15 +18,13 @@
   "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",
+    "postbuild": "tsc --build tsconfig.build.json",
     "test": "cd ../..; jest plugins/wiggle",
     "prepublishOnly": "yarn test",
     "prepack": "yarn build; yarn useDist",
@@ -60,5 +58,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "585e522096651ef4afb188366bb46d723439dc1b"
+  "gitHead": "6da232090c90f22ac96fd464c33082c89b8da14b"
 }

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,
     }

package/dist/DensityRenderer/DensityRenderer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/WiggleRendering.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/XYPlotRenderer/XYPlotRenderer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};