@apollo-annotation/jbrowse-plugin-apollo 0.3.12 → 1.0.0

package/src/menus/Icons.tsx

@@ -0,0 +1,49 @@
+import { SvgIcon, type SvgIconProps } from '@mui/material'
+import React from 'react'
+
+// Icon source: https://developers.google.com/identity/branding-guidelines
+export function Apollo(props: SvgIconProps) {
+  return (
+    <SvgIcon
+      viewBox="0 0 856 855"
+      style={{ fontSize: 18, marginRight: 4 }}
+      {...props}
+    >
+      <g>
+        <path
+          style={{ opacity: 0.68, fill: '#AEAEAE' }}
+          d="M276.7,656.9l85-148h102.9c23.1,0,16.1-16,11.1-25l-134-238.5l85-148l185,315.6c0,0-15-26.3,0,0
+			c53,92.9-24,243.9-132,243.9c-6,0-4,0-6.4,0H276.7z"
+        />
+        <polygon
+          style={{ opacity: 0.85, fill: '#717171' }}
+          points="49.7,756.9 219.1,756.9 513.7,246.9 425.7,99.9 		"
+        />
+        <polygon
+          style={{ opacity: 0.85, fill: '#717171' }}
+          points="630,756.9 806.4,756.9 513.7,246.9 425.1,400.2 		"
+        />
+        <polygon
+          style={{ fill: '#C6C6C6' }}
+          points="175.7,657.3 195.6,657.3 277.9,508.9 254.1,508.9 170.6,657.3 		"
+        />
+        <polygon
+          style={{ fill: '#C6C6C6' }}
+          points="369.7,657.3 389.6,657.3 471.9,508.9 448.1,508.9 364.6,657.3 		"
+        />
+        <polygon
+          style={{ fill: '#C6C6C6' }}
+          points="321.7,657.3 341.6,657.3 423.9,508.9 400.1,508.9 316.6,657.3 		"
+        />
+        <polygon
+          style={{ fill: '#C6C6C6' }}
+          points="224.7,657.3 244.6,657.3 326.9,508.9 303.1,508.9 219.6,657.3 		"
+        />
+        <polygon
+          style={{ fill: '#C6C6C6' }}
+          points="273.7,657.3 293.6,657.3 375.9,508.9 352.1,508.9 268.6,657.3 		"
+        />
+      </g>
+    </SvgIcon>
+  )
+}

package/src/menus/topLevelMenu.ts

@@ -2,22 +2,13 @@ import type {
   AbstractMenuManager,
   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 {
-  DownloadGFF3,
-  LogOut,
-  OpenLocalFile,
-  ViewChangeLog,
-  ViewCheckResults,
-} from '../components'
+import { LogOut } from '../components'
 import type { ApolloSessionModel } from '../session'
+import { type ApolloRootModel, isApolloInternetAccount } from '../types'
 
 export function addTopLevelMenus(rootModel: AbstractMenuManager) {
   rootModel.insertInMenu(
@@ -45,96 +36,33 @@ export function addTopLevelMenus(rootModel: AbstractMenuManager) {
     0,
   )
 
-  rootModel.appendToMenu('Apollo', {
-    label: 'Download GFF3',
-    icon: DownloadIcon,
-    onClick: (session: ApolloSessionModel) => {
-      ;(session as unknown as AbstractSessionModel).queueDialog(
-        (doneCallback) => [
-          DownloadGFF3,
-          {
-            session,
-            handleClose: () => {
-              doneCallback()
-            },
-          },
-        ],
-      )
-    },
-  })
-  rootModel.appendToMenu('Apollo', {
-    label: 'View Change Log',
-    icon: TrackChangesIcon,
-    onClick: (session: ApolloSessionModel) => {
-      ;(session as unknown as AbstractSessionModel).queueDialog(
-        (doneCallback) => [
-          ViewChangeLog,
-          {
-            session,
-            handleClose: () => {
-              doneCallback()
-            },
-          },
-        ],
-      )
-    },
-  })
-  rootModel.appendToMenu('Apollo', {
-    label: 'Open local GFF3 file',
-    icon: FileOpenIcon,
-    onClick: (session: ApolloSessionModel) => {
-      ;(session as unknown as AbstractSessionModel).queueDialog(
-        (doneCallback) => [
-          OpenLocalFile,
-          {
-            session,
-            handleClose: () => {
-              doneCallback()
-            },
-            inMemoryFileDriver: session.apolloDataStore.inMemoryFileDriver,
-          },
-        ],
-      )
-    },
-  })
-  rootModel.appendToMenu('Apollo', {
-    label: 'View check results',
-    icon: FactCheckIcon,
-    onClick: (session: ApolloSessionModel) => {
-      ;(session as unknown as AbstractSessionModel).queueDialog(
-        (doneCallback) => [
-          ViewCheckResults,
-          {
-            session,
-            handleClose: () => {
-              doneCallback()
-            },
-          },
-        ],
-      )
-    },
-  })
   rootModel.appendToMenu('Apollo', {
     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) => [
-          LogOut,
-          {
-            session,
-            handleClose: () => {
-              doneCallback()
+  const { internetAccounts } = rootModel as unknown as ApolloRootModel
+  const hasApolloInternetAccount = internetAccounts.some((ia) =>
+    isApolloInternetAccount(ia),
+  )
+  if (hasApolloInternetAccount) {
+    rootModel.appendToMenu('Apollo', {
+      label: 'Log out',
+      icon: LogoutIcon,
+      onClick: (session: ApolloSessionModel) => {
+        ;(session as unknown as AbstractSessionModel).queueDialog(
+          (doneCallback) => [
+            LogOut,
+            {
+              session,
+              handleClose: () => {
+                doneCallback()
+              },
             },
-          },
-        ],
-      )
-    },
-  })
+          ],
+        )
+      },
+    })
+  }
 }

