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

package/src/session/session.ts

@@ -26,8 +26,8 @@ import { autorun, observable } from 'mobx'
 import {
   type Instance,
   type SnapshotOut,
+  addDisposer,
   applySnapshot,
-  flow,
   getRoot,
   getSnapshot,
   types,
@@ -54,12 +54,15 @@ export interface Collaborator {
   locations: UserLocation[]
 }
 
+export interface HoveredFeature {
+  feature: AnnotationFeature
+  bp: number
+}
+
 export function extendSession(
   pluginManager: PluginManager,
   sessionModel: ReturnType<typeof types.model>,
 ) {
-  const aborter = new AbortController()
-  const { signal } = aborter
   const AnnotationFeatureExtended = pluginManager.evaluateExtensionPoint(
     'Apollo-extendAnnotationFeature',
     AnnotationFeatureModel,
@@ -70,7 +73,12 @@ export function extendSession(
       apolloDataStore: types.optional(ClientDataStore, { typeName: 'Client' }),
       apolloSelectedFeature: types.safeReference(AnnotationFeatureExtended),
       jobsManager: types.optional(ApolloJobModel, {}),
+      isLocked: types.optional(types.boolean, false),
     })
+    .volatile(() => ({
+      apolloHoveredFeature: undefined as HoveredFeature | undefined,
+      abortController: new AbortController(),
+    }))
     .extend(() => {
       const collabs = observable.array<Collaborator>([])
 
@@ -95,10 +103,13 @@ export function extendSession(
       }
     })
     .actions((self) => ({
-      apolloSetSelectedFeature(feature?: AnnotationFeature) {
+      apolloSetSelectedFeature(feature?: AnnotationFeature | string) {
         // @ts-expect-error Not sure why TS thinks these MST types don't match
         self.apolloSelectedFeature = feature
       },
+      apolloSetHoveredFeature(feature?: HoveredFeature) {
+        self.apolloHoveredFeature = feature
+      },
       addApolloTrackConfig(assembly: AssemblyModel, baseURL?: string) {
         const trackId = `apollo_track_${assembly.name}`
         const hasTrack = (self as unknown as AbstractSessionModel).tracks.some(
@@ -127,6 +138,18 @@ export function extendSession(
           })
         }
       },
+      toggleLocked() {
+        self.isLocked = !self.isLocked
+      },
+      getPluginConfiguration() {
+        const { jbrowse } = getRoot<ApolloRootModel>(self)
+        const pluginConfiguration =
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          jbrowse.configuration.ApolloPlugin as Instance<
+            typeof ApolloPluginConfigurationSchema
+          >
+        return pluginConfiguration
+      },
       broadcastLocations() {
         const { internetAccounts } = getRoot<ApolloRootModel>(self)
         const locations: {
@@ -184,132 +207,155 @@ export function extendSession(
         }
       },
     }))
+    .volatile((self) => ({
+      previousSnapshot: getSnapshot(self),
+    }))
     .actions((self) => ({
-      afterCreate: flow(function* afterCreate() {
-        autorun(
-          () => {
-            // broadcastLocations() // **** This is not working and therefore we need to duplicate broadcastLocations() -method code here because autorun() does not observe changes otherwise
-            const locations: {
-              assemblyName: string
-              refName: string
-              start: number
-              end: number
-            }[] = []
-            for (const view of (self as unknown as AbstractSessionModel)
-              .views) {
-              if (view.type !== 'LinearGenomeView') {
-                return
-              }
-              const lgv = view as unknown as LinearGenomeViewModel
-              if (lgv.initialized) {
-                const { dynamicBlocks } = lgv
-                // eslint-disable-next-line unicorn/no-array-for-each
-                dynamicBlocks.forEach((block) => {
-                  if (block.regionNumber !== undefined) {
-                    const { assemblyName, end, refName, start } = block
-                    const assembly =
-                      self.apolloDataStore.assemblies.get(assemblyName)
-                    if (
-                      assembly &&
-                      assembly.backendDriverType === 'CollaborationServerDriver'
-                    ) {
-                      locations.push({ assemblyName, refName, start, end })
+      afterCreate() {
+        applySnapshot(self, { name: self.name, id: self.id })
+        // @ts-expect-error type is missing on ApolloRootModel
+        const { internetAccounts, jbrowse, reloadPluginManagerCallback } =
+          getRoot<ApolloRootModel>(self)
+        addDisposer(
+          self,
+          autorun(
+            () => {
+              // broadcastLocations() // **** This is not working and therefore we need to duplicate broadcastLocations() -method code here because autorun() does not observe changes otherwise
+              const locations: {
+                assemblyName: string
+                refName: string
+                start: number
+                end: number
+              }[] = []
+              for (const view of (self as unknown as AbstractSessionModel)
+                .views) {
+                if (view.type !== 'LinearGenomeView') {
+                  return
+                }
+                const lgv = view as unknown as LinearGenomeViewModel
+                if (lgv.initialized) {
+                  const { dynamicBlocks } = lgv
+                  // eslint-disable-next-line unicorn/no-array-for-each
+                  dynamicBlocks.forEach((block) => {
+                    if (block.regionNumber !== undefined) {
+                      const { assemblyName, end, refName, start } = block
+                      const assembly =
+                        self.apolloDataStore.assemblies.get(assemblyName)
+                      if (
+                        assembly &&
+                        assembly.backendDriverType ===
+                          'CollaborationServerDriver'
+                      ) {
+                        locations.push({ assemblyName, refName, start, end })
+                      }
                     }
+                  })
+                }
+              }
+              if (locations.length === 0) {
+                for (const internetAccount of internetAccounts) {
+                  if ('baseURL' in internetAccount) {
+                    internetAccount.postUserLocation([])
                   }
-                })
+                }
+                return
               }
-            }
-            if (locations.length === 0) {
+
+              const allLocations: UserLocation[] = []
               for (const internetAccount of internetAccounts) {
                 if ('baseURL' in internetAccount) {
-                  internetAccount.postUserLocation([])
+                  for (const location of locations) {
+                    const tmpLoc: UserLocation = {
+                      assemblyId: location.assemblyName,
+                      refSeq: location.refName,
+                      start: location.start,
+                      end: location.end,
+                    }
+                    allLocations.push(tmpLoc)
+                  }
+                  internetAccount.postUserLocation(allLocations)
                 }
               }
-              return
-            }
+            },
+            { name: 'ApolloSessionBroadcastLocations' },
+          ),
+        )
+        addDisposer(
+          self,
+          autorun(
+            async (reaction) => {
+              // 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 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) {
+                // @ts-expect-error not sure why snapshot type is wrong for snapshot
+                applySnapshot(self, self.previousSnapshot)
+                reaction.dispose()
+                return
+              }
+
+              const { signal } = self.abortController
+              // fetch and initialize assemblies for each of our Apollo internet accounts
+              for (const internetAccount of internetAccounts as ApolloInternetAccountModel[]) {
+                if (internetAccount.type !== 'ApolloInternetAccount') {
+                  continue
+                }
 
-            const allLocations: UserLocation[] = []
-            for (const internetAccount of internetAccounts) {
-              if ('baseURL' in internetAccount) {
-                for (const location of locations) {
-                  const tmpLoc: UserLocation = {
-                    assemblyId: location.assemblyName,
-                    refSeq: location.refName,
-                    start: location.start,
-                    end: location.end,
+                const { baseURL } = internetAccount
+                const uri = new URL('jbrowse/config.json', baseURL).href
+                const fetch = internetAccount.getFetcher({
+                  locationType: 'UriLocation',
+                  uri,
+                })
+                let response: Response
+                try {
+                  response = await fetch(uri, { signal })
+                } catch (error) {
+                  if (!self.abortController.signal.aborted) {
+                    console.error(error)
                   }
-                  allLocations.push(tmpLoc)
+                  continue
+                }
+                if (!response.ok) {
+                  const errorMessage = await createFetchErrorMessage(
+                    response,
+                    'Failed to fetch assemblies',
+                  )
+                  console.error(errorMessage)
+                  continue
                 }
-                internetAccount.postUserLocation(allLocations)
+                let jbrowseConfig
+                try {
+                  jbrowseConfig = await response.json()
+                } catch (error) {
+                  console.error(error)
+                  continue
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                reloadPluginManagerCallback(
+                  jbrowseConfig,
+                  self.previousSnapshot,
+                )
+                reaction.dispose()
               }
-            }
-          },
-          { name: 'ApolloSession' },
+            },
+            { name: 'ApolloSessionLoadConfig' },
+          ),
         )
-        // 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[]) {
-          if (internetAccount.type !== 'ApolloInternetAccount') {
-            continue
-          }
-
-          const { baseURL } = internetAccount
-          const uri = new URL('jbrowse/config.json', baseURL).href
-          const fetch = internetAccount.getFetcher({
-            locationType: 'UriLocation',
-            uri,
-          })
-          let response: Response
-          try {
-            response = yield fetch(uri, { signal })
-          } catch (error) {
-            console.error(error)
-            continue
-          }
-          if (!response.ok) {
-            const errorMessage = yield createFetchErrorMessage(
-              response,
-              'Failed to fetch assemblies',
-            )
-            console.error(errorMessage)
-            continue
-          }
-          let jbrowseConfig
-          try {
-            jbrowseConfig = yield response.json()
-          } catch (error) {
-            console.error(error)
-            continue
-          }
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          reloadPluginManagerCallback(jbrowseConfig, sessionSnapshot)
-        }
-      }),
+      },
       beforeDestroy() {
-        aborter.abort('destroying session model')
+        self.abortController.abort('destroying session model')
       },
     }))
 

package/src/util/annotationFeatureUtils.ts

@@ -1,7 +1,5 @@
 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')
@@ -75,44 +73,40 @@ function getParents(feature: AnnotationFeature): AnnotationFeature[] {
   return parents
 }
 
-export function getFeaturesUnderClick(
-  mousePosition: MousePosition,
+export function getRelatedFeatures(
+  feature: AnnotationFeature,
+  bp: number,
   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 relatedFeatures: AnnotationFeature[] = []
+  relatedFeatures.push(feature)
+  for (const x of getParents(feature)) {
+    relatedFeatures.push(x)
   }
-  const { bp } = mousePosition
-  const children = getChildren(mousePosition.featureAndGlyphUnderMouse.feature)
+  const children = getChildren(feature)
   for (const child of children) {
     if (child.min < bp && child.max >= bp) {
-      clickedFeatures.push(child)
+      relatedFeatures.push(child)
     }
   }
   if (!includeSiblings) {
-    return clickedFeatures
+    return relatedFeatures
   }
 
   // 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 (feature.parent) {
+    const siblings = feature.parent.children
     if (siblings) {
       for (const [, sib] of siblings) {
-        if (sib._id == mousePosition.featureAndGlyphUnderMouse.feature._id) {
+        if (sib._id == feature._id) {
           continue
         }
         if (sib.min < bp && sib.max >= bp) {
-          clickedFeatures.push(sib)
+          relatedFeatures.push(sib)
         }
       }
     }
   }
-  return clickedFeatures
+  return relatedFeatures
 }

package/src/util/displayUtils.ts

@@ -0,0 +1,149 @@
+import { type CheckResultIdsType } from '@apollo-annotation/mst'
+import { makeStyles } from 'tss-react/mui'
+
+export { default as EditZoomThresholdDialog } from '../components/EditZoomThresholdDialog'
+
+export type Coord = [number, number]
+
+export const useStyles = makeStyles()((theme) => ({
+  canvasContainer: {
+    position: 'relative',
+    left: 0,
+  },
+  canvas: {
+    position: 'absolute',
+    left: 0,
+  },
+  center: {
+    display: 'flex',
+    justifyContent: 'center',
+  },
+  ellipses: {
+    textOverflow: 'ellipsis',
+    overflow: 'hidden',
+  },
+  avatar: {
+    position: 'static',
+    height: '100%',
+    width: '100%',
+    overflow: 'visible',
+    color: theme.palette.warning.light,
+    backgroundColor: theme.palette.warning.contrastText,
+  },
+  box: {
+    position: 'absolute',
+    overflow: 'visible',
+  },
+  badge: {
+    display: 'inline-block',
+  },
+  loading: {
+    position: 'absolute',
+    right: theme.spacing(3),
+    zIndex: 10,
+    pointerEvents: 'none',
+    textAlign: 'right',
+  },
+  locked: {
+    position: 'absolute',
+    right: theme.spacing(3),
+    top: theme.spacing(6),
+    zIndex: 1,
+    pointerEvents: 'none',
+    textAlign: 'right',
+  },
+}))
+
+export interface CheckResultCluster<T> {
+  _id: string
+  message: string
+  start: number
+  count: number
+  members: T[]
+  range: { min: number; max: number }
+  featureIds: CheckResultIdsType
+}
+
+export function clusterResultByMessage<
+  T extends {
+    _id: string
+    start: number
+    end: number
+    message: string
+    ids: CheckResultIdsType
+  },
+>(
+  items: readonly T[],
+  width: number,
+  touchesAsOverlap: boolean,
+): CheckResultCluster<T>[] {
+  const byMsg = new Map<string, T[]>()
+  for (const it of items) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ;(byMsg.get(it.message) ?? byMsg.set(it.message, []).get(it.message)!).push(
+      it,
+    )
+  }
+
+  const clusters: CheckResultCluster<T>[] = []
+  const overlaps = (aEnd: number, bStart: number) =>
+    touchesAsOverlap ? bStart <= aEnd : bStart < aEnd
+
+  for (const [message, arr] of byMsg.entries()) {
+    if (arr.length === 0) {
+      continue
+    }
+
+    arr.sort((a, b) => a.start - b.start)
+
+    let group: T[] = [arr[0]]
+    let curMin = arr[0].start
+    let curMax = arr[0].start + width
+
+    const pushResult = () => {
+      const starts = group.map((d) => d.start).sort((a, b) => a - b)
+      const mid = Math.floor(starts.length / 2)
+      const median: number =
+        starts.length % 2 ? starts[mid] : (starts[mid - 1] + starts[mid]) / 2
+      const clusterId = group[0]._id
+      const featureIds = group[0].ids
+
+      clusters.push({
+        _id: clusterId,
+        message,
+        start: median,
+        count: group.length,
+        members: [...group],
+        range: { min: curMin, max: curMax },
+        featureIds,
+      })
+    }
+
+    for (let i = 1; i < arr.length; i++) {
+      const it = arr[i]
+      const itStart = it.start
+      const itEnd = itStart + width
+
+      if (overlaps(curMax, itStart)) {
+        group.push(it)
+        if (itStart < curMin) {
+          curMin = itStart
+        }
+        if (itEnd > curMax) {
+          curMax = itEnd
+        }
+      } else {
+        pushResult()
+        group = [it]
+        curMin = itStart
+        curMax = itEnd
+      }
+    }
+    pushResult()
+  }
+
+  clusters.sort(
+    (a, b) => a.message.localeCompare(b.message) || a.start - b.start,
+  )
+  return clusters
+}