@apollo-annotation/jbrowse-plugin-apollo 0.1.0

package/src/LinearApolloDisplay/stateModel/base.ts

@@ -0,0 +1,146 @@
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration'
+import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration/configurationSchema'
+import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes'
+import PluginManager from '@jbrowse/core/PluginManager'
+import {
+  AbstractSessionModel,
+  getContainingView,
+  getSession,
+} from '@jbrowse/core/util'
+import { getParentRenderProps } from '@jbrowse/core/util/tracks'
+// import type LinearGenomeViewPlugin from '@jbrowse/plugin-linear-genome-view'
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
+import { AnnotationFeatureI } from 'apollo-mst'
+import { autorun } from 'mobx'
+import { addDisposer, getRoot, types } from 'mobx-state-tree'
+
+import { ApolloInternetAccountModel } from '../../ApolloInternetAccount/model'
+import { ApolloSessionModel } from '../../session'
+import { ApolloRootModel } from '../../types'
+import { TrackHeightMixin } from './trackHeightMixin'
+
+export function baseModelFactory(
+  _pluginManager: PluginManager,
+  configSchema: AnyConfigurationSchemaType,
+) {
+  // TODO: Restore this when TRackHeightMixin is in LGV runtime exports
+
+  // const LGVPlugin = pluginManager.getPlugin(
+  //   'LinearGenomeViewPlugin',
+  // ) as LinearGenomeViewPlugin
+  // const { TrackHeightMixin } = LGVPlugin.exports
+
+  return types
+    .compose(BaseDisplay, TrackHeightMixin)
+    .named('BaseLinearApolloDisplay')
+    .props({
+      type: types.literal('LinearApolloDisplay'),
+      configuration: ConfigurationReference(configSchema),
+    })
+    .volatile((self) => ({
+      lgv: getContainingView(self) as unknown as LinearGenomeViewModel,
+    }))
+    .views((self) => {
+      const { configuration, renderProps: superRenderProps } = self
+      return {
+        renderProps() {
+          return {
+            ...superRenderProps(),
+            ...getParentRenderProps(self),
+            config: configuration.renderer,
+          }
+        },
+      }
+    })
+    .views((self) => ({
+      get rendererTypeName() {
+        return self.configuration.renderer.type
+      },
+      get session() {
+        return getSession(self) as unknown as ApolloSessionModel
+      },
+      get regions() {
+        const regions = self.lgv.dynamicBlocks.contentBlocks.map(
+          ({ assemblyName, end, refName, start }) => ({
+            assemblyName,
+            refName,
+            start: Math.round(start),
+            end: Math.round(end),
+          }),
+        )
+        return regions
+      },
+      get displayedRegions() {
+        return self.lgv.displayedRegions
+      },
+      regionCannotBeRendered(/* region */) {
+        if (self.lgv && self.lgv.bpPerPx >= 200) {
+          return 'Zoom in to see annotations'
+        }
+        return
+      },
+    }))
+    .views((self) => ({
+      get apolloInternetAccount() {
+        const [region] = self.regions
+        const { internetAccounts } = getRoot<ApolloRootModel>(self)
+        const { assemblyName } = region
+        const { assemblyManager } =
+          self.session as unknown as AbstractSessionModel
+        const assembly = assemblyManager.get(assemblyName)
+        if (!assembly) {
+          throw new Error(`No assembly found with name ${assemblyName}`)
+        }
+        const { internetAccountConfigId } = getConf(assembly, [
+          'sequence',
+          'metadata',
+        ]) as { internetAccountConfigId: string }
+        return internetAccounts.find(
+          (ia) => getConf(ia, 'internetAccountId') === internetAccountConfigId,
+        ) as ApolloInternetAccountModel | undefined
+      },
+      get changeManager() {
+        return (self.session as unknown as ApolloSessionModel).apolloDataStore
+          ?.changeManager
+      },
+      getAssemblyId(assemblyName: string) {
+        const { assemblyManager } =
+          self.session as unknown as AbstractSessionModel
+        const assembly = assemblyManager.get(assemblyName)
+        if (!assembly) {
+          throw new Error(`Could not find assembly named ${assemblyName}`)
+        }
+        return assembly.name
+      },
+      get selectedFeature(): AnnotationFeatureI | undefined {
+        return (self.session as unknown as ApolloSessionModel)
+          .apolloSelectedFeature
+      },
+    }))
+    .actions((self) => ({
+      setSelectedFeature(feature?: AnnotationFeatureI) {
+        return (
+          self.session as unknown as ApolloSessionModel
+        ).apolloSetSelectedFeature(feature)
+      },
+      afterAttach() {
+        addDisposer(
+          self,
+          autorun(
+            () => {
+              if (!self.lgv.initialized || self.regionCannotBeRendered()) {
+                return
+              }
+              void (
+                self.session as unknown as ApolloSessionModel
+              ).apolloDataStore.loadFeatures(self.regions)
+              void (
+                self.session as unknown as ApolloSessionModel
+              ).apolloDataStore.loadRefSeq(self.regions)
+            },
+            { name: 'LinearApolloDisplayLoadFeatures', delay: 1000 },
+          ),
+        )
+      },
+    }))
+}

