@jbrowse/plugin-alignments 1.6.7 → 1.7.0

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.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = register;
+
+var _configSchema = _interopRequireDefault(require("./models/configSchema"));
+
+var _model = _interopRequireDefault(require("./models/model"));
+
+var _pluginWiggle = require("@jbrowse/plugin-wiggle");
+
+var _DisplayType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/DisplayType"));
+
+function register(pluginManager) {
+  pluginManager.addDisplayType(function () {
+    var configSchema = (0, _configSchema["default"])(pluginManager);
+    return new _DisplayType["default"]({
+      name: 'LinearSNPCoverageDisplay',
+      configSchema: configSchema,
+      stateModel: (0, _model["default"])(pluginManager, configSchema),
+      trackType: 'AlignmentsTrack',
+      viewType: 'LinearGenomeView',
+      ReactComponent: _pluginWiggle.LinearWiggleDisplayReactComponent
+    });
+  });
+}

package/dist/LinearSNPCoverageDisplay/models/configSchema.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = SNPCoverageConfigFactory;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _pluginLinearGenomeView = require("@jbrowse/plugin-linear-genome-view");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+function SNPCoverageConfigFactory(pluginManager) {
+  var SNPCoverageRendererConfigSchema = pluginManager.getRendererType('SNPCoverageRenderer').configSchema;
+  return (0, _configuration.ConfigurationSchema)('LinearSNPCoverageDisplay', {
+    autoscale: {
+      type: 'stringEnum',
+      defaultValue: 'local',
+      model: _mobxStateTree.types.enumeration('Autoscale type', ['local']),
+      description: 'performs local autoscaling (no other options for SNP Coverage available)'
+    },
+    minScore: {
+      type: 'number',
+      defaultValue: Number.MIN_VALUE,
+      description: 'minimum value for the y-scale'
+    },
+    maxScore: {
+      type: 'number',
+      description: 'maximum value for the y-scale',
+      defaultValue: Number.MAX_VALUE
+    },
+    scaleType: {
+      type: 'stringEnum',
+      model: _mobxStateTree.types.enumeration('Scale type', ['linear', 'log']),
+      // todo zscale
+      description: 'The type of scale to use',
+      defaultValue: 'linear'
+    },
+    inverted: {
+      type: 'boolean',
+      description: 'draw upside down',
+      defaultValue: false
+    },
+    multiTicks: {
+      type: 'boolean',
+      description: 'Display multiple values for the ticks',
+      defaultValue: false
+    },
+    renderers: (0, _configuration.ConfigurationSchema)('RenderersConfiguration', {
+      SNPCoverageRenderer: SNPCoverageRendererConfigSchema
+    })
+  }, {
+    baseConfiguration: _pluginLinearGenomeView.baseLinearDisplayConfigSchema,
+    explicitlyTyped: true
+  });
+}

