@jbrowse/plugin-alignments 2.16.1 → 2.18.0

package/esm/LinearAlignmentsDisplay/{models/configSchema.d.ts → configSchema.d.ts}

@@ -1,21 +1,7 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-/**
- * #config LinearAlignmentsDisplay
- * has a "pileup" sub-display, where you can see individual reads and a
- * quantitative "snpcoverage" sub-display track showing SNP frequencies
- */
-export default function configModelFactory(pm: PluginManager): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
+import type PluginManager from '@jbrowse/core/PluginManager';
+export default function configModelFactory(pluginManager: PluginManager): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
     pileupDisplay: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
-    /**
-     * #slot
-     */
     snpCoverageDisplay: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
-    /**
-     * #slot
-     */
     height: {
         type: string;
         defaultValue: number;

package/esm/LinearAlignmentsDisplay/configSchema.js

@@ -0,0 +1,16 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { baseLinearDisplayConfigSchema } from '@jbrowse/plugin-linear-genome-view';
+export default function configModelFactory(pluginManager) {
+    return ConfigurationSchema('LinearAlignmentsDisplay', {
+        pileupDisplay: pluginManager.getDisplayType('LinearPileupDisplay')
+            .configSchema,
+        snpCoverageDisplay: pluginManager.getDisplayType('LinearSNPCoverageDisplay').configSchema,
+        height: {
+            type: 'number',
+            defaultValue: 250,
+        },
+    }, {
+        baseConfiguration: baseLinearDisplayConfigSchema,
+        explicitlyTyped: true,
+    });
+}

package/esm/LinearAlignmentsDisplay/index.d.ts

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

package/esm/LinearAlignmentsDisplay/index.js

@@ -1,8 +1,7 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-// locals
-import configSchemaFactory from './models/configSchema';
-import modelFactory from './models/model';
 import ReactComponent from './components/AlignmentsDisplay';
+import configSchemaFactory from './configSchema';
+import modelFactory from './model';
 export default function LinearAlignmentsDisplayF(pluginManager) {
     pluginManager.addDisplayType(() => {
         const configSchema = configSchemaFactory(pluginManager);

package/esm/LinearAlignmentsDisplay/{models/model.d.ts → model.d.ts}

@@ -1,16 +1,10 @@
 import React from 'react';
-import { Instance, IStateTreeNode } from 'mobx-state-tree';
-import { AnyConfigurationModel, AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
-import PluginManager from '@jbrowse/core/PluginManager';
-import { MenuItem } from '@jbrowse/core/ui';
-import { FeatureDensityStats } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { IFilter } from '../../shared';
-/**
- * #stateModel LinearAlignmentsDisplay
- * extends
- * - [BaseDisplay](../basedisplay)
- * - [LinearAlignmentsDisplayMixin](../linearalignmentsdisplaymixin)
- */
+import type { FilterBy } from '../shared/types';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel, AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { FeatureDensityStats } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { Instance } from 'mobx-state-tree';
 declare function stateModelFactory(pluginManager: PluginManager, configSchema: AnyConfigurationSchemaType): 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>;
@@ -85,93 +79,33 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
 } & {
     scrollTop: number;
 } & {
-    /**
-     * #action
-     */
     setScrollTop(scrollTop: number): void;
-    /**
-     * #action
-     */
     setSNPCoverageHeight(n: number): void;
 } & {
-    /**
-     * #getter
-     */
     readonly height: any;
-    /**
-     * #getter
-     */
     readonly featureIdUnderMouse: any;
 } & {
-    /**
-     * #getter
-     */
     readonly pileupConf: any;
-    /**
-     * #method
-     */
     getFeatureByID(blockKey: string, id: string): any;
-    /**
-     * #method
-     */
     searchFeatureByID(id: string): any;
-    /**
-     * #getter
-     */
     readonly features: any;
-    /**
-     * #getteralignmentsdisplaymodel
-     */
     readonly DisplayBlurb: any;
-    /**
-     * #getter
-     */
     readonly sortedBy: any;
-    /**
-     * #getter
-     */
     readonly coverageConf: any;
 } & {
-    /**
-     * #action
-     */
     setSNPCoverageDisplay(configuration: AnyConfigurationModel): void;
-    /**
-     * #action
-     */
     setFeatureDensityStatsLimit(stats?: FeatureDensityStats): void;
-    /**
-     * #action
-     */
     setPileupDisplay(configuration: AnyConfigurationModel): void;
-    /**
-     * #action
-     */
     setHeight(n: number): number;
-    /**
-     * #action
-     */
-    setFilterBy(filter: IFilter): void;
-    /**
-     * #action
-     */
+    setFilterBy(filter: FilterBy): void;
     setLowerPanelType(type: string): void;
-    /**
-     * #action
-     */
     resizeHeight(distance: number): number;
 } & {
     afterAttach(): void;
-    /**
-     * #action
-     */
     renderSvg(opts: {
         rasterizeLayers?: boolean;
     }): Promise<React.JSX.Element>;
 } & {
-    /**
-     * #method
-     */
     trackMenuItems(): MenuItem[];
 }, import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;

package/esm/LinearAlignmentsDisplay/{models/model.js → model.js}

@@ -1,17 +1,12 @@
 import React from 'react';
-import { autorun, when } from 'mobx';
-import { addDisposer, getSnapshot, isAlive, types, } from 'mobx-state-tree';
-import deepEqual from 'fast-deep-equal';
-// jbrowse
-import { getConf, } from '@jbrowse/core/configuration';
+import { getConf } from '@jbrowse/core/configuration';
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models';
-// locals
+import deepEqual from 'fast-deep-equal';
+import { autorun, when } from 'mobx';
+import { addDisposer, getSnapshot, isAlive, types } from 'mobx-state-tree';
 import { LinearAlignmentsDisplayMixin } from './alignmentsModel';
 import { getLowerPanelDisplays } from './util';
 const minDisplayHeight = 20;
-function deepSnap(x1, x2) {
-    return deepEqual(x1 ? getSnapshot(x1) : undefined, x2 ? getSnapshot(x2) : undefined);
-}
 function preCheck(self) {
     const { PileupDisplay, SNPCoverageDisplay } = self;
     return (PileupDisplay ||
@@ -24,8 +19,10 @@ function propagateColorBy(self) {
     if (!preCheck(self) || !PileupDisplay.colorBy) {
         return;
     }
-    if (!deepSnap(PileupDisplay.colorBy, SNPCoverageDisplay.colorBy)) {
-        SNPCoverageDisplay.setColorBy(getSnapshot(PileupDisplay.colorBy));
+    if (!deepEqual(PileupDisplay.colorBy, SNPCoverageDisplay.colorBy)) {
+        SNPCoverageDisplay.setColorScheme({
+            ...PileupDisplay.colorBy,
+        });
     }
 }
 function propagateFilterBy(self) {
@@ -33,16 +30,12 @@ function propagateFilterBy(self) {
     if (!preCheck(self) || !PileupDisplay.filterBy) {
         return;
     }
-    if (!deepSnap(PileupDisplay.filterBy, SNPCoverageDisplay.filterBy)) {
-        SNPCoverageDisplay.setFilterBy(getSnapshot(PileupDisplay.filterBy));
+    if (!deepEqual(PileupDisplay.filterBy, SNPCoverageDisplay.filterBy)) {
+        SNPCoverageDisplay.setFilterBy({
+            ...PileupDisplay.filterBy,
+        });
     }
 }
-/**
- * #stateModel LinearAlignmentsDisplay
- * extends
- * - [BaseDisplay](../basedisplay)
- * - [LinearAlignmentsDisplayMixin](../linearalignmentsdisplaymixin)
- */
 function stateModelFactory(pluginManager, configSchema) {
     return types
         .compose('LinearAlignmentsDisplay', BaseDisplay, LinearAlignmentsDisplayMixin(pluginManager, configSchema))
@@ -50,94 +43,58 @@ function stateModelFactory(pluginManager, configSchema) {
         scrollTop: 0,
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         setScrollTop(scrollTop) {
             self.scrollTop = scrollTop;
         },
-        /**
-         * #action
-         */
         setSNPCoverageHeight(n) {
             self.snpCovHeight = n;
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get height() {
             var _a;
             return (_a = self.heightPreConfig) !== null && _a !== void 0 ? _a : getConf(self, 'height');
         },
-        /**
-         * #getter
-         */
         get featureIdUnderMouse() {
             return (self.PileupDisplay.featureIdUnderMouse ||
                 self.SNPCoverageDisplay.featureIdUnderMouse);
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get pileupConf() {
             const conf = getConf(self, 'pileupDisplay');
             return {
                 ...conf,
                 type: self.lowerPanelType,
-                displayId: `${self.configuration.displayId}_${self.lowerPanelType}_xyz`, // xyz to avoid someone accidentally naming the displayId similar to this
+                displayId: `${self.configuration.displayId}_${self.lowerPanelType}_xyz`,
             };
         },
-        /**
-         * #method
-         */
         getFeatureByID(blockKey, id) {
             return self.PileupDisplay.getFeatureByID(blockKey, id);
         },
-        /**
-         * #method
-         */
         searchFeatureByID(id) {
             var _a, _b;
             return (_b = (_a = self.PileupDisplay).searchFeatureByID) === null || _b === void 0 ? void 0 : _b.call(_a, id);
         },
-        /**
-         * #getter
-         */
         get features() {
             return self.PileupDisplay.features;
         },
-        /**
-         * #getteralignmentsdisplaymodel
-         */
         get DisplayBlurb() {
             var _a;
             return (_a = self.PileupDisplay) === null || _a === void 0 ? void 0 : _a.DisplayBlurb;
         },
-        /**
-         * #getter
-         */
         get sortedBy() {
             return self.PileupDisplay.sortedBy;
         },
-        /**
-         * #getter
-         */
         get coverageConf() {
             const conf = getConf(self, 'snpCoverageDisplay');
             return {
                 ...conf,
-                displayId: `${self.configuration.displayId}_snpcoverage_xyz`, // xyz to avoid someone accidentally naming the displayId similar to this
+                displayId: `${self.configuration.displayId}_snpcoverage_xyz`,
             };
         },
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         setSNPCoverageDisplay(configuration) {
             self.SNPCoverageDisplay = {
                 type: 'LinearSNPCoverageDisplay',
@@ -145,45 +102,27 @@ function stateModelFactory(pluginManager, configSchema) {
                 height: self.snpCovHeight,
             };
         },
-        /**
-         * #action
-         */
         setFeatureDensityStatsLimit(stats) {
             self.PileupDisplay.setFeatureDensityStatsLimit(stats);
             self.SNPCoverageDisplay.setFeatureDensityStatsLimit(stats);
         },
-        /**
-         * #action
-         */
         setPileupDisplay(configuration) {
             self.PileupDisplay = {
                 type: configuration.type || 'LinearPileupDisplay',
                 configuration,
             };
         },
-        /**
-         * #action
-         */
         setHeight(n) {
             self.heightPreConfig = Math.max(n, minDisplayHeight);
             return self.heightPreConfig;
         },
-        /**
-         * #action
-         */
         setFilterBy(filter) {
             self.PileupDisplay.setFilterBy(filter);
             self.SNPCoverageDisplay.setFilterBy(filter);
         },
-        /**
-         * #action
-         */
         setLowerPanelType(type) {
             self.lowerPanelType = type;
         },
-        /**
-         * #action
-         */
         resizeHeight(distance) {
             const oldHeight = self.height;
             const newHeight = this.setHeight(self.height + distance);
@@ -217,9 +156,6 @@ function stateModelFactory(pluginManager, configSchema) {
                 self.PileupDisplay.setHeight(self.height - self.SNPCoverageDisplay.height);
             }));
         },
-        /**
-         * #action
-         */
         async renderSvg(opts) {
             const pileupHeight = self.height - self.SNPCoverageDisplay.height;
             await when(() => !self.PileupDisplay.renderProps().notReady &&
@@ -235,9 +171,6 @@ function stateModelFactory(pluginManager, configSchema) {
         .views(self => {
         const { trackMenuItems: superTrackMenuItems } = self;
         return {
-            /**
-             * #method
-             */
             trackMenuItems() {
                 if (!self.PileupDisplay) {
                     return [];
@@ -272,11 +205,9 @@ function stateModelFactory(pluginManager, configSchema) {
         };
     })
         .preProcessSnapshot(snap => {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!snap) {
             return snap;
         }
-        // @ts-expect-error
         const { height, ...rest } = snap;
         return { heightPreConfig: height, ...rest };
     });

package/esm/LinearAlignmentsDisplay/{models/util.d.ts → util.d.ts}

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export declare function getLowerPanelDisplays(pluginManager: PluginManager): import("@jbrowse/core/pluggableElementTypes").DisplayType[];