@jbrowse/plugin-alignments 1.6.9 → 1.7.3

package/dist/LinearAlignmentsDisplay/components/AlignmentsDisplay.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _mobxReact = require("mobx-react");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _ui = require("@jbrowse/core/ui");
+
+var _core = require("@material-ui/core");
+
+var useStyles = (0, _core.makeStyles)(function () {
+  return {
+    resizeHandle: {
+      height: 2,
+      position: 'absolute',
+      zIndex: 2
+    }
+  };
+});
+
+function AlignmentsDisplay(_ref) {
+  var model = _ref.model;
+  var PileupDisplay = model.PileupDisplay,
+      SNPCoverageDisplay = model.SNPCoverageDisplay,
+      showPileup = model.showPileup,
+      showCoverage = model.showCoverage;
+  var classes = useStyles();
+  var top = SNPCoverageDisplay.height;
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    "data-testid": "display-".concat((0, _configuration.getConf)(model, 'displayId')),
+    style: {
+      position: 'relative'
+    }
+  }, showCoverage ? /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("div", {
+    "data-testid": "Blockset-snpcoverage"
+  }, /*#__PURE__*/_react["default"].createElement(SNPCoverageDisplay.RenderingComponent, {
+    model: SNPCoverageDisplay
+  })), /*#__PURE__*/_react["default"].createElement(_ui.ResizeHandle, {
+    onDrag: function onDrag(delta) {
+      SNPCoverageDisplay.setHeight(SNPCoverageDisplay.height + delta);
+      return delta;
+    },
+    className: classes.resizeHandle,
+    style: {
+      top: top
+    }
+  })) : null, showPileup ? /*#__PURE__*/_react["default"].createElement("div", {
+    "data-testid": "Blockset-pileup",
+    style: {
+      position: 'absolute',
+      top: showCoverage ? SNPCoverageDisplay.height : 0
+    }
+  }, /*#__PURE__*/_react["default"].createElement(PileupDisplay.RenderingComponent, {
+    model: PileupDisplay
+  })) : null);
+}
+
+var _default = (0, _mobxReact.observer)(AlignmentsDisplay);
+
+exports["default"] = _default;

package/dist/LinearAlignmentsDisplay/index.d.ts

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

package/dist/LinearAlignmentsDisplay/index.js

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

package/dist/LinearAlignmentsDisplay/models/configSchema.d.ts

@@ -1,4 +1,4 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-declare const configModelFactory: (pluginManager: PluginManager) => import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
-export declare type AlignmentsConfigModel = ReturnType<typeof configModelFactory>;
-export default configModelFactory;
+import PluginManager from '@jbrowse/core/PluginManager';
+declare const configModelFactory: (pluginManager: PluginManager) => import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+export declare type AlignmentsConfigModel = ReturnType<typeof configModelFactory>;
+export default configModelFactory;

package/dist/LinearAlignmentsDisplay/models/configSchema.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _pluginLinearGenomeView = require("@jbrowse/plugin-linear-genome-view");
+
+var configModelFactory = function configModelFactory(pluginManager) {
+  var PileupDisplayConfigSchema = pluginManager.getDisplayType('LinearPileupDisplay').configSchema;
+  var SNPCoverageDisplayConfigSchema = pluginManager.getDisplayType('LinearSNPCoverageDisplay').configSchema;
+  return (0, _configuration.ConfigurationSchema)('LinearAlignmentsDisplay', {
+    pileupDisplay: PileupDisplayConfigSchema,
+    snpCoverageDisplay: SNPCoverageDisplayConfigSchema
+  }, {
+    baseConfiguration: _pluginLinearGenomeView.baseLinearDisplayConfigSchema,
+    explicitlyTyped: true
+  });
+};
+
+var _default = configModelFactory;
+exports["default"] = _default;

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