package/dist/LinearSNPCoverageDisplay/models/configSchema.test.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+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 _Plugin2 = _interopRequireDefault(require("@jbrowse/core/Plugin"));
+
+var _PluginManager = _interopRequireDefault(require("@jbrowse/core/PluginManager"));
+
+var _SNPCoverageRenderer = _interopRequireDefault(require("../../SNPCoverageRenderer"));
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));
+
+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; } }
+
+// mock warnings to avoid unnecessary outputs
+beforeEach(function () {
+  jest.spyOn(console, 'warn').mockImplementation(function () {});
+});
+afterEach(function () {
+  console.warn.mockRestore();
+}); // change renderer
+
+var SNPCoverageRendererPlugin = /*#__PURE__*/function (_Plugin) {
+  (0, _inherits2["default"])(SNPCoverageRendererPlugin, _Plugin);
+
+  var _super = _createSuper(SNPCoverageRendererPlugin);
+
+  function SNPCoverageRendererPlugin() {
+    (0, _classCallCheck2["default"])(this, SNPCoverageRendererPlugin);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(SNPCoverageRendererPlugin, [{
+    key: "install",
+    value: function install(pluginManager) {
+      (0, _SNPCoverageRenderer["default"])(pluginManager);
+    }
+  }]);
+  return SNPCoverageRendererPlugin;
+}(_Plugin2["default"]);
+
+test('has a type attr', function () {
+  var configSchema = (0, _configSchema["default"])(new _PluginManager["default"]([new SNPCoverageRendererPlugin()]).createPluggableElements().configure());
+  var config = configSchema.create({
+    type: 'LinearSNPCoverageDisplay',
+    displayId: 'display1',
+    name: 'SNPZonker Display'
+  });
+  expect(config.type).toEqual('LinearSNPCoverageDisplay');
+});

package/dist/LinearSNPCoverageDisplay/models/model.d.ts

@@ -26,7 +26,7 @@ declare const stateModelFactory: (pluginManager: PluginManager, configSchema: An
         renderInProgress: AbortController | undefined;
         filled: boolean;
         reactElement: import("react").ReactElement<any, string | ((props: any) => import("react").ReactElement<any, any> | null) | (new (props: any) => import("react").Component<any, any, any>)> | undefined;
-        features: Map<string, import("@jbrowse/core/util/simpleFeature").Feature> | undefined;
+        features: Map<string, import("@jbrowse/core/util").Feature> | undefined;
         layout: any;
         status: string;
         error: unknown;
@@ -44,7 +44,7 @@ declare const stateModelFactory: (pluginManager: PluginManager, configSchema: An
         setMessage(messageText: string): void;
         setRendered(props: {
             reactElement: import("react").ReactElement<any, string | ((props: any) => import("react").ReactElement<any, any> | null) | (new (props: any) => import("react").Component<any, any, any>)>;
-            features: Map<string, import("@jbrowse/core/util/simpleFeature").Feature>;
+            features: Map<string, import("@jbrowse/core/util").Feature>;
             layout: any;
             maxHeightReached: boolean;
             renderProps: any;

package/dist/LinearSNPCoverageDisplay/models/model.js

@@ -0,0 +1,237 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _mobx = require("mobx");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _pluginWiggle = require("@jbrowse/plugin-wiggle");
+
+var _util = require("@jbrowse/core/util");
+
+var _Tooltip = _interopRequireDefault(require("../components/Tooltip"));
+
+var _shared = require("../../shared");
+
+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; }
+
+// using a map because it preserves order
+var rendererTypes = new Map([['snpcoverage', 'SNPCoverageRenderer']]);
+
+var stateModelFactory = function stateModelFactory(pluginManager, configSchema) {
+  return _mobxStateTree.types.compose('LinearSNPCoverageDisplay', (0, _pluginWiggle.linearWiggleDisplayModelFactory)(pluginManager, configSchema), _mobxStateTree.types.model({
+    type: _mobxStateTree.types.literal('LinearSNPCoverageDisplay'),
+    drawInterbaseCounts: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    drawIndicators: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    drawArcs: _mobxStateTree.types.maybe(_mobxStateTree.types["boolean"]),
+    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
+      }))
+    }), {}),
+    colorBy: _mobxStateTree.types.maybe(_mobxStateTree.types.model({
+      type: _mobxStateTree.types.string,
+      tag: _mobxStateTree.types.maybe(_mobxStateTree.types.string)
+    }))
+  }))["volatile"](function () {
+    return {
+      modificationTagMap: _mobx.observable.map({})
+    };
+  }).actions(function (self) {
+    return {
+      setConfig: function setConfig(configuration) {
+        self.configuration = configuration;
+      },
+      setFilterBy: function setFilterBy(filter) {
+        self.filterBy = (0, _mobxStateTree.cast)(filter);
+      },
+      setColorBy: function setColorBy(colorBy) {
+        self.colorBy = (0, _mobxStateTree.cast)(colorBy);
+      },
+      updateModificationColorMap: function updateModificationColorMap(uniqueModifications) {
+        var colorPalette = ['red', 'blue', 'green', 'orange', 'purple'];
+        var i = 0;
+        uniqueModifications.forEach(function (value) {
+          if (!self.modificationTagMap.has(value)) {
+            var newColor = colorPalette[i++];
+            self.modificationTagMap.set(value, newColor);
+          }
+        });
+      }
+    };
+  }).views(function (self) {
+    var superRenderProps = self.renderProps;
+    return {
+      get rendererConfig() {
+        var configBlob = (0, _configuration.getConf)(self, ['renderers', self.rendererTypeName]) || {};
+        return self.rendererType.configSchema.create(_objectSpread(_objectSpread({}, configBlob), {}, {
+          drawInterbaseCounts: self.drawInterbaseCounts === undefined ? configBlob.drawInterbaseCounts : self.drawInterbaseCounts,
+          drawIndicators: self.drawIndicators === undefined ? configBlob.drawIndicators : self.drawIndicators,
+          drawArcs: self.drawArcs === undefined ? configBlob.drawArcs : self.drawArcs
+        }), (0, _mobxStateTree.getEnv)(self));
+      },
+
+      get drawArcsSetting() {
+        return self.drawArcs !== undefined ? self.drawArcs : (0, _configuration.readConfObject)(this.rendererConfig, 'drawArcs');
+      },
+
+      get drawInterbaseCountsSetting() {
+        return self.drawInterbaseCounts !== undefined ? self.drawInterbaseCounts : (0, _configuration.readConfObject)(this.rendererConfig, 'drawInterbaseCounts');
+      },
+
+      get drawIndicatorsSetting() {
+        return self.drawIndicators !== undefined ? self.drawIndicators : (0, _configuration.readConfObject)(this.rendererConfig, 'drawIndicators');
+      },
+
+      get modificationsReady() {
+        var _self$colorBy;
+
+        return ((_self$colorBy = self.colorBy) === null || _self$colorBy === void 0 ? void 0 : _self$colorBy.type) === 'modifications' ? Object.keys(JSON.parse(JSON.stringify(self.modificationTagMap))).length > 0 : true;
+      },
+
+      renderProps: function renderProps() {
+        var superProps = superRenderProps();
+        return _objectSpread(_objectSpread({}, superProps), {}, {
+          notReady: superProps.notReady || !this.modificationsReady,
+          modificationTagMap: JSON.parse(JSON.stringify(self.modificationTagMap)),
+          // must use getSnapshot because otherwise changes to e.g. just the
+          // colorBy.type are not read
+          colorBy: self.colorBy ? (0, _mobxStateTree.getSnapshot)(self.colorBy) : undefined,
+          filterBy: self.filterBy
+        });
+      }
+    };
+  }).actions(function (self) {
+    return {
+      toggleDrawIndicators: function toggleDrawIndicators() {
+        self.drawIndicators = !self.drawIndicatorsSetting;
+      },
+      toggleDrawInterbaseCounts: function toggleDrawInterbaseCounts() {
+        self.drawInterbaseCounts = !self.drawInterbaseCountsSetting;
+      },
+      toggleDrawArcs: function toggleDrawArcs() {
+        self.drawArcs = !self.drawArcsSetting;
+      },
+      afterAttach: function afterAttach() {
+        (0, _mobxStateTree.addDisposer)(self, (0, _mobx.autorun)( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+          var colorBy, _ref2, staticBlocks, vals;
+
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.prev = 0;
+                  colorBy = self.colorBy;
+                  _ref2 = (0, _util.getContainingView)(self), staticBlocks = _ref2.staticBlocks;
+
+                  if (!((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications')) {
+                    _context.next = 8;
+                    break;
+                  }
+
+                  _context.next = 6;
+                  return (0, _shared.getUniqueModificationValues)(self, (0, _configuration.getConf)(self.parentTrack, 'adapter'), colorBy, staticBlocks);
+
+                case 6:
+                  vals = _context.sent;
+                  self.updateModificationColorMap(vals);
+
+                case 8:
+                  _context.next = 14;
+                  break;
+
+                case 10:
+                  _context.prev = 10;
+                  _context.t0 = _context["catch"](0);
+                  console.error(_context.t0);
+                  self.setError(_context.t0);
+
+                case 14:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee, null, [[0, 10]]);
+        })), {
+          delay: 1000
+        }));
+      }
+    };
+  }).views(function (self) {
+    var superTrackMenuItems = self.trackMenuItems;
+    return {
+      get TooltipComponent() {
+        return _Tooltip["default"];
+      },
+
+      get adapterConfig() {
+        var subadapter = (0, _configuration.getConf)(self.parentTrack, 'adapter');
+        return {
+          type: 'SNPCoverageAdapter',
+          subadapter: subadapter
+        };
+      },
+
+      get rendererTypeName() {
+        return rendererTypes.get('snpcoverage');
+      },
+
+      get needsScalebar() {
+        return true;
+      },
+
+      contextMenuItems: function contextMenuItems() {
+        return [];
+      },
+      trackMenuItems: function trackMenuItems() {
+        return [].concat((0, _toConsumableArray2["default"])(superTrackMenuItems()), [{
+          label: 'Draw insertion/clipping indicators',
+          type: 'checkbox',
+          checked: self.drawIndicatorsSetting,
+          onClick: function onClick() {
+            self.toggleDrawIndicators();
+          }
+        }, {
+          label: 'Draw insertion/clipping counts',
+          type: 'checkbox',
+          checked: self.drawInterbaseCountsSetting,
+          onClick: function onClick() {
+            self.toggleDrawInterbaseCounts();
+          }
+        }, {
+          label: 'Draw arcs',
+          type: 'checkbox',
+          checked: self.drawArcsSetting,
+          onClick: function onClick() {
+            self.toggleDrawArcs();
+          }
+        }]);
+      }
+    };
+  });
+};
+
+var _default = stateModelFactory;
+exports["default"] = _default;

