@apollo-annotation/jbrowse-plugin-apollo 0.1.18 → 0.1.20

package/src/util/loadAssemblyIntoClient.ts

@@ -1,12 +1,8 @@
 import { ClientDataStore, checkRegistry } from '@apollo-annotation/common'
-import {
-  AnnotationFeatureSnapshot,
-  ApolloAssemblyI,
-  CheckResultSnapshot,
-} from '@apollo-annotation/mst'
+import { ApolloAssemblyI, CheckResultSnapshot } from '@apollo-annotation/mst'
+import { gff3ToAnnotationFeature } from '@apollo-annotation/shared'
 import gff, { GFF3Comment, GFF3Feature, GFF3Sequence } from '@gmod/gff'
 import { getSnapshot } from 'mobx-state-tree'
-import { nanoid } from 'nanoid'
 
 export async function loadAssemblyIntoClient(
   assemblyId: string,
@@ -27,13 +23,13 @@ export async function loadAssemblyIntoClient(
   let sequenceFeatureCount = 0
   let assembly = apolloDataStore.assemblies.get(assemblyId)
   if (!assembly) {
-    assembly = apolloDataStore.addAssembly(assemblyId)
+    assembly = apolloDataStore.addAssembly(assemblyId, 'InMemoryFileDriver')
   }
 
   for (const seqLine of featuresAndSequences) {
     if (Array.isArray(seqLine)) {
       // regular feature
-      const feature = createFeature(seqLine)
+      const feature = gff3ToAnnotationFeature(seqLine)
 
       const ref =
         assembly.refSeqs.get(feature.refSeq) ??
@@ -88,205 +84,3 @@ export async function checkFeatures(
   }
   return checkResults
 }
-
-function createFeature(gff3Feature: GFF3Feature): AnnotationFeatureSnapshot {
-  const [firstFeature] = gff3Feature
-  const {
-    attributes,
-    child_features: childFeatures,
-    end,
-    phase,
-    score,
-    seq_id: refName,
-    source,
-    start,
-    strand,
-    type,
-  } = firstFeature
-  if (!refName) {
-    throw new Error(
-      `feature does not have seq_id: ${JSON.stringify(firstFeature)}`,
-    )
-  }
-  if (!type) {
-    throw new Error(
-      `feature does not have type: ${JSON.stringify(firstFeature)}`,
-    )
-  }
-  if (start === null) {
-    throw new Error(
-      `feature does not have start: ${JSON.stringify(firstFeature)}`,
-    )
-  }
-  if (end === null) {
-    throw new Error(
-      `feature does not have end: ${JSON.stringify(firstFeature)}`,
-    )
-  }
-  const feature: AnnotationFeatureSnapshot = {
-    _id: nanoid(),
-    gffId: '',
-    refSeq: refName,
-    type,
-    start: start - 1,
-    end,
-  }
-  if (gff3Feature.length > 1) {
-    feature.discontinuousLocations = gff3Feature.map((f) => {
-      const { end: subEnd, phase: locationPhase, start: subStart } = f
-      if (subStart === null || subEnd === null) {
-        throw new Error(
-          `feature does not have start and/or end: ${JSON.stringify(f)}`,
-        )
-      }
-      let parsedPhase: 0 | 1 | 2 | undefined
-      if (locationPhase) {
-        switch (locationPhase) {
-          case '0': {
-            parsedPhase = 0
-
-            break
-          }
-          case '1': {
-            parsedPhase = 1
-
-            break
-          }
-          case '2': {
-            parsedPhase = 2
-
-            break
-          }
-          default: {
-            throw new Error(`Unknown phase: "${locationPhase}"`)
-          }
-        }
-      }
-      return { start: subStart - 1, end: subEnd, phase: parsedPhase }
-    })
-  }
-  if (strand) {
-    if (strand === '+') {
-      feature.strand = 1
-    } else if (strand === '-') {
-      feature.strand = -1
-    } else {
-      throw new Error(`Unknown strand: "${strand}"`)
-    }
-  }
-  if (score !== null) {
-    feature.score = score
-  }
-  if (phase) {
-    switch (phase) {
-      case '0': {
-        feature.phase = 0
-
-        break
-      }
-      case '1': {
-        feature.phase = 1
-
-        break
-      }
-      case '2': {
-        feature.phase = 2
-
-        break
-      }
-      default: {
-        throw new Error(`Unknown phase: "${phase}"`)
-      }
-    }
-  }
-
-  if (childFeatures.length > 0) {
-    const children: Record<string, AnnotationFeatureSnapshot> = {}
-    for (const childFeature of childFeatures) {
-      const child = createFeature(childFeature)
-      children[child._id] = child
-      // Add value to gffId
-      child.attributes?._id
-        ? (child.gffId = child.attributes._id.toString())
-        : (child.gffId = child._id)
-    }
-    feature.children = children
-  }
-  if (source ?? attributes) {
-    const attrs: Record<string, string[]> = {}
-    if (source) {
-      attrs.source = [source]
-    }
-    if (attributes) {
-      for (const [key, val] of Object.entries(attributes)) {
-        if (val) {
-          const newKey = key.toLowerCase()
-          if (newKey !== 'parent') {
-            // attrs[key.toLowerCase()] = val
-            switch (key) {
-              case 'ID': {
-                attrs._id = val
-                break
-              }
-              case 'Name': {
-                attrs.gff_name = val
-                break
-              }
-              case 'Alias': {
-                attrs.gff_alias = val
-                break
-              }
-              case 'Target': {
-                attrs.gff_target = val
-                break
-              }
-              case 'Gap': {
-                attrs.gff_gap = val
-                break
-              }
-              case 'Derives_from': {
-                attrs.gff_derives_from = val
-                break
-              }
-              case 'Note': {
-                attrs.gff_note = val
-                break
-              }
-              case 'Dbxref': {
-                attrs.gff_dbxref = val
-                break
-              }
-              case 'Ontology_term': {
-                const goTerms: string[] = []
-                const otherTerms: string[] = []
-                for (const v of val) {
-                  if (v.startsWith('GO:')) {
-                    goTerms.push(v)
-                  } else {
-                    otherTerms.push(v)
-                  }
-                }
-                if (goTerms.length > 0) {
-                  attrs['Gene Ontology'] = goTerms
-                }
-                if (otherTerms.length > 0) {
-                  attrs.gff_ontology_term = otherTerms
-                }
-                break
-              }
-              case 'Is_circular': {
-                attrs.gff_is_circular = val
-                break
-              }
-              default: {
-                attrs[key.toLowerCase()] = val
-              }
-            }
-          }
-        }
-      }
-    }
-    feature.attributes = attrs
-  }
-  return feature
-}

package/src/FeatureDetailsWidget/RelatedFeature.tsx

@@ -1,97 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { AnnotationFeature, AnnotationFeatureI } from '@apollo-annotation/mst'
-import { SessionWithWidgets } from '@jbrowse/core/util'
-import { Button, Paper, Typography } from '@mui/material'
-import { observer } from 'mobx-react'
-import { IMSTMap } from 'mobx-state-tree'
-import React from 'react'
-import { makeStyles } from 'tss-react/mui'
-
-import { ApolloSessionModel } from '../session'
-
-const useStyles = makeStyles()((theme) => ({
-  paper: {
-    margin: theme.spacing(2),
-    padding: theme.spacing(2),
-    display: 'flex',
-    flexDirection: 'column',
-  },
-}))
-
-export const RelatedFeatures = observer(function RelatedFeatures({
-  assembly,
-  feature,
-  refName,
-  session,
-}: {
-  feature: AnnotationFeatureI
-  refName: string
-  session: ApolloSessionModel
-  assembly: string
-}) {
-  const { classes } = useStyles()
-  const { parent } = feature
-  const { children } = feature as {
-    children?: IMSTMap<typeof AnnotationFeature>
-  }
-
-  const onButtonClick = (newFeature: AnnotationFeatureI) => {
-    if (parent) {
-      const apolloFeatureWidget = (
-        session as unknown as SessionWithWidgets
-      ).addWidget('ApolloFeatureDetailsWidget', 'apolloFeatureDetailsWidget', {
-        feature: newFeature,
-        assembly,
-        refName,
-      })
-      ;(session as unknown as SessionWithWidgets).showWidget(
-        apolloFeatureWidget,
-      )
-    }
-  }
-
-  if (!(parent || (children && children.size > 0))) {
-    return null
-  }
-  return (
-    <>
-      <Typography variant="h4">Related features</Typography>
-      {parent && (
-        <>
-          <Typography variant="h5">Parent</Typography>
-          <Paper elevation={6} className={classes.paper}>
-            {`Start: ${parent.start}, End: ${parent.end}, Type: ${parent.type}`}
-            <Button
-              variant="contained"
-              onClick={() => {
-                onButtonClick(parent)
-              }}
-            >
-              Go to parent
-            </Button>
-          </Paper>
-        </>
-      )}
-      {children && children.size > 0 && (
-        <>
-          <Typography variant="h5">Children</Typography>
-          {[...children.values()].map((child) => (
-            <Paper elevation={6} className={classes.paper} key={child._id}>
-              {`Start: ${child.start}, End: ${child.end}, Type: ${child.type}`}
-              <Button
-                variant="contained"
-                onClick={() => {
-                  onButtonClick(child)
-                }}
-              >
-                Go to child
-              </Button>
-            </Paper>
-          ))}
-        </>
-      )}
-    </>
-  )
-})