package/src/LinearApolloDisplay/stateModel/getGlyph.ts

@@ -0,0 +1,39 @@
+import { AnnotationFeatureI } from 'apollo-mst'
+
+import {
+  BoxGlyph,
+  CanonicalGeneGlyph,
+  GenericChildGlyph,
+  ImplicitExonGeneGlyph,
+} from '../glyphs'
+import { Glyph } from '../glyphs/Glyph'
+
+const boxGlyph = new BoxGlyph()
+const canonicalGeneGlyph = new CanonicalGeneGlyph()
+const genericChildGlyph = new GenericChildGlyph()
+const implicitExonGeneGlyph = new ImplicitExonGeneGlyph()
+
+/** get the appropriate glyph for the given top-level feature */
+export function getGlyph(feature: AnnotationFeatureI, _bpPerPx: number): Glyph {
+  if (feature.type === 'gene') {
+    let hasExon = false
+    for (const [, mrna] of feature.children ?? new Map()) {
+      if (mrna.type !== 'mRNA') {
+        continue
+      }
+      for (const [, possibleExon] of mrna.children ?? new Map()) {
+        if (possibleExon.type === 'exon') {
+          hasExon = true
+        }
+      }
+    }
+    if (hasExon) {
+      return canonicalGeneGlyph
+    }
+    return implicitExonGeneGlyph
+  }
+  if (feature.children?.size) {
+    return genericChildGlyph
+  }
+  return boxGlyph
+}

package/src/LinearApolloDisplay/stateModel/glyphs.ts

@@ -0,0 +1,45 @@
+import { AnnotationFeatureI } from 'apollo-mst'
+import { ObservableMap, observable } from 'mobx'
+import { types } from 'mobx-state-tree'
+
+import { BoxGlyph } from '../glyphs/BoxGlyph'
+import { Glyph } from '../glyphs/Glyph'
+
+export default function Glyphs() {
+  return types
+    .model({})
+    .volatile(() => ({
+      glyphs: observable.map<number, ObservableMap<string, Glyph>>(),
+    }))
+    .actions((s) => {
+      const self = s
+      return {
+        getGlyphsForZoomLevel(bpPerPx: number): ObservableMap<string, Glyph> {
+          const existingZoomLevel = self.glyphs.get(bpPerPx)
+          if (existingZoomLevel) {
+            return existingZoomLevel
+          }
+          const newZoomLevel = observable.map()
+          self.glyphs.set(bpPerPx, newZoomLevel)
+          return newZoomLevel
+        },
+        createGlyph() {
+          return new BoxGlyph()
+        },
+        /** get the appropriate glyph for the given top-level feature */
+        getGlyph(feature: AnnotationFeatureI, bpPerPx: number) {
+          const glyphsForZoomLevel = this.getGlyphsForZoomLevel(bpPerPx)
+          const glyphForFeature = glyphsForZoomLevel.get(feature._id)
+          if (glyphForFeature) {
+            return glyphForFeature
+          }
+          const newGlyph = this.createGlyph()
+          glyphsForZoomLevel.set(feature._id, newGlyph)
+          return newGlyph
+        },
+        afterAttach() {
+          // autorun to clean up old glyph zoom levels
+        },
+      }
+    })
+}

package/src/LinearApolloDisplay/stateModel/index.ts

