@apollo-annotation/jbrowse-plugin-apollo 0.3.6 → 0.3.8

package/src/extensions/annotationFromPileup.ts

@@ -4,21 +4,30 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
-import { AddFeatureChange } from '@apollo-annotation/shared'
 import { type Assembly } from '@jbrowse/core/assemblyManager/assembly'
 import { type DisplayType } from '@jbrowse/core/pluggableElementTypes'
 import type PluggableElementBase from '@jbrowse/core/pluggableElementTypes/PluggableElementBase'
-import { getContainingView, getSession } from '@jbrowse/core/util'
+import {
+  type AbstractSessionModel,
+  getContainingView,
+  getSession,
+} from '@jbrowse/core/util'
 import { type LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
 import AddIcon from '@mui/icons-material/Add'
 import ObjectID from 'bson-objectid'
 
-import { type ApolloSessionModel } from '../session'
+import { CreateApolloAnnotation } from '../components/CreateApolloAnnotation'
 
-function parseCigar(cigar: string): [string | undefined, number][] {
-  return (cigar.toUpperCase().match(/\d+\D/g) ?? []).map((op) => {
-    return [(/\D/.exec(op) ?? [])[0], Number.parseInt(op, 10)]
-  })
+function parseCigar(cigar: string): [string, number][] {
+  const regex = /(\d+)([MIDNSHPX=])/g
+  const result: [string, number][] = []
+  let match
+
+  while ((match = regex.exec(cigar)) !== null) {
+    result.push([match[2], Number.parseInt(match[1], 10)])
+  }
+
+  return result
 }
 
 export function annotationFromPileup(pluggableElement: PluggableElementBase) {
@@ -62,55 +71,87 @@ export function annotationFromPileup(pluggableElement: PluggableElementBase) {
         }
         return refSeqId
       },
-      createFeature() {
+      getAnnotationFeature() {
         const feature = self.contextMenuFeature
         const assembly = self.getAssembly()
         const refSeqId = self.getRefSeqId(assembly)
+        const start: number = feature.get('start')
+        const end: number = feature.get('end')
+        const strand = feature.get('strand')
+        const name = feature.get('name')
+
         const cigarData: string = feature.get('CIGAR')
         const ops = parseCigar(cigarData)
-        let currOffset = 0
-        const start: number = feature.get('start')
-        let openStart: number | undefined
+        let position = start
+        let currentExonStart: number | undefined
         const exons: {
           start: number
           end: number
         }[] = []
+
+        // Example: [[96,S], [4,M], [4216,N], [357,M], [1,I], [628,M], [94,S]]
+        // Results in 2 exons
+        // M, = and X are matches -> exon
+        // N is a gap in the reference sequence -> intron
+        // I, S, H and P -> not counted in reference position
         for (const [op, len] of ops) {
-          // open or continue open
-          if (op === 'M' || op === '=') {
-            // if it was closed, then open with start, strand, type
-            if (openStart === undefined) {
-              // add subfeature
-              openStart = currOffset + start
+          switch (op) {
+            case 'M':
+            case '=':
+            case 'X': {
+              if (currentExonStart === undefined) {
+                currentExonStart = position
+              }
+              position += len
+              break
+            }
+
+            case 'N': {
+              if (currentExonStart !== undefined) {
+                exons.push({
+                  start: currentExonStart,
+                  end: position,
+                })
+                currentExonStart = undefined
+              }
+              position += len
+              break
+            }
+            case 'D': {
+              position += len
+              break
+            }
+            case 'I':
+            case 'S':
+            case 'H':
+            case 'P': {
+              // These operations do not affect the position in the reference sequence
+              break
+            }
+            default: {
+              throw new Error(`Unknown CIGAR operation: ${op}`)
             }
-          } else if (op === 'N' && openStart !== undefined) {
-            // if it was open, then close and add the subfeature
-            exons.push({
-              start: openStart,
-              end: currOffset + openStart,
-            })
-            openStart = undefined
-          }
-          if (op !== 'I') {
-            // we ignore insertions when calculating potential exon length
-            currOffset += len
           }
         }
-        // if we are still open, then close with the final length and add subfeature
-        if (openStart !== undefined) {
+
+        // If still in exon at end
+        if (currentExonStart !== undefined) {
           exons.push({
-            start: openStart,
-            end: currOffset + start,
+            start: currentExonStart,
+            end: position,
           })
         }
 
         const newFeature: AnnotationFeatureSnapshot = {
           _id: ObjectID().toHexString(),
           refSeq: refSeqId,
-          min: feature.get('start'),
-          max: feature.get('end'),
+          min: start,
+          max: end,
           type: 'mRNA',
-          strand: feature.get('strand'),
+          strand,
+          attributes: {
+            name: [name],
+          },
         }
         if (exons.length === 0) {
           return newFeature
@@ -118,75 +159,28 @@ export function annotationFromPileup(pluggableElement: PluggableElementBase) {
 
         const children: Record<string, AnnotationFeatureSnapshot> = {}
         newFeature.children = children
-        const [firstExon] = exons
-        const cdsFeature: AnnotationFeatureSnapshot = {
-          _id: ObjectID().toHexString(),
-          refSeq: refSeqId,
-          min: firstExon.start,
-          max: firstExon.end,
-          type: 'CDS',
-          strand: feature.get('strand'),
-        }
-        newFeature.children[cdsFeature._id] = cdsFeature
-        if (exons.length === 1) {
-          const exon: AnnotationFeatureSnapshot = {
-            _id: ObjectID().toHexString(),
-            refSeq: refSeqId,
-            min: firstExon.start,
-            max: firstExon.end,
-            type: 'exon',
-            strand: feature.get('strand'),
-          }
-          newFeature.children[exon._id] = exon
-          return newFeature
-        }
 
-        const discontinuousLocations: {
-          start: number
-          end: number
-          phase: 0 | 1 | 2
-        }[] = []
-        let phase: 0 | 1 | 2 = 0
         for (const exon of exons) {
-          cdsFeature.min = Math.min(cdsFeature.min, exon.start)
-          cdsFeature.max = Math.max(cdsFeature.max, exon.end)
-          const { end, start } = exon
-          discontinuousLocations.push({ start, end, phase })
-          const localPhase = (end - start) % 3
-          phase = ((phase + localPhase) % 3) as 0 | 1 | 2
           const newExon: AnnotationFeatureSnapshot = {
             _id: ObjectID().toHexString(),
             refSeq: refSeqId,
-            min: start,
-            max: end,
+            min: exon.start,
+            max: exon.end,
             type: 'exon',
-            strand: feature.get('strand'),
+            strand,
           }
           newFeature.children[newExon._id] = newExon
         }
         return newFeature
       },
-      async onPileupFeatureContext() {
-        const newFeature = self.createFeature()
-        const assembly = self.getAssembly()
-        const assemblyId = assembly.name
-        const change = new AddFeatureChange({
-          changedIds: [newFeature._id],
-          typeName: 'AddFeatureChange',
-          assembly: assemblyId,
-          addedFeature: newFeature,
-        })
-        const session = getSession(self)
-        await (
-          session as unknown as ApolloSessionModel
-        ).apolloDataStore.changeManager.submit(change)
-        session.notify('Annotation added successfully', 'success')
-      },
     }))
     .views((self) => {
       const superContextMenuItems = self.contextMenuItems
       return {
         contextMenuItems() {
+          const session = getSession(self)
+          const assembly = self.getAssembly()
+          const region = self.getFirstRegion()
           const feature = self.contextMenuFeature
           if (!feature) {
             return superContextMenuItems()
@@ -196,7 +190,23 @@ export function annotationFromPileup(pluggableElement: PluggableElementBase) {
             {
               label: 'Create Apollo annotation',
               icon: AddIcon,
-              onClick: self.onPileupFeatureContext,
+              onClick: () => {
+                ;(session as unknown as AbstractSessionModel).queueDialog(
+                  (doneCallback) => [
+                    CreateApolloAnnotation,
+                    {
+                      session,
+                      handleClose: () => {
+                        doneCallback()
+                      },
+                      annotationFeature: self.getAnnotationFeature(assembly),
+                      assembly,
+                      refSeqId: self.getRefSeqId(assembly),
+                      region,
+                    },
+                  ],
+                )
+              },
             },
           ]
         },

package/src/index.ts

@@ -6,6 +6,7 @@ import {
   CDSCheck,
   CoreValidation,
   ParentChildValidation,
+  TranscriptCheck,
   changes,
   validationRegistry,
 } from '@apollo-annotation/shared'
@@ -30,6 +31,7 @@ import {
 } from '@jbrowse/core/util'
 import { type LinearGenomeViewStateModel } from '@jbrowse/plugin-linear-genome-view'
 import AddIcon from '@mui/icons-material/Add'
+import { alpha } from '@mui/material'
 
 import { version } from '../package.json'
 
@@ -51,19 +53,16 @@ import {
   configSchema as linearApolloDisplayConfigSchema,
   stateModelFactory as LinearApolloDisplayStateModelFactory,
 } from './LinearApolloDisplay'
+import {
+  LinearApolloReferenceSequenceDisplay,
+  configSchema as linearApolloReferenceSequenceDisplayConfigSchema,
+  stateModelFactory as LinearApolloReferenceSequenceDisplayStateModelFactory,
+} from './LinearApolloReferenceSequenceDisplay'
 import {
   configSchema as linearApolloSixFrameDisplayConfigSchema,
   stateModelFactory as LinearApolloSixFrameDisplayStateModelFactory,
 } from './LinearApolloSixFrameDisplay'
-import {
-  AddFeature,
-  DownloadGFF3,
-  LogOut,
-  ManageChecks,
-  OpenLocalFile,
-  ViewChangeLog,
-  ViewCheckResults,
-} from './components'
+import { AddFeature } from './components'
 import ApolloPluginConfigurationSchema from './config'
 import {
   annotationFromJBrowseFeature,
@@ -73,6 +72,7 @@ import {
   LinearApolloDisplayComponent,
   LinearApolloSixFrameDisplayComponent,
 } from './makeDisplayComponent'
+import { addTopLevelMenus } from './menus'
 import { type ApolloSessionModel, extendSession } from './session'
 
 interface RpcHandle {
@@ -106,6 +106,10 @@ for (const [changeName, change] of Object.entries(changes)) {
 
 const cdsCheck = new CDSCheck()
 checkRegistry.registerCheck(cdsCheck.name, cdsCheck)
+
+const transcriptCheck = new TranscriptCheck()
+checkRegistry.registerCheck(transcriptCheck.name, transcriptCheck)
+
 validationRegistry.registerValidation(new CoreValidation())
 validationRegistry.registerValidation(new ParentChildValidation())
 
@@ -201,6 +205,22 @@ export default class ApolloPlugin extends Plugin {
       })
     })
 
+    pluginManager.addDisplayType(() => {
+      const configSchema = linearApolloReferenceSequenceDisplayConfigSchema
+      return new DisplayType({
+        name: 'LinearApolloReferenceSequenceDisplay',
+        configSchema,
+        stateModel: LinearApolloReferenceSequenceDisplayStateModelFactory(
+          pluginManager,
+          configSchema,
+        ),
+        displayName: 'Apollo reference sequence display',
+        trackType: 'ReferenceSequenceTrack',
+        viewType: 'LinearGenomeView',
+        ReactComponent: LinearApolloReferenceSequenceDisplay,
+      })
+    })
+
     pluginManager.addToExtensionPoint(
       'Core-extendSession',
       // @ts-expect-error not sure how to deal with snapshot model types
@@ -357,103 +377,20 @@ export default class ApolloPlugin extends Plugin {
 
   configure(pluginManager: PluginManager) {
     if (isAbstractMenuManager(pluginManager.rootModel)) {
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'Download GFF3',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              DownloadGFF3,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-              },
-            ],
-          )
-        },
-      })
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'Manage Checks',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              ManageChecks,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-              },
-            ],
-          )
-        },
-      })
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'View Change Log',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              ViewChangeLog,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-              },
-            ],
-          )
-        },
-      })
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'Open local GFF3 file',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              OpenLocalFile,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-                inMemoryFileDriver: session.apolloDataStore.inMemoryFileDriver,
-              },
-            ],
-          )
-        },
-      })
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'View check results',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              ViewCheckResults,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-              },
-            ],
-          )
-        },
-      })
-      pluginManager.rootModel.appendToMenu('Apollo', {
-        label: 'Log out',
-        onClick: (session: ApolloSessionModel) => {
-          ;(session as unknown as AbstractSessionModel).queueDialog(
-            (doneCallback) => [
-              LogOut,
-              {
-                session,
-                handleClose: () => {
-                  doneCallback()
-                },
-              },
-            ],
-          )
+      pluginManager.jexl.addFunction(
+        'colorFeature',
+        (featureType: 'pseudogenic_transcript' | 'nonCodingTranscript') => {
+          if (featureType === 'pseudogenic_transcript') {
+            return alpha('rgb(148, 203, 236)', 0.6)
+          }
+          if (featureType === 'nonCodingTranscript') {
+            return alpha('rgb(194, 106, 119)', 0.6)
+          }
+          throw new Error('Invalid type')
         },
-      })
+      )
+
+      addTopLevelMenus(pluginManager.rootModel)
     }
   }
 }

