@jbrowse/plugin-wiggle 2.1.7 → 2.2.1

package/src/LinearWiggleDisplay/models/model.tsx

@@ -10,6 +10,7 @@ import {
   getSession,
   getContainingView,
   isSelectionContainer,
+  Feature,
 } from '@jbrowse/core/util'
 import {
   BaseLinearDisplay,
@@ -19,7 +20,6 @@ import { when } from 'mobx'
 import { isAlive, types, Instance } from 'mobx-state-tree'
 import PluginManager from '@jbrowse/core/PluginManager'
 
-import { Feature } from '@jbrowse/core/util/simpleFeature'
 import { axisPropsFromTickScale } from 'react-d3-axis-mod'
 import {
   getNiceDomain,
@@ -44,29 +44,78 @@ const rendererTypes = new Map([
 
 type LGV = LinearGenomeViewModel
 
-const stateModelFactory = (
+/**
+ * #stateModel LinearWiggleDisplay
+ * Extends `BaseLinearDisplay`
+ */
+function stateModelFactory(
   pluginManager: PluginManager,
   configSchema: AnyConfigurationSchemaType,
-) =>
-  types
+) {
+  return types
     .compose(
       'LinearWiggleDisplay',
       BaseLinearDisplay,
       types.model({
+        /**
+         * #property
+         */
         type: types.literal('LinearWiggleDisplay'),
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
+        /**
+         * #property
+         */
         selectedRendering: types.optional(types.string, ''),
+        /**
+         * #property
+         */
         resolution: types.optional(types.number, 1),
+        /**
+         * #property
+         */
         fill: types.maybe(types.boolean),
+        /**
+         * #property
+         */
         minSize: types.maybe(types.number),
+        /**
+         * #property
+         */
         color: types.maybe(types.string),
+        /**
+         * #property
+         */
         posColor: types.maybe(types.string),
+        /**
+         * #property
+         */
         negColor: types.maybe(types.string),
+        /**
+         * #property
+         */
         summaryScoreMode: types.maybe(types.string),
+        /**
+         * #property
+         */
         rendererTypeNameState: types.maybe(types.string),
+        /**
+         * #property
+         */
         scale: types.maybe(types.string),
+        /**
+         * #property
+         */
         autoscale: types.maybe(types.string),
+        /**
+         * #property
+         */
         displayCrossHatches: types.maybe(types.boolean),
+        /**
+         * #property
+         */
         constraints: types.optional(
           types.model({
             max: types.maybe(types.number),
@@ -83,6 +132,9 @@ const stateModelFactory = (
       statsFetchInProgress: undefined as undefined | AbortController,
     }))
     .actions(self => ({
+      /**
+       * #action
+       */
       updateStats(stats: { scoreMin: number; scoreMax: number }) {
         const { scoreMin, scoreMax } = stats
         const EPSILON = 0.000001
@@ -91,19 +143,31 @@ const stateModelFactory = (
           Math.abs(self.stats.scoreMin - scoreMin) > EPSILON
         ) {
           self.stats = { scoreMin, scoreMax }
-          self.statsReady = true
         }
+        self.statsReady = true
       },
+      /**
+       * #action
+       */
       setColor(color?: string) {
         self.color = color
       },
+      /**
+       * #action
+       */
       setPosColor(color?: string) {
         self.posColor = color
       },
+      /**
+       * #action
+       */
       setNegColor(color?: string) {
         self.negColor = color
       },
 
+      /**
+       * #action
+       */
       setLoading(aborter: AbortController) {
         const { statsFetchInProgress: statsFetch } = self
         if (statsFetch !== undefined && !statsFetch.signal.aborted) {
@@ -112,19 +176,29 @@ const stateModelFactory = (
         self.statsFetchInProgress = aborter
       },
 
-      // this overrides the BaseLinearDisplayModel to avoid popping up a
-      // feature detail display, but still sets the feature selection on the
-      // model so listeners can detect a click
+      /**
+       * #action
+       * this overrides the BaseLinearDisplayModel to avoid popping up a
+       * feature detail display, but still sets the feature selection on the
+       * model so listeners can detect a click
+       */
       selectFeature(feature: Feature) {
         const session = getSession(self)
         if (isSelectionContainer(session)) {
           session.setSelection(feature)
         }
       },
+
+      /**
+       * #action
+       */
       setResolution(res: number) {
         self.resolution = res
       },
 
+      /**
+       * #action
+       */
       setFill(fill: number) {
         if (fill === 0) {
           self.fill = true
@@ -138,6 +212,9 @@ const stateModelFactory = (
         }
       },
 
+      /**
+       * #action
+       */
       toggleLogScale() {
         if (self.scale !== 'log') {
           self.scale = 'log'
@@ -146,51 +223,87 @@ const stateModelFactory = (
         }
       },
 
+      /**
+       * #action
+       */
       setScaleType(scale?: string) {
         self.scale = scale
       },
 
+      /**
+       * #action
+       */
       setSummaryScoreMode(val: string) {
         self.summaryScoreMode = val
       },
 
+      /**
+       * #action
+       */
       setAutoscale(val: string) {
         self.autoscale = val
       },
 
+      /**
+       * #action
+       */
       setMaxScore(val?: number) {
         self.constraints.max = val
       },
 
+      /**
+       * #action
+       */
       setRendererType(val: string) {
         self.rendererTypeNameState = val
       },
 
+      /**
+       * #action
+       */
       setMinScore(val?: number) {
         self.constraints.min = val
       },
 
+      /**
+       * #action
+       */
       toggleCrossHatches() {
         self.displayCrossHatches = !self.displayCrossHatches
       },
 
+      /**
+       * #action
+       */
       setCrossHatches(cross: boolean) {
         self.displayCrossHatches = cross
       },
     }))
     .views(self => ({
+      /**
+       * #getter
+       */
       get TooltipComponent() {
         return Tooltip as unknown as React.FC
       },
 
+      /**
+       * #getter
+       */
       get adapterTypeName() {
         return self.adapterConfig.type
       },
 
+      /**
+       * #getter
+       */
       get rendererTypeNameSimple() {
         return self.rendererTypeNameState || getConf(self, 'defaultRendering')
       },
 
+      /**
+       * #getter
+       */
       get rendererTypeName() {
         const name = this.rendererTypeNameSimple
         const rendererType = rendererTypes.get(name)
@@ -200,24 +313,39 @@ const stateModelFactory = (
         return rendererType
       },
 
-      // subclasses can define these, as snpcoverage track does
+      /**
+       * #getter
+       * subclasses can define these, as snpcoverage track does
+       */
       get filters() {
         return undefined
       },
 
+      /**
+       * #getter
+       */
       get scaleType() {
         return self.scale || getConf(self, 'scaleType')
       },
 
+      /**
+       * #getter
+       */
       get maxScore() {
         return self.constraints.max ?? getConf(self, 'maxScore')
       },
 
+      /**
+       * #getter
+       */
       get minScore() {
         return self.constraints.min ?? getConf(self, 'minScore')
       },
     }))
     .views(self => ({
+      /**
+       * #getter
+       */
       get rendererConfig() {
         const configBlob =
           getConf(self, ['renderers', self.rendererTypeName]) || {}
@@ -254,14 +382,23 @@ const stateModelFactory = (
     .views(self => {
       let oldDomain: [number, number] = [0, 0]
       return {
+        /**
+         * #getter
+         */
         get filled() {
           const { fill, rendererConfig: conf } = self
           return fill ?? readConfObject(conf, 'filled')
         },
+        /**
+         * #getter
+         */
         get summaryScoreModeSetting() {
           const { summaryScoreMode, rendererConfig: conf } = self
           return summaryScoreMode ?? readConfObject(conf, 'summaryScoreMode')
         },
+        /**
+         * #getter
+         */
         get domain() {
           const { stats, scaleType, minScore, maxScore } = self
 
@@ -284,12 +421,18 @@ const stateModelFactory = (
           return oldDomain
         },
 
+        /**
+         * #getter
+         */
         get needsScalebar() {
           return (
             self.rendererTypeName === 'XYPlotRenderer' ||
             self.rendererTypeName === 'LinePlotRenderer'
           )
         },
+        /**
+         * #getter
+         */
         get scaleOpts() {
           return {
             domain: this.domain,
@@ -300,14 +443,23 @@ const stateModelFactory = (
           }
         },
 
+        /**
+         * #getter
+         */
         get canHaveFill() {
           return self.rendererTypeName === 'XYPlotRenderer'
         },
 
+        /**
+         * #getter
+         */
         get autoscaleType() {
           return self.autoscale ?? getConf(self, 'autoscale')
         },
 
+        /**
+         * #getter
+         */
         get displayCrossHatchesSetting() {
           const { displayCrossHatches: hatches, rendererConfig: conf } = self
           return hatches ?? readConfObject(conf, 'displayCrossHatches')
@@ -315,6 +467,9 @@ const stateModelFactory = (
       }
     })
     .views(self => ({
+      /**
+       * #getter
+       */
       get ticks() {
         const { scaleType, domain, height } = self
         const minimalTicks = getConf(self, 'minimalTicks')
@@ -332,14 +487,20 @@ const stateModelFactory = (
           : ticks
       },
 
+      /**
+       * #getter
+       */
       get adapterCapabilities() {
-        return pluginManager.getAdapterType(self.adapterTypeName)
-          .adapterCapabilities
+        const type = self.adapterTypeName
+        return pluginManager.getAdapterType(type).adapterCapabilities
       },
     }))
     .views(self => {
       const { renderProps: superRenderProps } = self
       return {
+        /**
+         * #method
+         */
         renderProps() {
           const superProps = superRenderProps()
           const { filters, ticks, height, resolution, scaleOpts } = self
@@ -357,14 +518,23 @@ const stateModelFactory = (
             filters,
           }
         },
+        /**
+         * #getter
+         */
         get hasResolution() {
           return self.adapterCapabilities.includes('hasResolution')
         },
 
+        /**
+         * #getter
+         */
         get hasGlobalStats() {
           return self.adapterCapabilities.includes('hasGlobalStats')
         },
 
+        /**
+         * #getter
+         */
         get fillSetting() {
           if (self.filled) {
             return 0
@@ -380,6 +550,9 @@ const stateModelFactory = (
       const { trackMenuItems: superTrackMenuItems } = self
       const hasRenderings = getConf(self, 'defaultRendering')
       return {
+        /**
+         * #method
+         */
         trackMenuItems() {
           return [
             ...superTrackMenuItems(),
@@ -501,7 +674,10 @@ const stateModelFactory = (
       type ExportSvgOpts = Parameters<typeof superRenderSvg>[0]
 
       return {
-        // re-runs stats and refresh whole display on reload
+        /**
+         * #action
+         * re-runs stats and refresh whole display on reload
+         */
         async reload() {
           self.setError()
           const aborter = new AbortController()
@@ -522,6 +698,9 @@ const stateModelFactory = (
         afterAttach() {
           statsAutorun(self)
         },
+        /**
+         * #action
+         */
         async renderSvg(opts: ExportSvgOpts) {
           await when(() => self.statsReady && !!self.regionCannotBeRenderedText)
           const { needsScalebar, stats } = self
@@ -542,6 +721,7 @@ const stateModelFactory = (
         },
       }
     })
+}
 
 export type WiggleDisplayStateModel = ReturnType<typeof stateModelFactory>
 export type WiggleDisplayModel = Instance<WiggleDisplayStateModel>

package/src/MultiDensityRenderer/configSchema.ts

@@ -1,10 +1,21 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import ConfigSchema from '../configSchema'
+import baseWiggleRendererConfigSchema from '../configSchema'
+
+/**
+ * #config MultiDensityRenderer
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
 const configSchema = ConfigurationSchema(
   'MultiDensityRenderer',
   {},
-  { baseConfiguration: ConfigSchema, explicitlyTyped: true },
+  {
+    /**
+     * #baseConfiguration
+     */
+    baseConfiguration: baseWiggleRendererConfigSchema,
+    explicitlyTyped: true,
+  },
 )
 
 export default configSchema

package/src/MultiLineRenderer/configSchema.ts

@@ -1,16 +1,25 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 import { types } from 'mobx-state-tree'
-import ConfigSchema from '../configSchema'
+import baseWiggleRendererConfigSchema from '../configSchema'
+/**
+ * #config MultiLineRenderer
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
 const configSchema = ConfigurationSchema(
   'MultiLineRenderer',
   {
+    /**
+     * #slot
+     */
     displayCrossHatches: {
       type: 'boolean',
       description: 'choose to draw cross hatches (sideways lines)',
       defaultValue: false,
     },
-
+    /**
+     * #slot
+     */
     summaryScoreMode: {
       type: 'stringEnum',
       model: types.enumeration('Score type', ['max', 'min', 'avg', 'whiskers']),
@@ -19,6 +28,12 @@ const configSchema = ConfigurationSchema(
       defaultValue: 'avg',
     },
   },
-  { baseConfiguration: ConfigSchema, explicitlyTyped: true },
+  {
+    /**
+     * #baseConfiguration
+     */
+    baseConfiguration: baseWiggleRendererConfigSchema,
+    explicitlyTyped: true,
+  },
 )
 export default configSchema

package/src/MultiLinearWiggleDisplay/models/configSchema.ts

@@ -3,6 +3,11 @@ import { baseLinearDisplayConfigSchema } from '@jbrowse/plugin-linear-genome-vie
 import { types } from 'mobx-state-tree'
 import PluginManager from '@jbrowse/core/PluginManager'
 
+/**
+ * #config MultiLinearWiggleDisplay
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
 export default function WiggleConfigFactory(pluginManager: PluginManager) {
   const MultiXYPlotRendererConfigSchema = pluginManager.getRendererType(
     'MultiXYPlotRenderer',
@@ -22,6 +27,9 @@ export default function WiggleConfigFactory(pluginManager: PluginManager) {
   return ConfigurationSchema(
     'MultiLinearWiggleDisplay',
     {
+      /**
+       * #slot
+       */
       autoscale: {
         type: 'stringEnum',
         defaultValue: 'local',
@@ -35,40 +43,63 @@ export default function WiggleConfigFactory(pluginManager: PluginManager) {
         description:
           'global/local using their min/max values or w/ standard deviations (globalsd/localsd)',
       },
+
+      /**
+       * #slot
+       */
       minimalTicks: {
         type: 'boolean',
         defaultValue: false,
         description: 'use the minimal amount of ticks',
       },
 
+      /**
+       * #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
+       */
       numStdDev: {
         type: 'number',
         description:
           'number of standard deviations to use for autoscale types globalsd or localsd',
         defaultValue: 3,
       },
+      /**
+       * #slot
+       */
       scaleType: {
         type: 'stringEnum',
         model: types.enumeration('Scale type', ['linear', 'log']), // todo zscale
         description: 'The type of scale to use',
         defaultValue: 'linear',
       },
+
+      /**
+       * #slot
+       */
       inverted: {
         type: 'boolean',
         description: 'draw upside down',
         defaultValue: false,
       },
 
+      /**
+       * #slot
+       */
       defaultRendering: {
         type: 'stringEnum',
         model: types.enumeration('Rendering', [
@@ -81,6 +112,9 @@ export default function WiggleConfigFactory(pluginManager: PluginManager) {
         defaultValue: 'multirowxy',
       },
 
+      /**
+       * #slot
+       */
       renderers: ConfigurationSchema('RenderersConfiguration', {
         MultiXYPlotRenderer: MultiXYPlotRendererConfigSchema,
         MultiDensityRenderer: MultiDensityRendererConfigSchema,
@@ -89,6 +123,12 @@ export default function WiggleConfigFactory(pluginManager: PluginManager) {
         MultiRowLineRenderer: MultiRowLineRendererConfigSchema,
       }),
     },
-    { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true },
+    {
+      /**
+       * #baseConfiguration
+       */
+      baseConfiguration: baseLinearDisplayConfigSchema,
+      explicitlyTyped: true,
+    },
   )
 }

package/src/MultiQuantitativeTrack/configSchema.ts

@@ -0,0 +1,23 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes/models'
+import PluginManager from '@jbrowse/core/PluginManager'
+
+/**
+ * #config MultiQuantitativeTrack
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const configSchema = (pluginManager: PluginManager) => {
+  return ConfigurationSchema(
+    'MultiQuantitativeTrack',
+    {},
+    {
+      /**
+       * #baseConfiguration
+       */
+      baseConfiguration: createBaseTrackConfig(pluginManager),
+    },
+  )
+}
+
+export default configSchema

package/src/MultiQuantitativeTrack/index.ts

@@ -1,18 +1,11 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import {
-  createBaseTrackConfig,
-  createBaseTrackModel,
-} from '@jbrowse/core/pluggableElementTypes/models'
+import { createBaseTrackModel } from '@jbrowse/core/pluggableElementTypes/models'
 import TrackType from '@jbrowse/core/pluggableElementTypes/TrackType'
 import PluginManager from '@jbrowse/core/PluginManager'
+import configSchemaF from './configSchema'
 
 export default (pluginManager: PluginManager) => {
   pluginManager.addTrackType(() => {
-    const configSchema = ConfigurationSchema(
-      'MultiQuantitativeTrack',
-      {},
-      { baseConfiguration: createBaseTrackConfig(pluginManager) },
-    )
+    const configSchema = configSchemaF(pluginManager)
     return new TrackType({
       name: 'MultiQuantitativeTrack',
       configSchema,