@@ -0,0 +1,83 @@
+"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 _BoxRendererType = _interopRequireDefault(require("@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType"));
+
+var _pluginSvg = require("@jbrowse/plugin-svg");
+
+var _PileupRenderer = _interopRequireDefault(require("../../PileupRenderer"));
+
+var _SNPCoverageRenderer = _interopRequireDefault(require("../../SNPCoverageRenderer"));
+
+var _LinearPileupDisplay = _interopRequireDefault(require("../../LinearPileupDisplay"));
+
+var _LinearSNPCoverageDisplay = _interopRequireDefault(require("../../LinearSNPCoverageDisplay"));
+
+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();
+});
+
+var AlignmentsPlugin = /*#__PURE__*/function (_Plugin) {
+  (0, _inherits2["default"])(AlignmentsPlugin, _Plugin);
+
+  var _super = _createSuper(AlignmentsPlugin);
+
+  function AlignmentsPlugin() {
+    (0, _classCallCheck2["default"])(this, AlignmentsPlugin);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(AlignmentsPlugin, [{
+    key: "install",
+    value: function install(pluginManager) {
+      (0, _PileupRenderer["default"])(pluginManager);
+      pluginManager.addRendererType(function () {
+        return new _BoxRendererType["default"]({
+          name: 'SvgFeatureRenderer',
+          ReactComponent: _pluginSvg.SvgFeatureRendererReactComponent,
+          configSchema: _pluginSvg.svgFeatureRendererConfigSchema,
+          pluginManager: pluginManager
+        });
+      });
+      (0, _SNPCoverageRenderer["default"])(pluginManager);
+      (0, _LinearPileupDisplay["default"])(pluginManager);
+      (0, _LinearSNPCoverageDisplay["default"])(pluginManager);
+    }
+  }]);
+  return AlignmentsPlugin;
+}(_Plugin2["default"]);
+
+test('has a type attr', function () {
+  var configSchema = (0, _configSchema["default"])(new _PluginManager["default"]([new AlignmentsPlugin()]).createPluggableElements().configure());
+  var config = configSchema.create({
+    type: 'LinearAlignmentsDisplay',
+    displayId: 'display0',
+    name: 'Zonker Display'
+  });
+  expect(config.type).toEqual('LinearAlignmentsDisplay');
+});

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

@@ -1,105 +1,105 @@
-import React from 'react';
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import PluginManager from '@jbrowse/core/PluginManager';
-import { MenuItem } from '@jbrowse/core/ui';
-import { Instance } from 'mobx-state-tree';
-import { AlignmentsConfigModel } from './configSchema';
-declare const stateModelFactory: (pluginManager: PluginManager, configSchema: AlignmentsConfigModel) => import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<string>;
-    rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-} & {
-    PileupDisplay: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IAnyModelType>;
-    SNPCoverageDisplay: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IAnyModelType>;
-    snpCovHeight: import("mobx-state-tree").IType<number | undefined, number, number>;
-    type: import("mobx-state-tree").ISimpleType<"LinearAlignmentsDisplay">;
-    configuration: import("mobx-state-tree").ITypeUnion<any, any, any>;
-    height: import("mobx-state-tree").IType<number | undefined, number, number>;
-    showCoverage: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    showPileup: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    userFeatureScreenDensity: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-}, {
-    rendererTypeName: string;
-    error: unknown;
-} & {
-    readonly RenderingComponent: React.FC<{
-        model: import("mobx-state-tree").ModelInstanceTypeProps<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        }> & {
-            rendererTypeName: string;
-            error: unknown;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        }, {
-            rendererTypeName: string;
-            error: unknown;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-        onHorizontalScroll?: Function | undefined;
-        blockState?: Record<string, any> | undefined;
-    }>;
-    readonly DisplayBlurb: React.FC<{
-        model: import("mobx-state-tree").ModelInstanceTypeProps<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        }> & {
-            rendererTypeName: string;
-            error: unknown;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        }, {
-            rendererTypeName: string;
-            error: unknown;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    }> | null;
-    readonly adapterConfig: any;
-    readonly parentTrack: any;
-    renderProps(): any;
-    readonly rendererType: any;
-    readonly DisplayMessageComponent: React.FC<any> | undefined;
-    trackMenuItems(): MenuItem[];
-    readonly viewMenuActions: MenuItem[];
-    regionCannotBeRendered(): undefined;
-} & {
-    setError(error?: unknown): void;
-    setRpcDriverName(rpcDriverName: string): void;
-    reload(): void;
-} & {
-    scrollTop: number;
-} & {
-    toggleCoverage(): void;
-    togglePileup(): void;
-    setScrollTop(scrollTop: number): void;
-    setSNPCoverageHeight(n: number): void;
-} & {
-    readonly pileupDisplayConfig: any;
-    getFeatureByID(blockKey: string, id: string): any;
-    searchFeatureByID(id: string): any;
-    readonly features: any;
-    readonly DisplayBlurb: any;
-    readonly sortedBy: any;
-    readonly sortedByPosition: any;
-    readonly sortedByRefName: any;
-    readonly snpCoverageDisplayConfig: any;
-    trackMenuItems(): MenuItem[];
-} & {
-    setSNPCoverageDisplay(displayConfig: AnyConfigurationModel): void;
-    setUserFeatureScreenDensity(limit: number): void;
-    setPileupDisplay(displayConfig: AnyConfigurationModel): void;
-    setHeight(displayHeight: number): number;
-    resizeHeight(distance: number): number;
-} & {
-    afterAttach(): void;
-    renderSvg(opts: {
-        rasterizeLayers?: boolean;
-    }): Promise<JSX.Element>;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export default stateModelFactory;
-export declare type AlignmentsDisplayStateModel = ReturnType<typeof stateModelFactory>;
-export declare type AlignmentsDisplayModel = Instance<AlignmentsDisplayStateModel>;
+import React from 'react';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import PluginManager from '@jbrowse/core/PluginManager';
+import { MenuItem } from '@jbrowse/core/ui';
+import { Instance } from 'mobx-state-tree';
+import { AlignmentsConfigModel } from './configSchema';
+declare const stateModelFactory: (pluginManager: PluginManager, configSchema: AlignmentsConfigModel) => import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+} & {
+    PileupDisplay: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IAnyModelType>;
+    SNPCoverageDisplay: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IAnyModelType>;
+    snpCovHeight: import("mobx-state-tree").IType<number | undefined, number, number>;
+    type: import("mobx-state-tree").ISimpleType<"LinearAlignmentsDisplay">;
+    configuration: import("mobx-state-tree").ITypeUnion<any, any, any>;
+    height: import("mobx-state-tree").IType<number | undefined, number, number>;
+    showCoverage: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    showPileup: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    userFeatureScreenDensity: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+}, {
+    rendererTypeName: string;
+    error: unknown;
+} & {
+    readonly RenderingComponent: React.FC<{
+        model: import("mobx-state-tree").ModelInstanceTypeProps<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }> & {
+            rendererTypeName: string;
+            error: unknown;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+        onHorizontalScroll?: Function | undefined;
+        blockState?: Record<string, any> | undefined;
+    }>;
+    readonly DisplayBlurb: React.FC<{
+        model: import("mobx-state-tree").ModelInstanceTypeProps<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }> & {
+            rendererTypeName: string;
+            error: unknown;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    }> | null;
+    readonly adapterConfig: any;
+    readonly parentTrack: any;
+    renderProps(): any;
+    readonly rendererType: any;
+    readonly DisplayMessageComponent: React.FC<any> | undefined;
+    trackMenuItems(): MenuItem[];
+    readonly viewMenuActions: MenuItem[];
+    regionCannotBeRendered(): undefined;
+} & {
+    setError(error?: unknown): void;
+    setRpcDriverName(rpcDriverName: string): void;
+    reload(): void;
+} & {
+    scrollTop: number;
+} & {
+    toggleCoverage(): void;
+    togglePileup(): void;
+    setScrollTop(scrollTop: number): void;
+    setSNPCoverageHeight(n: number): void;
+} & {
+    readonly pileupDisplayConfig: any;
+    getFeatureByID(blockKey: string, id: string): any;
+    searchFeatureByID(id: string): any;
+    readonly features: any;
+    readonly DisplayBlurb: any;
+    readonly sortedBy: any;
+    readonly sortedByPosition: any;
+    readonly sortedByRefName: any;
+    readonly snpCoverageDisplayConfig: any;
+    trackMenuItems(): MenuItem[];
+} & {
+    setSNPCoverageDisplay(displayConfig: AnyConfigurationModel): void;
+    setUserFeatureScreenDensity(limit: number): void;
+    setPileupDisplay(displayConfig: AnyConfigurationModel): void;
+    setHeight(displayHeight: number): number;
+    resizeHeight(distance: number): number;
+} & {
+    afterAttach(): void;
+    renderSvg(opts: {
+        rasterizeLayers?: boolean;
+    }): Promise<JSX.Element>;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export default stateModelFactory;
+export declare type AlignmentsDisplayStateModel = ReturnType<typeof stateModelFactory>;
+export declare type AlignmentsDisplayModel = Instance<AlignmentsDisplayStateModel>;