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

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/session/session.ts

@@ -36,6 +36,7 @@ import {
 import { type ApolloInternetAccountModel } from '../ApolloInternetAccount/model'
 import { ApolloJobModel } from '../ApolloJobModel'
 import { type ChangeManager } from '../ChangeManager'
+import type ApolloPluginConfigurationSchema from '../config'
 import { type ApolloRootModel } from '../types'
 import { createFetchErrorMessage } from '../util'
 
@@ -185,15 +186,6 @@ export function extendSession(
     }))
     .actions((self) => ({
       afterCreate: flow(function* afterCreate() {
-        // When the initial config.json loads, it doesn't include the Apollo
-        // tracks, which would result in a potentially invalid session snapshot
-        // if any tracks are open. Here we copy the session snapshot, apply an
-        // empty session snapshot, and then restore the original session
-        // snapshot after the updated config.json loads.
-        const sessionSnapshot = getSnapshot(self)
-        const { id, name } = sessionSnapshot
-        applySnapshot(self, { name, id })
-        const { internetAccounts, jbrowse } = getRoot<ApolloRootModel>(self)
         autorun(
           () => {
             // broadcastLocations() // **** This is not working and therefore we need to duplicate broadcastLocations() -method code here because autorun() does not observe changes otherwise
@@ -254,7 +246,29 @@ export function extendSession(
           },
           { name: 'ApolloSession' },
         )
-        // END AUTORUN
+        // When the initial config.json loads, it doesn't include the Apollo
+        // tracks, which would result in a potentially invalid session snapshot
+        // if any tracks are open. Here we copy the session snapshot, apply an
+        // empty session snapshot, and then restore the original session
+        // snapshot after the updated config.json loads.
+        // @ts-expect-error type is missing on ApolloRootModel
+        const { internetAccounts, jbrowse, reloadPluginManagerCallback } =
+          getRoot<ApolloRootModel>(self)
+        const pluginConfiguration =
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          jbrowse.configuration.ApolloPlugin as Instance<
+            typeof ApolloPluginConfigurationSchema
+          >
+        const hasRole = readConfObject(
+          pluginConfiguration,
+          'hasRole',
+        ) as boolean
+        if (hasRole) {
+          return
+        }
+        const sessionSnapshot = getSnapshot(self)
+        const { id, name } = sessionSnapshot
+        applySnapshot(self, { name, id })
 
         // fetch and initialize assemblies for each of our Apollo internet accounts
         for (const internetAccount of internetAccounts as ApolloInternetAccountModel[]) {
@@ -290,9 +304,8 @@ export function extendSession(
             console.error(error)
             continue
           }
-          applySnapshot(jbrowse, jbrowseConfig)
-          // @ts-expect-error snapshot seems to get wrong type?
-          applySnapshot(self, sessionSnapshot)
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          reloadPluginManagerCallback(jbrowseConfig, sessionSnapshot)
         }
       }),
       beforeDestroy() {

package/src/util/annotationFeatureUtils.ts

@@ -1,5 +1,7 @@
 import { type AnnotationFeature } from '@apollo-annotation/mst'
 
+import { type MousePosition } from '../LinearApolloDisplay/stateModel/mouseEvents'
+
 export function getFeatureName(feature: AnnotationFeature) {
   const { attributes } = feature
   const name = attributes.get('gff_name')
@@ -51,3 +53,66 @@ export function getStrand(strand: number | undefined) {
   }
   return ''
 }
+
+function getChildren(feature: AnnotationFeature): AnnotationFeature[] {
+  const children: AnnotationFeature[] = []
+  //
+  if (feature.children) {
+    for (const [, ff] of feature.children) {
+      children.push(ff)
+    }
+  }
+  return children
+}
+
+function getParents(feature: AnnotationFeature): AnnotationFeature[] {
+  const parents: AnnotationFeature[] = []
+  let { parent } = feature
+  while (parent) {
+    parents.push(parent)
+    ;({ parent } = parent)
+  }
+  return parents
+}
+
+export function getFeaturesUnderClick(
+  mousePosition: MousePosition,
+  includeSiblings = false,
+): AnnotationFeature[] {
+  const clickedFeatures: AnnotationFeature[] = []
+  if (!mousePosition.featureAndGlyphUnderMouse) {
+    return clickedFeatures
+  }
+  clickedFeatures.push(mousePosition.featureAndGlyphUnderMouse.feature)
+  for (const x of getParents(mousePosition.featureAndGlyphUnderMouse.feature)) {
+    clickedFeatures.push(x)
+  }
+  const { bp } = mousePosition
+  const children = getChildren(mousePosition.featureAndGlyphUnderMouse.feature)
+  for (const child of children) {
+    if (child.min < bp && child.max >= bp) {
+      clickedFeatures.push(child)
+    }
+  }
+  if (!includeSiblings) {
+    return clickedFeatures
+  }
+
+  // Also add siblings , i.e. features having the same parent as the clicked
+  // one and intersecting the click position
+  if (mousePosition.featureAndGlyphUnderMouse.feature.parent) {
+    const siblings =
+      mousePosition.featureAndGlyphUnderMouse.feature.parent.children
+    if (siblings) {
+      for (const [, sib] of siblings) {
+        if (sib._id == mousePosition.featureAndGlyphUnderMouse.feature._id) {
+          continue
+        }
+        if (sib.min < bp && sib.max >= bp) {
+          clickedFeatures.push(sib)
+        }
+      }
+    }
+  }
+  return clickedFeatures
+}

package/src/util/copyToClipboard.ts

@@ -0,0 +1,21 @@
+export async function copyToClipboard(element: HTMLElement) {
+  if (isSecureContext) {
+    const textBlob = new Blob([element.outerText], { type: 'text/plain' })
+    const htmlBlob = new Blob([element.outerHTML], { type: 'text/html' })
+    const clipboardItem = new ClipboardItem({
+      [textBlob.type]: textBlob,
+      [htmlBlob.type]: htmlBlob,
+    })
+    return navigator.clipboard.write([clipboardItem])
+  }
+  const copyCallback = (event: ClipboardEvent) => {
+    event.clipboardData?.setData('text/plain', element.outerText)
+    event.clipboardData?.setData('text/html', element.outerHTML)
+    event.preventDefault()
+  }
+  document.addEventListener('copy', copyCallback)
+  // fall back to deprecated only in non-secure contexts
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  document.execCommand('copy')
+  document.removeEventListener('copy', copyCallback)
+}

package/src/util/glyphUtils.ts

@@ -0,0 +1,49 @@
+import {
+  type AnnotationFeature,
+  type TranscriptPartCoding,
+} from '@apollo-annotation/mst'
+import { type LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
+
+export function getMinAndMaxPx(
+  feature: AnnotationFeature | TranscriptPartCoding,
+  refName: string,
+  regionNumber: number,
+  lgv: LinearGenomeViewModel,
+): [number, number] | undefined {
+  const minPxInfo = lgv.bpToPx({
+    refName,
+    coord: feature.min,
+    regionNumber,
+  })
+  const maxPxInfo = lgv.bpToPx({
+    refName,
+    coord: feature.max,
+    regionNumber,
+  })
+  if (minPxInfo === undefined || maxPxInfo === undefined) {
+    return
+  }
+  const { offsetPx } = lgv
+  const minPx = minPxInfo.offsetPx - offsetPx
+  const maxPx = maxPxInfo.offsetPx - offsetPx
+  return [minPx, maxPx]
+}
+
+export function getOverlappingEdge(
+  feature: AnnotationFeature,
+  x: number,
+  minMax: [number, number],
+): { feature: AnnotationFeature; edge: 'min' | 'max' } | undefined {
+  const [minPx, maxPx] = minMax
+  // Feature is too small to tell if we're overlapping an edge
+  if (Math.abs(maxPx - minPx) < 8) {
+    return
+  }
+  if (Math.abs(minPx - x) < 4) {
+    return { feature, edge: 'min' }
+  }
+  if (Math.abs(maxPx - x) < 4) {
+    return { feature, edge: 'max' }
+  }
+  return
+}

package/src/util/index.ts

@@ -30,3 +30,5 @@ export function getApolloInternetAccount(session: ApolloSessionModel) {
 
 export * from './loadAssemblyIntoClient'
 export * from './annotationFeatureUtils'
+export * from './glyphUtils'
+export * from './mouseEventsUtils'

package/src/util/mouseEventsUtils.ts

@@ -0,0 +1,113 @@
+import { type AnnotationFeature } from '@apollo-annotation/mst'
+
+type MinEdge = 'min'
+type MaxEdge = 'max'
+export type Edge = MinEdge | MaxEdge
+
+interface LocationChange {
+  featureId: string
+  oldLocation: number
+  newLocation: number
+}
+
+function expandFeatures(
+  feature: AnnotationFeature,
+  newLocation: number,
+  edge: Edge,
+): LocationChange[] {
+  const featureId = feature._id
+  const oldLocation = feature[edge]
+  const changes: LocationChange[] = [{ featureId, oldLocation, newLocation }]
+  const { parent } = feature
+  if (
+    parent &&
+    ((edge === 'min' && parent[edge] > newLocation) ||
+      (edge === 'max' && parent[edge] < newLocation))
+  ) {
+    changes.push(...expandFeatures(parent, newLocation, edge))
+  }
+  return changes
+}
+
+function shrinkFeatures(
+  feature: AnnotationFeature,
+  newLocation: number,
+  edge: Edge,
+  shrinkParent: boolean,
+  childIdToSkip?: string,
+): LocationChange[] {
+  const featureId = feature._id
+  const oldLocation = feature[edge]
+  const changes: LocationChange[] = [{ featureId, oldLocation, newLocation }]
+  const { parent, children } = feature
+  if (children) {
+    for (const [, child] of children) {
+      if (child._id === childIdToSkip) {
+        continue
+      }
+      if (
+        (edge === 'min' && child[edge] < newLocation) ||
+        (edge === 'max' && child[edge] > newLocation)
+      ) {
+        changes.push(...shrinkFeatures(child, newLocation, edge, shrinkParent))
+      }
+    }
+  }
+  if (parent && shrinkParent) {
+    const siblings: AnnotationFeature[] = []
+    if (parent.children) {
+      for (const [, c] of parent.children) {
+        if (c._id === featureId) {
+          continue
+        }
+        siblings.push(c)
+      }
+    }
+    if (siblings.length === 0) {
+      changes.push(
+        ...shrinkFeatures(parent, newLocation, edge, shrinkParent, featureId),
+      )
+    } else {
+      const oldLocation = parent[edge]
+      const boundedLocation = Math[edge](
+        ...siblings.map((s) => s[edge]),
+        newLocation,
+      )
+      if (boundedLocation !== oldLocation) {
+        changes.push(
+          ...shrinkFeatures(
+            parent,
+            boundedLocation,
+            edge,
+            shrinkParent,
+            featureId,
+          ),
+        )
+      }
+    }
+  }
+  return changes
+}
+
+export function getPropagatedLocationChanges(
+  feature: AnnotationFeature,
+  newLocation: number,
+  edge: Edge,
+  shrinkParent = false,
+): LocationChange[] {
+  const oldLocation = feature[edge]
+  if (newLocation === oldLocation) {
+    throw new Error(`New and existing locations are the same: "${newLocation}"`)
+  }
+  if (edge === 'min') {
+    if (newLocation > oldLocation) {
+      // shrinking feature, may need to shrink children and/or parents
+      return shrinkFeatures(feature, newLocation, edge, shrinkParent)
+    }
+    return expandFeatures(feature, newLocation, edge)
+  }
+  if (newLocation < oldLocation) {
+    return shrinkFeatures(feature, newLocation, edge, shrinkParent)
+  }
+  return expandFeatures(feature, newLocation, edge)
+}