package/src/makeDisplayComponent.tsx

@@ -19,7 +19,6 @@ const accordionControlHeight = 12
 const useStyles = makeStyles()((theme) => ({
   shading: {
     background: alpha(theme.palette.primary.main, 0.2),
-    overflowY: 'scroll',
     overflowX: 'hidden',
   },
   details: {

package/src/menus/index.ts

@@ -0,0 +1 @@
+export { addTopLevelMenus } from './topLevelMenu'

package/src/{ApolloInternetAccount/addMenuItems.ts → menus/topLevelMenu.ts}

@@ -2,112 +2,139 @@ import {
   type AbstractMenuManager,
   type AbstractSessionModel,
 } from '@jbrowse/core/util'
+import DownloadIcon from '@mui/icons-material/Download'
+import FactCheckIcon from '@mui/icons-material/FactCheck'
+import FileOpenIcon from '@mui/icons-material/FileOpen'
+import LogoutIcon from '@mui/icons-material/Logout'
+import RedoIcon from '@mui/icons-material/Redo'
+import TrackChangesIcon from '@mui/icons-material/TrackChanges'
+import UndoIcon from '@mui/icons-material/Undo'
 
 import {
-  AddAssembly,
-  AddRefSeqAliases,
-  DeleteAssembly,
-  ImportFeatures,
-  ManageUsers,
+  DownloadGFF3,
+  LogOut,
+  OpenLocalFile,
+  ViewChangeLog,
+  ViewCheckResults,
 } from '../components'
 import { type ApolloSessionModel } from '../session'
 
-export function addMenuItems(rootModel: AbstractMenuManager) {
+export function addTopLevelMenus(rootModel: AbstractMenuManager) {
+  rootModel.insertInMenu(
+    'Apollo',
+    {
+      label: 'Redo',
+      icon: RedoIcon,
+      onClick(session: ApolloSessionModel) {
+        const { apolloDataStore } = session
+        void apolloDataStore.changeManager.redoLastChange()
+      },
+    },
+    0,
+  )
+  rootModel.insertInMenu(
+    'Apollo',
+    {
+      label: 'Undo',
+      icon: UndoIcon,
+      onClick(session: ApolloSessionModel) {
+        const { apolloDataStore } = session
+        void apolloDataStore.changeManager.undoLastChange()
+      },
+    },
+    0,
+  )
+
   rootModel.appendToMenu('Apollo', {
-    label: 'Add Assembly',
+    label: 'Download GFF3',
+    icon: DownloadIcon,
     onClick: (session: ApolloSessionModel) => {
       ;(session as unknown as AbstractSessionModel).queueDialog(
         (doneCallback) => [
-          AddAssembly,
+          DownloadGFF3,
           {
             session,
             handleClose: () => {
               doneCallback()
             },
-            changeManager: session.apolloDataStore.changeManager,
           },
         ],
       )
     },
   })
   rootModel.appendToMenu('Apollo', {
-    label: 'Delete Assembly',
+    label: 'View Change Log',
+    icon: TrackChangesIcon,
     onClick: (session: ApolloSessionModel) => {
       ;(session as unknown as AbstractSessionModel).queueDialog(
         (doneCallback) => [
-          DeleteAssembly,
+          ViewChangeLog,
           {
             session,
             handleClose: () => {
               doneCallback()
             },
-            changeManager: session.apolloDataStore.changeManager,
           },
         ],
       )
     },
   })
   rootModel.appendToMenu('Apollo', {
-    label: 'Import Features',
+    label: 'Open local GFF3 file',
+    icon: FileOpenIcon,
     onClick: (session: ApolloSessionModel) => {
       ;(session as unknown as AbstractSessionModel).queueDialog(
         (doneCallback) => [
-          ImportFeatures,
+          OpenLocalFile,
           {
             session,
             handleClose: () => {
               doneCallback()
             },
-            changeManager: session.apolloDataStore.changeManager,
+            inMemoryFileDriver: session.apolloDataStore.inMemoryFileDriver,
           },
         ],
       )
     },
   })
   rootModel.appendToMenu('Apollo', {
-    label: 'Add reference sequence aliases',
+    label: 'View check results',
+    icon: FactCheckIcon,
     onClick: (session: ApolloSessionModel) => {
       ;(session as unknown as AbstractSessionModel).queueDialog(
         (doneCallback) => [
-          AddRefSeqAliases,
+          ViewCheckResults,
           {
             session,
             handleClose: () => {
               doneCallback()
             },
-            changeManager: session.apolloDataStore.changeManager,
           },
         ],
       )
     },
   })
   rootModel.appendToMenu('Apollo', {
-    label: 'Manage Users',
+    label: 'Lock/Unlock session',
+    onClick: (session: ApolloSessionModel) => {
+      session.toggleLocked()
+    },
+  })
+  rootModel.appendToMenu('Apollo', {
+    label: 'Log out',
+    icon: LogoutIcon,
     onClick: (session: ApolloSessionModel) => {
       ;(session as unknown as AbstractSessionModel).queueDialog(
         (doneCallback) => [
-          ManageUsers,
+          LogOut,
           {
             session,
             handleClose: () => {
               doneCallback()
             },
-            changeManager: session.apolloDataStore.changeManager,
           },
         ],
       )
     },
   })
-  rootModel.appendToMenu('Apollo', {
-    label: 'Undo',
-    onClick: (session: ApolloSessionModel) => {
-      const { apolloDataStore } = session
-      const { notify } = session as unknown as AbstractSessionModel
-      if (apolloDataStore.changeManager.recentChanges.length > 0) {
-        void apolloDataStore.changeManager.revertLastChange()
-      } else {
-        notify('No changes to undo', 'info')
-      }
-    },
-  })
 }