@@ -0,0 +1,20 @@
+import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration/configurationSchema'
+import PluginManager from '@jbrowse/core/PluginManager'
+import { Instance, types } from 'mobx-state-tree'
+
+import { TabularEditorStateModelType } from '../../TabularEditor'
+import { mouseEventsModelFactory } from './mouseEvents'
+
+export function stateModelFactory(
+  pluginManager: PluginManager,
+  configSchema: AnyConfigurationSchemaType,
+) {
+  // TODO: this needs to be refactored so that the final composition of the
+  // state model mixins happens here in one central place
+  return mouseEventsModelFactory(pluginManager, configSchema)
+    .props({ tabularEditor: types.optional(TabularEditorStateModelType, {}) })
+    .named('LinearApolloDisplay')
+}
+
+export type LinearApolloDisplayStateModel = ReturnType<typeof stateModelFactory>
+export type LinearApolloDisplay = Instance<LinearApolloDisplayStateModel>

package/src/LinearApolloDisplay/stateModel/layouts.ts

@@ -0,0 +1,230 @@
+import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration/configurationSchema'
+import PluginManager from '@jbrowse/core/PluginManager'
+import { AbstractSessionModel, doesIntersect2 } from '@jbrowse/core/util'
+import { AnnotationFeatureI } from 'apollo-mst'
+import { autorun, observable } from 'mobx'
+import { addDisposer, isAlive } from 'mobx-state-tree'
+
+import { ApolloSessionModel } from '../../session'
+import { baseModelFactory } from './base'
+import { getGlyph } from './getGlyph'
+
+export function layoutsModelFactory(
+  pluginManager: PluginManager,
+  configSchema: AnyConfigurationSchemaType,
+) {
+  const BaseLinearApolloDisplay = baseModelFactory(pluginManager, configSchema)
+
+  return BaseLinearApolloDisplay.named('LinearApolloDisplayLayouts')
+    .props({
+      featuresMinMaxLimit: 500_000,
+    })
+    .volatile(() => ({
+      seenFeatures: observable.map<string, AnnotationFeatureI>(),
+    }))
+    .views((self) => ({
+      get featuresMinMax() {
+        const { assemblyManager } =
+          self.session as unknown as AbstractSessionModel
+        return self.displayedRegions.map((region) => {
+          const assembly = assemblyManager.get(region.assemblyName)
+          let min: number | undefined
+          let max: number | undefined
+          const { end, refName, start } = region
+          for (const [, feature] of self.seenFeatures) {
+            if (
+              refName !== assembly?.getCanonicalRefName(feature.refSeq) ||
+              !doesIntersect2(start, end, feature.min, feature.max) ||
+              feature.length > self.featuresMinMaxLimit
+            ) {
+              continue
+            }
+            if (min === undefined) {
+              ;({ min } = feature)
+            }
+            if (max === undefined) {
+              ;({ max } = feature)
+            }
+            if (feature.min < min) {
+              ;({ min } = feature)
+            }
+            if (feature.end > max) {
+              ;({ max } = feature)
+            }
+          }
+          if (min !== undefined && max !== undefined) {
+            return [min, max]
+          }
+          return
+        })
+      },
+    }))
+    .actions((self) => ({
+      addSeenFeature(feature: AnnotationFeatureI) {
+        self.seenFeatures.set(feature._id, feature)
+      },
+      deleteSeenFeature(featureId: string) {
+        self.seenFeatures.delete(featureId)
+      },
+    }))
+    .views((self) => ({
+      get featureLayouts() {
+        const { assemblyManager } =
+          self.session as unknown as AbstractSessionModel
+        return self.displayedRegions.map((region, idx) => {
+          const assembly = assemblyManager.get(region.assemblyName)
+          const featureLayout = new Map<
+            number,
+            [number, AnnotationFeatureI][]
+          >()
+          const minMax = self.featuresMinMax[idx]
+          if (!minMax) {
+            return featureLayout
+          }
+          const [min, max] = minMax
+          const rows: boolean[][] = []
+          const { end, refName, start } = region
+          for (const [id, feature] of self.seenFeatures.entries()) {
+            if (!isAlive(feature)) {
+              self.deleteSeenFeature(id)
+              continue
+            }
+            if (
+              refName !== assembly?.getCanonicalRefName(feature.refSeq) ||
+              !doesIntersect2(start, end, feature.min, feature.max)
+            ) {
+              continue
+            }
+            const rowCount = getGlyph(feature, self.lgv.bpPerPx).getRowCount(
+              feature,
+              self.lgv.bpPerPx,
+            )
+            let startingRow = 0
+            let placed = false
+            while (!placed) {
+              let rowsForFeature = rows.slice(
+                startingRow,
+                startingRow + rowCount,
+              )
+              if (rowsForFeature.length < rowCount) {
+                for (let i = 0; i < rowCount - rowsForFeature.length; i++) {
+                  const newRowNumber = rows.length
+                  rows[newRowNumber] = Array.from({ length: max - min })
+                  featureLayout.set(newRowNumber, [])
+                }
+                rowsForFeature = rows.slice(startingRow, startingRow + rowCount)
+              }
+              if (
+                rowsForFeature
+                  .map((rowForFeature) => {
+                    // zero-length features are allowed in the spec
+                    const featureMax =
+                      feature.max - feature.min === 0
+                        ? feature.min + 1
+                        : feature.max
+                    let start = feature.min - min,
+                      end = featureMax - min
+                    if (feature.min - min < 0) {
+                      start = 0
+                      end = featureMax - feature.min
+                    }
+                    return rowForFeature.slice(start, end).some(Boolean)
+                  })
+                  .some(Boolean)
+              ) {
+                startingRow += 1
+                continue
+              }
+              for (
+                let rowNum = startingRow;
+                rowNum < startingRow + rowCount;
+                rowNum++
+              ) {
+                const row = rows[rowNum]
+                let start = feature.min - min,
+                  end = feature.max - min
+                if (feature.min - min < 0) {
+                  start = 0
+                  end = feature.max - feature.min
+                }
+                row.fill(true, start, end)
+                const layoutRow = featureLayout.get(rowNum)
+                layoutRow?.push([rowNum - startingRow, feature])
+              }
+              placed = true
+            }
+          }
+          return featureLayout
+        })
+      },
+      getFeatureLayoutPosition(feature: AnnotationFeatureI) {
+        const { featureLayouts } = this
+        for (const layout of featureLayouts) {
+          for (const [layoutRowNum, layoutRow] of layout) {
+            for (const [featureRowNum, layoutFeature] of layoutRow) {
+              if (featureRowNum !== 0) {
+                // Same top-level feature in all feature rows, so only need to
+                // check the first one
+                continue
+              }
+              if (feature._id === layoutFeature._id) {
+                return { layoutRow: layoutRowNum, featureRow: featureRowNum }
+              }
+              if (layoutFeature.hasDescendant(feature._id)) {
+                const row = getGlyph(
+                  layoutFeature,
+                  self.lgv.bpPerPx,
+                ).getRowForFeature(layoutFeature, feature)
+                if (row !== undefined) {
+                  return { layoutRow: layoutRowNum, featureRow: row }
+                }
+              }
+            }
+          }
+        }
+        return
+      },
+    }))
+    .views((self) => ({
+      get highestRow() {
+        return Math.max(
+          0,
+          ...self.featureLayouts.map((layout) => Math.max(...layout.keys())),
+        )
+      },
+    }))
+    .actions((self) => ({
+      afterAttach() {
+        addDisposer(
+          self,
+          autorun(
+            () => {
+              if (!self.lgv.initialized || self.regionCannotBeRendered()) {
+                return
+              }
+              for (const region of self.regions) {
+                const assembly = (
+                  self.session as unknown as ApolloSessionModel
+                ).apolloDataStore.assemblies.get(region.assemblyName)
+                const ref = assembly?.getByRefName(region.refName)
+                for (const [, feature] of ref?.features ?? new Map()) {
+                  if (
+                    doesIntersect2(
+                      region.start,
+                      region.end,
+                      feature.start,
+                      feature.end,
+                    ) &&
+                    !self.seenFeatures.has(feature._id)
+                  ) {
+                    self.addSeenFeature(feature)
+                  }
+                }
+              }
+            },
+            { name: 'LinearApolloDisplaySetSeenFeatures', delay: 1000 },
+          ),
+        )
+      },
+    }))
+}