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

package/src/menus/topLevelMenuAdmin.ts

@@ -0,0 +1,154 @@
+import {
+  type AbstractMenuManager,
+  type AbstractSessionModel,
+} from '@jbrowse/core/util'
+import AddIcon from '@mui/icons-material/Add'
+import AdminPanelSettingsIcon from '@mui/icons-material/AdminPanelSettings'
+import DeleteIcon from '@mui/icons-material/Delete'
+import InputIcon from '@mui/icons-material/Input'
+import PersonIcon from '@mui/icons-material/Person'
+import RuleIcon from '@mui/icons-material/Rule'
+
+import {
+  AddAssembly,
+  AddAssemblyAliases,
+  AddRefSeqAliases,
+  DeleteAssembly,
+  ImportFeatures,
+  ManageChecks,
+  ManageUsers,
+} from '../components'
+import { type ApolloSessionModel } from '../session'
+
+export function addTopLevelAdminMenus(rootModel: AbstractMenuManager) {
+  rootModel.appendToMenu('Apollo', {
+    label: 'Admin',
+    type: 'subMenu',
+    icon: AdminPanelSettingsIcon,
+    subMenu: [
+      {
+        label: 'Add Assembly',
+        icon: AddIcon,
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              AddAssembly,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Delete Assembly',
+        icon: DeleteIcon,
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              DeleteAssembly,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Import Features',
+        icon: InputIcon,
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              ImportFeatures,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Add reference sequence aliases',
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              AddRefSeqAliases,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Add Assembly aliases',
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              AddAssemblyAliases,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Manage Users',
+        icon: PersonIcon,
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              ManageUsers,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+                changeManager: session.apolloDataStore.changeManager,
+              },
+            ],
+          )
+        },
+      },
+      {
+        label: 'Manage Checks',
+        icon: RuleIcon,
+        onClick: (session: ApolloSessionModel) => {
+          ;(session as unknown as AbstractSessionModel).queueDialog(
+            (doneCallback) => [
+              ManageChecks,
+              {
+                session,
+                handleClose: () => {
+                  doneCallback()
+                },
+              },
+            ],
+          )
+        },
+      },
+    ],
+  })
+}

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,
@@ -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'
 
@@ -53,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,
@@ -69,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>([])
 
@@ -94,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(
@@ -126,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: {
@@ -183,120 +207,155 @@ export function extendSession(
         }
       },
     }))
+    .volatile((self) => ({
+      previousSnapshot: getSnapshot(self),
+    }))
     .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
-            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 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 { 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 { 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
                 }
-                internetAccount.postUserLocation(allLocations)
+                if (!response.ok) {
+                  const errorMessage = await createFetchErrorMessage(
+                    response,
+                    'Failed to fetch assemblies',
+                  )
+                  console.error(errorMessage)
+                  continue
+                }
+                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' },
+          ),
         )
-        // END AUTORUN
-
-        // 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
-          }
-          applySnapshot(jbrowse, jbrowseConfig)
-          // @ts-expect-error snapshot seems to get wrong type?
-          applySnapshot(self, sessionSnapshot)
-        }
-      }),
+      },
       beforeDestroy() {
-        aborter.abort('destroying session model')
+        self.abortController.abort('destroying session model')
       },
     }))
 

package/src/util/annotationFeatureUtils.ts

@@ -51,3 +51,62 @@ 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 getRelatedFeatures(
+  feature: AnnotationFeature,
+  bp: number,
+  includeSiblings = false,
+): AnnotationFeature[] {
+  const relatedFeatures: AnnotationFeature[] = []
+  relatedFeatures.push(feature)
+  for (const x of getParents(feature)) {
+    relatedFeatures.push(x)
+  }
+  const children = getChildren(feature)
+  for (const child of children) {
+    if (child.min < bp && child.max >= bp) {
+      relatedFeatures.push(child)
+    }
+  }
+  if (!includeSiblings) {
+    return relatedFeatures
+  }
+
+  // Also add siblings , i.e. features having the same parent as the clicked
+  // one and intersecting the click position
+  if (feature.parent) {
+    const siblings = feature.parent.children
+    if (siblings) {
+      for (const [, sib] of siblings) {
+        if (sib._id == feature._id) {
+          continue
+        }
+        if (sib.min < bp && sib.max >= bp) {
+          relatedFeatures.push(sib)
+        }
+      }
+    }
+  }
+  return relatedFeatures
+}

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)
+}