@jbrowse/plugin-alignments 2.1.6 → 2.2.0

package/src/LinearAlignmentsDisplay/models/model.tsx

@@ -2,6 +2,7 @@ import React from 'react'
 import {
   ConfigurationReference,
   AnyConfigurationModel,
+  AnyConfigurationSchemaType,
   getConf,
 } from '@jbrowse/core/configuration'
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models'
@@ -11,30 +12,63 @@ import { autorun, when } from 'mobx'
 import { addDisposer, getSnapshot, Instance, types } from 'mobx-state-tree'
 import { getContainingTrack } from '@jbrowse/core/util'
 import deepEqual from 'fast-deep-equal'
-import { AlignmentsConfigModel } from './configSchema'
 
 const minDisplayHeight = 20
-const stateModelFactory = (
+
+/**
+ * #stateModel LinearAlignmentsDisplay
+ * extends `BaseDisplay`
+ */
+function stateModelFactory(
   pluginManager: PluginManager,
-  configSchema: AlignmentsConfigModel,
-) => {
+  configSchema: AnyConfigurationSchemaType,
+) {
   return types
     .compose(
       'LinearAlignmentsDisplay',
       BaseDisplay,
       types.model({
+        /**
+         * #property
+         * refers to LinearPileupDisplay sub-display model
+         */
         PileupDisplay: types.maybe(
           pluginManager.getDisplayType('LinearPileupDisplay').stateModel,
         ),
+        /**
+         * #property
+         * refers to LinearSNPCoverageDisplay sub-display model
+         */
         SNPCoverageDisplay: types.maybe(
           pluginManager.getDisplayType('LinearSNPCoverageDisplay').stateModel,
         ),
+        /**
+         * #property
+         */
         snpCovHeight: 45,
+        /**
+         * #property
+         */
         type: types.literal('LinearAlignmentsDisplay'),
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
+        /**
+         * #property
+         */
         height: 250,
+        /**
+         * #property
+         */
         showCoverage: true,
+        /**
+         * #property
+         */
         showPileup: true,
+        /**
+         * #property
+         */
         userFeatureScreenDensity: types.maybe(types.number),
       }),
     )
@@ -42,15 +76,28 @@ const stateModelFactory = (
       scrollTop: 0,
     }))
     .actions(self => ({
+      /**
+       * #action
+       */
       toggleCoverage() {
         self.showCoverage = !self.showCoverage
       },
+      /**
+       * #action
+       */
       togglePileup() {
         self.showPileup = !self.showPileup
       },
+      /**
+       * #action
+       */
       setScrollTop(scrollTop: number) {
         self.scrollTop = scrollTop
       },
+
+      /**
+       * #action
+       */
       setSNPCoverageHeight(n: number) {
         self.snpCovHeight = n
       },
@@ -58,6 +105,9 @@ const stateModelFactory = (
     .views(self => {
       const { trackMenuItems: superTrackMenuItems } = self
       return {
+        /**
+         * #getter
+         */
         get pileupDisplayConfig() {
           const conf = getConf(self, 'pileupDisplay')
           const track = getContainingTrack(self)
@@ -69,31 +119,55 @@ const stateModelFactory = (
           }
         },
 
+        /**
+         * #method
+         */
         getFeatureByID(blockKey: string, id: string) {
           return self.PileupDisplay.getFeatureByID(blockKey, id)
         },
+        /**
+         * #method
+         */
         searchFeatureByID(id: string) {
           return self.PileupDisplay.searchFeatureByID(id)
         },
 
+        /**
+         * #getter
+         */
         get features() {
           return self.PileupDisplay.features
         },
 
+        /**
+         * #getter
+         */
         get DisplayBlurb() {
           return self.PileupDisplay?.DisplayBlurb
         },
 
+        /**
+         * #getter
+         */
         get sortedBy() {
           return self.PileupDisplay.sortedBy
         },
+        /**
+         * #getter
+         */
         get sortedByPosition() {
           return self.PileupDisplay.sortedByPosition
         },
+        /**
+         * #getter
+         */
         get sortedByRefName() {
           return self.PileupDisplay.sortedByRefName
         },
 
+        /**
+         * #getter
+         */
         get snpCoverageDisplayConfig() {
           const conf = getConf(self, 'snpCoverageDisplay')
           const track = getContainingTrack(self)
@@ -105,6 +179,9 @@ const stateModelFactory = (
           }
         },
 
+        /**
+         * #method
+         */
         trackMenuItems(): MenuItem[] {
           return [
             ...superTrackMenuItems(),
@@ -123,6 +200,9 @@ const stateModelFactory = (
       }
     })
     .actions(self => ({
+      /**
+       * #action
+       */
       setSNPCoverageDisplay(displayConfig: AnyConfigurationModel) {
         self.SNPCoverageDisplay = {
           type: 'LinearSNPCoverageDisplay',
@@ -130,16 +210,25 @@ const stateModelFactory = (
           height: self.snpCovHeight,
         }
       },
+      /**
+       * #action
+       */
       setUserFeatureScreenDensity(limit: number) {
         self.PileupDisplay.setUserFeatureScreenDensity(limit)
         self.SNPCoverageDisplay.setUserFeatureScreenDensity(limit)
       },
+      /**
+       * #action
+       */
       setPileupDisplay(displayConfig: AnyConfigurationModel) {
         self.PileupDisplay = {
           type: 'LinearPileupDisplay',
           configuration: displayConfig,
         }
       },
+      /**
+       * #action
+       */
       setHeight(displayHeight: number) {
         if (displayHeight > minDisplayHeight) {
           self.height = displayHeight
@@ -148,6 +237,9 @@ const stateModelFactory = (
         }
         return self.height
       },
+      /**
+       * #action
+       */
       resizeHeight(distance: number) {
         const oldHeight = self.height
         const newHeight = this.setHeight(self.height + distance)
@@ -218,6 +310,9 @@ const stateModelFactory = (
           }),
         )
       },
+      /**
+       * #action
+       */
       async renderSvg(opts: { rasterizeLayers?: boolean }) {
         const pileupHeight = self.height - self.SNPCoverageDisplay.height
         await when(() => self.PileupDisplay.ready)

package/src/LinearPileupDisplay/configSchema.ts

@@ -3,28 +3,43 @@ import { linearBasicDisplayConfigSchemaFactory } from '@jbrowse/plugin-linear-ge
 import { types, Instance } from 'mobx-state-tree'
 import PluginManager from '@jbrowse/core/PluginManager'
 
-function PileupConfigFactory(pluginManager: PluginManager) {
-  const PileupRendererConfigSchema =
-    pluginManager.getRendererType('PileupRenderer').configSchema
+/**
+ * #config LinearPileupDisplay
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
+function PileupConfigFactory(pluginManager: PluginManager) {
   // modify config schema to take in a sub coverage display
   return ConfigurationSchema(
     'LinearPileupDisplay',
     {
+      /**
+       * #slot
+       */
       defaultRendering: {
         type: 'stringEnum',
         model: types.enumeration('Rendering', ['pileup']),
         defaultValue: 'pileup',
       },
+      /**
+       * #slot
+       */
       renderers: ConfigurationSchema('RenderersConfiguration', {
-        PileupRenderer: PileupRendererConfigSchema,
+        PileupRenderer:
+          pluginManager.getRendererType('PileupRenderer').configSchema,
       }),
-      renderer: '',
+      /**
+       * #slot
+       */
       maxFeatureScreenDensity: {
         type: 'number',
         description: 'maximum features per pixel that is displayed in the view',
         defaultValue: 5,
       },
+
+      /**
+       * #slot
+       */
       colorScheme: {
         type: 'stringEnum',
         model: types.enumeration('colorScheme', [
@@ -40,6 +55,9 @@ function PileupConfigFactory(pluginManager: PluginManager) {
       },
     },
     {
+      /**
+       * #baseConfiguration
+       */
       baseConfiguration: linearBasicDisplayConfigSchemaFactory(pluginManager),
       explicitlyTyped: true,
     },

package/src/LinearPileupDisplay/model.ts

@@ -53,20 +53,50 @@ const rendererTypes = new Map([
 
 type LGV = LinearGenomeViewModel
 
-const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
-  types
+/**
+ * #stateModel LinearPileupDisplay
+ */
+function stateModelFactory(configSchema: LinearPileupDisplayConfigModel) {
+  return types
     .compose(
       'LinearPileupDisplay',
       BaseLinearDisplay,
       types.model({
+        /**
+         * #property
+         */
         type: types.literal('LinearPileupDisplay'),
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
+        /**
+         * #property
+         */
         showSoftClipping: false,
+        /**
+         * #property
+         */
         featureHeight: types.maybe(types.number),
+        /**
+         * #property
+         */
         noSpacing: types.maybe(types.boolean),
+        /**
+         * #property
+         */
         fadeLikelihood: types.maybe(types.boolean),
+        /**
+         * #property
+         */
         trackMaxHeight: types.maybe(types.number),
+        /**
+         * #property
+         */
         mismatchAlpha: types.maybe(types.boolean),
+        /**
+         * #property
+         */
         sortedBy: types.maybe(
           types.model({
             type: types.string,
@@ -76,6 +106,10 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
             assemblyName: types.string,
           }),
         ),
+
+        /**
+         * #property
+         */
         colorBy: types.maybe(
           types.model({
             type: types.string,
@@ -103,25 +137,43 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       ready: false,
     }))
     .actions(self => ({
+      /**
+       * #action
+       */
       setReady(flag: boolean) {
         self.ready = flag
       },
+      /**
+       * #action
+       */
       setMaxHeight(n: number) {
         self.trackMaxHeight = n
       },
+      /**
+       * #action
+       */
       setFeatureHeight(n: number) {
         self.featureHeight = n
       },
+      /**
+       * #action
+       */
       setNoSpacing(flag: boolean) {
         self.noSpacing = flag
       },
 
+      /**
+       * #action
+       */
       setColorScheme(colorScheme: { type: string; tag?: string }) {
         self.colorTagMap = observable.map({}) // clear existing mapping
         self.colorBy = cast(colorScheme)
         self.ready = false
       },
 
+      /**
+       * #action
+       */
       updateModificationColorMap(uniqueModifications: string[]) {
         const colorPalette = ['red', 'blue', 'green', 'orange', 'purple']
         uniqueModifications.forEach(value => {
@@ -133,6 +185,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
         })
       },
 
+      /**
+       * #action
+       */
       updateColorTagMap(uniqueTag: string[]) {
         // pale color scheme
         // https://cran.r-project.org/web/packages/khroma/vignettes/tol.html
@@ -158,6 +213,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }
         })
       },
+      /**
+       * #action
+       */
       setFeatureUnderMouse(feat?: Feature) {
         self.featureUnderMouseVolatile = feat
       },
@@ -285,6 +343,10 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }),
         )
       },
+
+      /**
+       * #action
+       */
       selectFeature(feature: Feature) {
         const session = getSession(self)
         if (isSessionModelWithWidgets(session)) {
@@ -298,11 +360,17 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
         session.setSelection(feature)
       },
 
+      /**
+       * #action
+       */
       clearSelected() {
         self.sortedBy = undefined
       },
 
-      // uses copy-to-clipboard and generates notification
+      /**
+       * #action
+       * uses copy-to-clipboard and generates notification
+       */
       copyFeatureToClipboard(feature: Feature) {
         const { uniqueId, ...rest } = feature.toJSON()
         const session = getSession(self)
@@ -310,17 +378,30 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
         session.notify('Copied to clipboard', 'success')
       },
 
+      /**
+       * #action
+       */
       toggleSoftClipping() {
         self.showSoftClipping = !self.showSoftClipping
       },
+
+      /**
+       * #action
+       */
       toggleMismatchAlpha() {
         self.mismatchAlpha = !self.mismatchAlpha
       },
 
+      /**
+       * #action
+       */
       setConfig(configuration: AnyConfigurationModel) {
         self.configuration = configuration
       },
 
+      /**
+       * #action
+       */
       setSortedBy(type: string, tag?: string) {
         const { centerLineInfo } = getContainingView(self) as LGV
         if (!centerLineInfo) {
@@ -356,6 +437,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       const superReload = self.reload
 
       return {
+        /**
+         * #action
+         */
         reload() {
           self.clearSelected()
           superReload()
@@ -364,12 +448,19 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
     })
 
     .views(self => ({
+      /**
+       * #getter
+       */
       get maxHeight() {
         const conf = getConf(self, ['renderers', self.rendererTypeName]) || {}
         return self.trackMaxHeight !== undefined
           ? self.trackMaxHeight
           : conf.maxHeight
       },
+
+      /**
+       * #getter
+       */
       get rendererConfig() {
         const configBlob =
           getConf(self, ['renderers', self.rendererTypeName]) || {}
@@ -384,16 +475,26 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           getEnv(self),
         )
       },
+
+      /**
+       * #getter
+       */
       get featureHeightSetting() {
         return (
           self.featureHeight || readConfObject(this.rendererConfig, 'height')
         )
       },
+      /**
+       * #getter
+       */
       get mismatchAlphaSetting() {
         return self.mismatchAlpha !== undefined
           ? self.mismatchAlpha
           : readConfObject(this.rendererConfig, 'mismatchAlpha')
       },
+      /**
+       * #getter
+       */
       get featureUnderMouse() {
         return self.featureUnderMouseVolatile
       },
@@ -405,6 +506,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       } = self
 
       return {
+        /**
+         * #getter
+         */
         get rendererTypeName() {
           const viewName = getConf(self, 'defaultRendering')
           const rendererType = rendererTypes.get(viewName)
@@ -414,6 +518,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           return rendererType
         },
 
+        /**
+         * #method
+         */
         contextMenuItems() {
           const feat = self.contextMenuFeature
           const contextMenuItems = feat
@@ -442,10 +549,15 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           return contextMenuItems
         },
 
+        /**
+         * #getter
+         */
         get DisplayBlurb() {
           return LinearPileupDisplayBlurb
         },
-
+        /**
+         * #method
+         */
         renderProps() {
           const view = getContainingView(self) as LGV
           const {
@@ -543,6 +655,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }
         },
 
+        /**
+         * #method
+         */
         trackMenuItems() {
           return [
             ...superTrackMenuItems(),
@@ -698,6 +813,7 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
         },
       }
     })
+}
 
 export type LinearPileupDisplayStateModel = ReturnType<typeof stateModelFactory>
 export type LinearPileupDisplayModel = Instance<LinearPileupDisplayStateModel>

package/src/LinearSNPCoverageDisplay/models/configSchema.ts

@@ -3,14 +3,18 @@ import { baseLinearDisplayConfigSchema } from '@jbrowse/plugin-linear-genome-vie
 import { types } from 'mobx-state-tree'
 import PluginManager from '@jbrowse/core/PluginManager'
 
-export default function SNPCoverageConfigFactory(pluginManager: PluginManager) {
-  const SNPCoverageRendererConfigSchema = pluginManager.getRendererType(
-    'SNPCoverageRenderer',
-  ).configSchema
+/**
+ * #config LinearSNPCoverageDisplay
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
+export default function SNPCoverageConfigFactory(pluginManager: PluginManager) {
   return ConfigurationSchema(
     'LinearSNPCoverageDisplay',
     {
+      /**
+       * #slot
+       */
       autoscale: {
         type: 'stringEnum',
         defaultValue: 'local',
@@ -18,38 +22,61 @@ export default function SNPCoverageConfigFactory(pluginManager: PluginManager) {
         description:
           'performs local autoscaling (no other options for SNP Coverage available)',
       },
+      /**
+       * #slot
+       */
       minScore: {
         type: 'number',
         defaultValue: Number.MIN_VALUE,
         description: 'minimum value for the y-scale',
       },
+      /**
+       * #slot
+       */
       maxScore: {
         type: 'number',
         description: 'maximum value for the y-scale',
         defaultValue: Number.MAX_VALUE,
       },
+      /**
+       * #slot
+       */
       scaleType: {
         type: 'stringEnum',
         model: types.enumeration('Scale type', ['linear', 'log']), // todo zscale
         description: 'The type of scale to use',
         defaultValue: 'linear',
       },
-      inverted: {
+      /**
+       * #slot
+       */ inverted: {
         type: 'boolean',
         description: 'draw upside down',
         defaultValue: false,
       },
-
+      /**
+       * #slot
+       */
       multiTicks: {
         type: 'boolean',
         description: 'Display multiple values for the ticks',
         defaultValue: false,
       },
-
+      /**
+       * #slot
+       */
       renderers: ConfigurationSchema('RenderersConfiguration', {
-        SNPCoverageRenderer: SNPCoverageRendererConfigSchema,
+        SNPCoverageRenderer: pluginManager.getRendererType(
+          'SNPCoverageRenderer',
+        ).configSchema,
       }),
     },
-    { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true },
+    {
+      /**
+       * #baseConfiguration
+       */
+      baseConfiguration: baseLinearDisplayConfigSchema,
+      explicitlyTyped: true,
+    },
   )
 }