package/src/session/ClientDataStore.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import type { ClientDataStore as ClientDataStoreType } from '@apollo-annotation/common'
 import {
   type AnnotationFeatureModel,
   type AnnotationFeatureSnapshot,
@@ -18,7 +17,7 @@ import {
   getConf,
   readConfObject,
 } from '@jbrowse/core/configuration'
-import { type Region, getSession, isElectron } from '@jbrowse/core/util'
+import { type Region, getSession } from '@jbrowse/core/util'
 import type {
   LocalPathLocation,
   UriLocation,
@@ -38,8 +37,7 @@ import {
   type ApolloInternetAccount,
   type BackendDriver,
   CollaborationServerDriver,
-  DesktopFileDriver,
-  InMemoryFileDriver,
+  LocalDriver,
 } from '../BackendDrivers'
 import { ChangeManager } from '../ChangeManager'
 import {
@@ -158,16 +156,11 @@ export function clientDataStoreFactory(
       },
     }))
     .volatile((self) => ({
-      changeManager: new ChangeManager(self as unknown as ClientDataStoreType),
+      changeManager: new ChangeManager(self as ClientDataStoreModel),
       collaborationServerDriver: new CollaborationServerDriver(
-        self as unknown as ClientDataStoreType,
+        self as ClientDataStoreModel,
       ),
-      inMemoryFileDriver: new InMemoryFileDriver(
-        self as unknown as ClientDataStoreType,
-      ),
-      desktopFileDriver: isElectron
-        ? new DesktopFileDriver(self as unknown as ClientDataStoreType)
-        : undefined,
+      localDriver: new LocalDriver(self as ClientDataStoreModel),
     }))
     .actions((self) => ({
       afterCreate() {
@@ -245,17 +238,14 @@ export function clientDataStoreFactory(
         if (!assembly) {
           return
         }
-        const { file, internetAccountConfigId } = getConf(assembly, [
+        const { internetAccountConfigId } = getConf(assembly, [
           'sequence',
           'metadata',
         ]) as { internetAccountConfigId?: string; file: string }
-        if (isElectron && file) {
-          return self.desktopFileDriver
-        }
         if (internetAccountConfigId) {
           return self.collaborationServerDriver
         }
-        return self.inMemoryFileDriver
+        return self.localDriver
       },
       getInternetAccount(assemblyName?: string, internetAccountId?: string) {
         if (!(assemblyName ?? internetAccountId)) {
@@ -347,3 +337,12 @@ export function clientDataStoreFactory(
       }),
     }))
 }
+
+export type ClientDataStoreStateModel = ReturnType<
+  typeof clientDataStoreFactory
+>
+// eslint disable because of
+// https://mobx-state-tree.js.org/tips/typescript#using-a-mst-type-at-design-time
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ClientDataStoreModel
+  extends Instance<ClientDataStoreStateModel> {}

package/src/session/changeHandlers.ts

@@ -0,0 +1,261 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  attributesToRecords,
+  type localChanges,
+  stringifyAttributes,
+} from '@apollo-annotation/shared'
+
+import type { ClientDataStoreModel } from './ClientDataStore'
+
+type ChangeHandlers = {
+  [K in keyof typeof localChanges]: (
+    dataStore: ClientDataStoreModel,
+    change: InstanceType<(typeof localChanges)[K]>,
+  ) => Promise<void>
+}
+
+export function isLocalChange(
+  changeName: string,
+): changeName is keyof typeof localChanges {
+  return changeName in changeHandlers
+}
+
+export const changeHandlers: ChangeHandlers = {
+  async AddFeatureChange(dataStore, change) {
+    const { assembly, changes } = change
+    for (const c of changes) {
+      const { addedFeature, parentFeatureId } = c
+      if (parentFeatureId) {
+        let parentFeature = dataStore.getFeature(parentFeatureId)
+        // maybe the parent feature hasn't been loaded yet
+        if (!parentFeature) {
+          await dataStore.loadFeatures([
+            {
+              assemblyName: assembly,
+              refName: addedFeature.refSeq,
+              start: addedFeature.min,
+              end: addedFeature.max,
+            },
+          ])
+          parentFeature = dataStore.getFeature(parentFeatureId)
+          if (!parentFeature) {
+            throw new Error(
+              `Could not find parent feature "${parentFeatureId}"`,
+            )
+          }
+        }
+        // create an ID for the parent feature if it does not have one
+        if (!parentFeature.attributes.get('_id')) {
+          parentFeature.setAttribute('_id', [parentFeature._id])
+        }
+        parentFeature.addChild(addedFeature)
+      } else {
+        dataStore.addFeature(assembly, addedFeature)
+      }
+    }
+  },
+
+  async DeleteFeatureChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { deletedFeature, parentFeatureId } = c
+      if (parentFeatureId) {
+        const parentFeature = dataStore.getFeature(parentFeatureId)
+        if (!parentFeature) {
+          throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+        }
+        parentFeature.deleteChild(deletedFeature._id)
+      } else {
+        if (dataStore.getFeature(deletedFeature._id)) {
+          dataStore.deleteFeature(deletedFeature._id)
+        }
+      }
+    }
+  },
+
+  async FeatureAttributeChange(dataStore, change) {
+    for (const [idx, changedId] of change.changedIds.entries()) {
+      const feature = dataStore.getFeature(changedId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${changedId}"`)
+      }
+      feature.setAttributes(
+        new Map(Object.entries(change.changes[idx].newAttributes)),
+      )
+    }
+  },
+
+  async LocationEndChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { featureId, newEnd } = c
+      const feature = dataStore.getFeature(featureId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${featureId}"`)
+      }
+      feature.setMax(newEnd)
+    }
+  },
+
+  async LocationStartChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { featureId, newStart } = c
+      const feature = dataStore.getFeature(featureId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${featureId}"`)
+      }
+      feature.setMin(newStart)
+    }
+  },
+
+  async MergeExonsChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { firstExon, secondExon } = c
+      const mergedExon = dataStore.getFeature(firstExon._id)
+      if (!mergedExon) {
+        throw new Error(
+          `Could not find feature with identifier "${firstExon._id}"`,
+        )
+      }
+      mergedExon.setMin(Math.min(firstExon.min, secondExon.min))
+      mergedExon.setMax(Math.max(firstExon.max, secondExon.max))
+
+      const mrg = mergedExon.attributes.get('merged_with')?.slice() ?? []
+      const mergedWith = stringifyAttributes(
+        attributesToRecords(secondExon.attributes),
+      )
+      if (!mrg.includes(mergedWith)) {
+        mrg.push(mergedWith)
+      }
+      mergedExon.setAttribute('merged_with', mrg)
+
+      mergedExon.parent?.deleteChild(secondExon._id)
+    }
+  },
+
+  async SplitExonChange(dataStore, change) {
+    for (const [idx] of change.changedIds.entries()) {
+      const {
+        exonToBeSplit,
+        parentFeatureId,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      } = change.changes[idx]
+      if (!parentFeatureId) {
+        throw new Error('TODO: Split exon without parent')
+      }
+
+      const [leftExon, rightExon] = change.makeSplitExons(
+        exonToBeSplit,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      )
+
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+
+      parentFeature.addChild(leftExon)
+      parentFeature.addChild(rightExon)
+      if (dataStore.getFeature(exonToBeSplit._id)) {
+        dataStore.deleteFeature(exonToBeSplit._id)
+      }
+    }
+  },
+
+  async MergeTranscriptsChange(dataStore, change) {
+    for (const [idx, changedId] of change.changedIds.entries()) {
+      const { firstTranscript, secondTranscript } = change.changes[idx]
+      const mergedTranscript = dataStore.getFeature(firstTranscript._id)
+      if (!mergedTranscript) {
+        throw new Error(`Could not find feature with identifier "${changedId}"`)
+      }
+      change.mergeTranscriptsOnClient(mergedTranscript, secondTranscript)
+      mergedTranscript.parent?.deleteChild(secondTranscript._id)
+    }
+  },
+
+  async UndoMergeExonsChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { exonsToRestore, parentFeatureId } = c
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const exon of exonsToRestore) {
+        parentFeature.addChild(exon)
+      }
+    }
+  },
+
+  async UndoSplitExonChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { exonToRestore, parentFeatureId, idsToDelete } = c
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      parentFeature.addChild(exonToRestore)
+      idsToDelete.map((id) => {
+        parentFeature.deleteChild(id)
+      })
+    }
+  },
+
+  async UndoMergeTranscriptsChange(dataStore, change) {
+    for (const c of change.changes) {
+      const { transcriptsToRestore, parentFeatureId } = c
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const transcript of transcriptsToRestore) {
+        parentFeature.addChild(transcript)
+      }
+    }
+  },
+
+  async StrandChange(dataStore, change) {
+    for (const [idx, changedId] of change.changedIds.entries()) {
+      const feature = dataStore.getFeature(changedId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${changedId}"`)
+      }
+      feature.setStrand(change.changes[idx].newStrand)
+    }
+  },
+
+  async TypeChange(dataStore, change) {
+    for (const [idx, changedId] of change.changedIds.entries()) {
+      const feature = dataStore.getFeature(changedId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${changedId}"`)
+      }
+      feature.setType(change.changes[idx].newType)
+    }
+  },
+}