package/dist/NestedFrequencyTable.js

@@ -0,0 +1,152 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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; }
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// see perf results on object.keys vs for-in loop
+// https://jsperf.com/object-keys-vs-hasownproperty/55
+var NestedFrequencyTable = /*#__PURE__*/function () {
+  function NestedFrequencyTable() {
+    var initialData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, NestedFrequencyTable);
+    (0, _defineProperty2["default"])(this, "categories", void 0);
+    this.categories = _objectSpread({}, initialData);
+  } // get the sum of all the category counts
+
+
+  (0, _createClass2["default"])(NestedFrequencyTable, [{
+    key: "total",
+    value: function total() {
+      // calculate total if necessary
+      var t = 0;
+
+      for (var k in this.categories) {
+        var v = this.categories[k];
+        t += v.total ? v.total() : v;
+      }
+
+      return t;
+    } // decrement the count for the given category
+
+  }, {
+    key: "decrement",
+    value: function decrement(slotName, amount) {
+      if (!amount) {
+        amount = 1;
+      }
+
+      if (!slotName) {
+        slotName = 'default';
+      } else {
+        slotName = slotName.toString();
+      }
+
+      if (this.categories[slotName]) {
+        this.categories[slotName] = Math.max(0, this.categories[slotName] - amount);
+        return this.categories[slotName];
+      }
+
+      return 0;
+    } // increment the count for the given category
+
+  }, {
+    key: "increment",
+    value: function increment(slotName, amount) {
+      if (!amount) {
+        amount = 1;
+      }
+
+      if (!slotName) {
+        slotName = 'default';
+      } else {
+        slotName = slotName.toString();
+      }
+
+      this.categories[slotName] = (this.categories[slotName] || 0) + amount;
+      return this.categories[slotName];
+    } // get the value of the given category.  may be a number or a
+    // frequency table.
+
+  }, {
+    key: "get",
+    value: function get(slotName) {
+      return this.categories[slotName] || 0;
+    } // get a given category as a frequency table
+
+  }, {
+    key: "getNested",
+    value: function getNested(path) {
+      if (typeof path === 'string') {
+        path = path.split('/');
+      }
+
+      if (!path.length) {
+        return this;
+      }
+
+      var slotName = path[0].toString();
+      var slot = this.categories[slotName];
+
+      if (!slot || !slot.categories) {
+        this.categories[slotName] = new NestedFrequencyTable(slot ? {
+          "default": slot + 0
+        } : {});
+      }
+
+      slot = this.categories[slotName];
+
+      if (path.length > 1) {
+        return slot.getNested(path.slice(1));
+      }
+
+      return slot;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.total().toPrecision(6).toString().replace(/\.?0+$/, '');
+    }
+  }, {
+    key: "valueOf",
+    value: function valueOf() {
+      return this.total();
+    } // iterate through the categories and counts, call like:
+    //
+    //   tbl.forEach( function( count, categoryName ) {
+    //      // do something
+    //   }, this );
+    //
+
+  }, {
+    key: "forEach",
+    value: function forEach(func, ctx) {
+      if (ctx) {
+        for (var slotName in this.categories) {
+          func.call(ctx, this.categories[slotName], slotName);
+        }
+      } else {
+        for (var _slotName in this.categories) {
+          func(this.categories[_slotName], _slotName);
+        }
+      }
+    }
+  }]);
+  return NestedFrequencyTable;
+}();
+
+exports["default"] = NestedFrequencyTable;