@jbrowse/plugin-alignments 2.1.7 → 2.2.1

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 configSchemaF(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,14 +55,15 @@ function PileupConfigFactory(pluginManager: PluginManager) {
       },
     },
     {
+      /**
+       * #baseConfiguration
+       */
       baseConfiguration: linearBasicDisplayConfigSchemaFactory(pluginManager),
       explicitlyTyped: true,
     },
   )
 }
 
-export type LinearPileupDisplayConfigModel = ReturnType<
-  typeof PileupConfigFactory
->
+export type LinearPileupDisplayConfigModel = ReturnType<typeof configSchemaF>
 export type LinearPileupDisplayConfig = Instance<LinearPileupDisplayConfigModel>
-export default PileupConfigFactory
+export default configSchemaF

package/src/LinearPileupDisplay/index.ts

@@ -17,3 +17,8 @@ export default function register(pluginManager: PluginManager) {
     })
   })
 }
+
+export {
+  modelFactory as linearPileupDisplayStateModelFactory,
+  configSchemaFactory as linearPileupDisplayConfigSchemaFactory,
+}

package/src/LinearPileupDisplay/model.ts

@@ -53,20 +53,51 @@ const rendererTypes = new Map([
 
 type LGV = LinearGenomeViewModel
 
-const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
-  types
+/**
+ * #stateModel LinearPileupDisplay
+ * extends `BaseLinearDisplay`
+ */
+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 +107,10 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
             assemblyName: types.string,
           }),
         ),
+
+        /**
+         * #property
+         */
         colorBy: types.maybe(
           types.model({
             type: types.string,
@@ -83,6 +118,10 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
             extra: types.frozen(),
           }),
         ),
+
+        /**
+         * #property
+         */
         filterBy: types.optional(
           types.model({
             flagInclude: types.optional(types.number, 0),
@@ -100,28 +139,53 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       colorTagMap: observable.map<string, string>({}),
       modificationTagMap: observable.map<string, string>({}),
       featureUnderMouseVolatile: undefined as undefined | Feature,
+      currSortBpPerPx: 0,
       ready: false,
     }))
     .actions(self => ({
+      /**
+       * #action
+       */
       setReady(flag: boolean) {
         self.ready = flag
       },
+      /**
+       * #action
+       */
+      setCurrSortBpPerPx(n: number) {
+        self.currSortBpPerPx = n
+      },
+      /**
+       * #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 +197,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 +225,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }
         })
       },
+      /**
+       * #action
+       */
       setFeatureUnderMouse(feat?: Feature) {
         self.featureUnderMouseVolatile = feat
       },
@@ -230,7 +300,7 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
                     ...self.renderProps(),
                   })
                   self.setReady(true)
-                  self.setCurrBpPerPx(bpPerPx)
+                  self.setCurrSortBpPerPx(bpPerPx)
                 } else {
                   self.setReady(true)
                 }
@@ -244,6 +314,8 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
         )
 
         // autorun synchronizes featureUnderMouse with featureIdUnderMouse
+        // asynchronously. this is needed due to how we do not serialize all
+        // features from the BAM/CRAM over the rpc
         addDisposer(
           self,
           autorun(async () => {
@@ -285,6 +357,10 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }),
         )
       },
+
+      /**
+       * #action
+       */
       selectFeature(feature: Feature) {
         const session = getSession(self)
         if (isSessionModelWithWidgets(session)) {
@@ -298,11 +374,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 +392,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 +451,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       const superReload = self.reload
 
       return {
+        /**
+         * #action
+         */
         reload() {
           self.clearSelected()
           superReload()
@@ -364,12 +462,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 +489,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 +520,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
       } = self
 
       return {
+        /**
+         * #getter
+         */
         get rendererTypeName() {
           const viewName = getConf(self, 'defaultRendering')
           const rendererType = rendererTypes.get(viewName)
@@ -414,6 +532,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           return rendererType
         },
 
+        /**
+         * #method
+         */
         contextMenuItems() {
           const feat = self.contextMenuFeature
           const contextMenuItems = feat
@@ -442,10 +563,15 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           return contextMenuItems
         },
 
+        /**
+         * #getter
+         */
         get DisplayBlurb() {
           return LinearPileupDisplayBlurb
         },
-
+        /**
+         * #method
+         */
         renderProps() {
           const view = getContainingView(self) as LGV
           const {
@@ -455,7 +581,7 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
             colorBy,
             filterBy,
             rpcDriverName,
-            currBpPerPx,
+            currSortBpPerPx,
             ready,
           } = self
 
@@ -466,7 +592,7 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
             notReady:
               superProps.notReady ||
               !ready ||
-              (sortedBy && currBpPerPx !== view.bpPerPx),
+              (sortedBy && currSortBpPerPx !== view.bpPerPx),
             rpcDriverName,
             displayModel: self,
             sortedBy,
@@ -543,6 +669,9 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
           }
         },
 
+        /**
+         * #method
+         */
         trackMenuItems() {
           return [
             ...superTrackMenuItems(),
@@ -592,39 +721,31 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
               subMenu: [
                 {
                   label: 'Normal',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'normal' })
-                  },
+                  onClick: () => self.setColorScheme({ type: 'normal' }),
                 },
                 {
                   label: 'Mapping quality',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'mappingQuality' })
-                  },
+                  onClick: () =>
+                    self.setColorScheme({ type: 'mappingQuality' }),
                 },
                 {
                   label: 'Strand',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'strand' })
-                  },
+                  onClick: () => self.setColorScheme({ type: 'strand' }),
                 },
                 {
                   label: 'Pair orientation',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'pairOrientation' })
-                  },
+                  onClick: () =>
+                    self.setColorScheme({ type: 'pairOrientation' }),
                 },
                 {
                   label: 'Per-base quality',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'perBaseQuality' })
-                  },
+                  onClick: () =>
+                    self.setColorScheme({ type: 'perBaseQuality' }),
                 },
                 {
                   label: 'Per-base lettering',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'perBaseLettering' })
-                  },
+                  onClick: () =>
+                    self.setColorScheme({ type: 'perBaseLettering' }),
                 },
                 {
                   label: 'Modifications or methylation',
@@ -637,15 +758,12 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
                 },
                 {
                   label: 'Insert size',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'insertSize' })
-                  },
+                  onClick: () => self.setColorScheme({ type: 'insertSize' }),
                 },
                 {
                   label: 'Stranded paired-end',
-                  onClick: () => {
-                    self.setColorScheme({ type: 'reverseTemplate' })
-                  },
+                  onClick: () =>
+                    self.setColorScheme({ type: 'reverseTemplate' }),
                 },
                 {
                   label: 'Color by tag...',
@@ -690,14 +808,13 @@ const stateModelFactory = (configSchema: LinearPileupDisplayConfigModel) =>
               label: 'Fade mismatches by quality',
               type: 'checkbox',
               checked: self.mismatchAlphaSetting,
-              onClick: () => {
-                self.toggleMismatchAlpha()
-              },
+              onClick: () => self.toggleMismatchAlpha(),
             },
           ]
         },
       }
     })
+}
 
 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,
+    },
   )
 }