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

package/src/ApolloSixFrameRenderer/index.ts

@@ -1,3 +0,0 @@
-export { default as ReactComponent } from './components/ApolloRendering'
-export { default as configSchema } from './configSchema'
-export { default as ApolloSixFrameRenderer } from './ApolloSixFrameRenderer'

package/src/FeatureDetailsWidget/TranscriptBasic.tsx

@@ -1,200 +0,0 @@
-import { AnnotationFeature } from '@apollo-annotation/mst'
-import {
-  LocationEndChange,
-  LocationStartChange,
-} from '@apollo-annotation/shared'
-import { AbstractSessionModel, getFrame, revcom } from '@jbrowse/core/util'
-import {
-  Paper,
-  Typography,
-  Table,
-  TableBody,
-  TableCell,
-  TableContainer,
-  TableRow,
-  useTheme,
-} from '@mui/material'
-import { observer } from 'mobx-react'
-import React from 'react'
-
-import { ApolloSessionModel } from '../session'
-import { NumberTextField } from './NumberTextField'
-
-export const TranscriptBasicInformation = observer(
-  function TranscriptBasicInformation({
-    assembly,
-    feature,
-    refName,
-    session,
-  }: {
-    feature: AnnotationFeature
-    session: ApolloSessionModel
-    assembly: string
-    refName: string
-  }) {
-    const { notify } = session as unknown as AbstractSessionModel
-    const currentAssembly = session.apolloDataStore.assemblies.get(assembly)
-    const refData = currentAssembly?.getByRefName(refName)
-    const { changeManager } = session.apolloDataStore
-    const theme = useTheme()
-
-    function handleLocationChange(
-      oldLocation: number,
-      newLocation: number,
-      feature: AnnotationFeature,
-      isMin: boolean,
-    ) {
-      if (!feature.children) {
-        throw new Error('Transcript should have child features')
-      }
-      for (const [, child] of feature.children) {
-        if (isMin && oldLocation - 1 === child.min) {
-          const change = new LocationStartChange({
-            typeName: 'LocationStartChange',
-            changedIds: [child._id],
-            featureId: feature._id,
-            oldStart: oldLocation - 1,
-            newStart: newLocation - 1,
-            assembly,
-          })
-          changeManager.submit(change).catch(() => {
-            notify('Error updating feature start position', 'error')
-          })
-          return
-        }
-        if (!isMin && newLocation === child.max) {
-          const change = new LocationEndChange({
-            typeName: 'LocationEndChange',
-            changedIds: [child._id],
-            featureId: feature._id,
-            oldEnd: child.max,
-            newEnd: newLocation,
-            assembly,
-          })
-          changeManager.submit(change).catch(() => {
-            notify('Error updating feature start position', 'error')
-          })
-          return
-        }
-      }
-    }
-
-    if (!refData) {
-      return null
-    }
-
-    let strand, transcriptParts
-    try {
-      ;({ strand, transcriptParts } = feature)
-    } catch {
-      return null
-    }
-    const [firstLocation] = transcriptParts
-
-    const locationData = firstLocation
-      .map((loc, idx) => {
-        const { max, min, type } = loc
-        let label: string = type
-        if (label === 'threePrimeUTR') {
-          label = '3` UTR'
-        } else if (label === 'fivePrimeUTR') {
-          label = '5` UTR'
-        }
-        let fivePrimeSpliceSite
-        let threePrimeSpliceSite
-        let frameColor
-        if (type === 'CDS') {
-          const { phase } = loc
-          const frame = getFrame(min, max, strand ?? 1, phase)
-          frameColor = theme.palette.framesCDS.at(frame)?.main
-          const previousLoc = firstLocation.at(idx - 1)
-          const nextLoc = firstLocation.at(idx + 1)
-          if (strand === 1) {
-            if (previousLoc?.type === 'intron') {
-              fivePrimeSpliceSite = refData.getSequence(min - 2, min)
-            }
-            if (nextLoc?.type === 'intron') {
-              threePrimeSpliceSite = refData.getSequence(max, max + 2)
-            }
-          } else {
-            if (previousLoc?.type === 'intron') {
-              fivePrimeSpliceSite = revcom(refData.getSequence(max, max + 2))
-            }
-            if (nextLoc?.type === 'intron') {
-              threePrimeSpliceSite = revcom(refData.getSequence(min - 2, min))
-            }
-          }
-        }
-        return {
-          min,
-          max,
-          label,
-          fivePrimeSpliceSite,
-          threePrimeSpliceSite,
-          frameColor,
-        }
-      })
-      .filter((loc) => loc.label !== 'intron')
-
-    return (
-      <>
-        <Typography variant="h5">Structure</Typography>
-        <Typography variant="h6">
-          {strand === 1 ? 'Forward' : 'Reverse'} strand
-        </Typography>
-        <TableContainer component={Paper}>
-          <Table size="small">
-            <TableBody>
-              {locationData.map((loc) => (
-                <TableRow key={`${loc.label}:${loc.min}-${loc.max}`}>
-                  <TableCell
-                    component="th"
-                    scope="row"
-                    style={{ background: loc.frameColor }}
-                  >
-                    {loc.label}
-                  </TableCell>
-                  <TableCell>{loc.fivePrimeSpliceSite ?? ''}</TableCell>
-                  <TableCell padding="none">
-                    <NumberTextField
-                      margin="dense"
-                      variant="outlined"
-                      value={strand === 1 ? loc.min + 1 : loc.max}
-                      onChangeCommitted={(newLocation: number) => {
-                        handleLocationChange(
-                          strand === 1 ? loc.min + 1 : loc.max,
-                          newLocation,
-                          feature,
-                          strand === 1,
-                        )
-                      }}
-                    />
-                    {/* {strand === 1 ? loc.min : loc.max} */}
-                  </TableCell>
-                  <TableCell padding="none">
-                    <NumberTextField
-                      margin="dense"
-                      // disabled={item.type !== 'CDS'}
-                      variant="outlined"
-                      value={strand === 1 ? loc.max : loc.min + 1}
-                      onChangeCommitted={(newLocation: number) => {
-                        handleLocationChange(
-                          strand === 1 ? loc.max : loc.min + 1,
-                          newLocation,
-                          feature,
-                          strand !== 1,
-                        )
-                      }}
-                    />
-                    {/* {strand === 1 ? loc.max : loc.min} */}
-                  </TableCell>
-                  <TableCell>{loc.threePrimeSpliceSite ?? ''}</TableCell>
-                </TableRow>
-              ))}
-            </TableBody>
-          </Table>
-        </TableContainer>
-      </>
-    )
-  },
-)

package/src/SixFrameFeatureDisplay/components/TrackLines.tsx

@@ -1,19 +0,0 @@
-import { observer } from 'mobx-react'
-import React from 'react'
-
-import { SixFrameFeatureDisplay } from '../stateModel'
-
-export const TrackLines = observer(function TrackLines({
-  model,
-}: {
-  model: SixFrameFeatureDisplay
-}) {
-  const { height } = model
-  return (
-    <div
-      style={{ position: 'absolute', left: 0, top: height / 2, width: '100%' }}
-    >
-      <hr style={{ margin: 0, top: 0, color: 'black' }} />
-    </div>
-  )
-})

package/src/SixFrameFeatureDisplay/components/index.ts

@@ -1 +0,0 @@
-export * from './TrackLines'

package/src/SixFrameFeatureDisplay/configSchema.ts

@@ -1,21 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import PluginManager from '@jbrowse/core/PluginManager'
-import type LinearGenomeViewPlugin from '@jbrowse/plugin-linear-genome-view'
-
-import { configSchema as apolloRendererConfigSchema } from '../ApolloSixFrameRenderer'
-
-export function configSchemaFactory(pluginManager: PluginManager) {
-  const LGVPlugin = pluginManager.getPlugin(
-    'LinearGenomeViewPlugin',
-  ) as LinearGenomeViewPlugin
-  const { baseLinearDisplayConfigSchema } = LGVPlugin.exports
-
-  return ConfigurationSchema(
-    'SixFrameFeatureDisplay',
-    {
-      renderer: apolloRendererConfigSchema,
-      height: { type: 'number', defaultValue: 120 },
-    },
-    { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true },
-  )
-}

package/src/SixFrameFeatureDisplay/index.ts

@@ -1,2 +0,0 @@
-export { configSchemaFactory } from './configSchema'
-export { stateModelFactory } from './stateModel'

package/src/SixFrameFeatureDisplay/stateModel.ts

@@ -1,439 +0,0 @@
-/* eslint-disable @typescript-eslint/restrict-plus-operands */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/unbound-method */
-import { AnnotationFeature } from '@apollo-annotation/mst'
-import { ConfigurationReference } from '@jbrowse/core/configuration'
-import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration/configurationSchema'
-import PluginManager from '@jbrowse/core/PluginManager'
-import {
-  defaultStarts,
-  defaultStops,
-  getContainingView,
-  getSession,
-  revcom,
-  reverse,
-} from '@jbrowse/core/util'
-import { BaseBlock } from '@jbrowse/core/util/blockTypes'
-import { getParentRenderProps } from '@jbrowse/core/util/tracks'
-import type LinearGenomeViewPlugin from '@jbrowse/plugin-linear-genome-view'
-import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
-import { autorun } from 'mobx'
-import { Instance, addDisposer, types } from 'mobx-state-tree'
-
-import { ApolloSession, ApolloSessionModel } from '../session'
-
-const forwardPhaseMap: Record<number, number> = { 0: 2, 1: 1, 2: 0 }
-const reversePhaseMap: Record<number, number> = { 3: 0, 4: 1, 5: 2 }
-
-export function stateModelFactory(
-  pluginManager: PluginManager,
-  configSchema: AnyConfigurationSchemaType,
-) {
-  const LGVPlugin = pluginManager.getPlugin(
-    'LinearGenomeViewPlugin',
-  ) as LinearGenomeViewPlugin
-  const { BaseLinearDisplay } = LGVPlugin.exports
-
-  return BaseLinearDisplay.named('SixFrameFeatureDisplay')
-    .props({
-      type: types.literal('SixFrameFeatureDisplay'),
-      configuration: ConfigurationReference(configSchema),
-      apolloRowHeight: 20,
-      detailsMinHeight: 200,
-      showStartCodons: false,
-      showStopCodons: true,
-      showIntronLines: true,
-    })
-    .volatile(() => ({
-      apolloFeatureUnderMouse: undefined as AnnotationFeature | undefined,
-      apolloRowUnderMouse: undefined as number | undefined,
-    }))
-    .views((self) => {
-      const { configuration, renderProps: superRenderProps } = self
-      return {
-        renderProps() {
-          return {
-            ...superRenderProps(),
-            ...getParentRenderProps(self),
-            config: configuration.renderer,
-          }
-        },
-      }
-    })
-    .views((self) => ({
-      get regions() {
-        let blockDefinitions
-        try {
-          ;({ blockDefinitions } = self)
-        } catch {
-          return []
-        }
-        const regions = blockDefinitions.contentBlocks.map(
-          ({ assemblyName, end, refName, start }) => ({
-            assemblyName,
-            refName,
-            start,
-            end,
-          }),
-        )
-        return regions
-      },
-      regionCannotBeRendered(/* region */) {
-        const view = getContainingView(self) as unknown as LinearGenomeViewModel
-        if (view && view.bpPerPx >= 200) {
-          return 'Zoom in to see annotations'
-        }
-        return
-      },
-      get session() {
-        return getSession(self) as unknown as ApolloSessionModel
-      },
-    }))
-    .actions((self) => {
-      let previousBlockKeys: string[] = []
-      return {
-        afterAttach() {
-          addDisposer(
-            self,
-            autorun(
-              () => {
-                const session = getSession(self) as ApolloSession
-                const view = getContainingView(
-                  self,
-                ) as unknown as LinearGenomeViewModel
-                if (view.initialized) {
-                  if (self.regionCannotBeRendered()) {
-                    return
-                  }
-                  const blockKeys: string[] = []
-                  const newBlocks: BaseBlock[] = []
-                  for (const block of self.blockDefinitions.contentBlocks) {
-                    blockKeys.push(block.key)
-                    if (!previousBlockKeys.includes(block.key)) {
-                      newBlocks.push(block)
-                    }
-                  }
-                  session.apolloDataStore.loadFeatures(
-                    newBlocks.map(({ assemblyName, end, refName, start }) => ({
-                      assemblyName,
-                      refName,
-                      start,
-                      end,
-                    })),
-                  )
-                  session.apolloDataStore.loadRefSeq(
-                    newBlocks.map(({ assemblyName, end, refName, start }) => ({
-                      assemblyName,
-                      refName,
-                      start,
-                      end,
-                    })),
-                  )
-                  previousBlockKeys = blockKeys
-                }
-              },
-              { name: 'SixFrameFeatureDisplay' },
-            ),
-          )
-        },
-      }
-    })
-    .views((self) => ({
-      get rendererTypeName() {
-        return self.configuration.renderer.type
-      },
-      get changeManager() {
-        const session = getSession(self) as ApolloSession
-        return session.apolloDataStore.changeManager
-      },
-      get sequence() {
-        const { regions } = self
-        const session = getSession(self) as ApolloSession
-        const seq = new Map<number, string>()
-        for (const region of regions) {
-          const assembly = session.apolloDataStore.assemblies.get(
-            region.assemblyName,
-          )
-          const ref = assembly?.getByRefName(region.refName)
-          const refSeq: string | undefined = ref?.getSequence(
-            region.start,
-            region.end,
-          )
-          seq.set(region.start, refSeq ?? '')
-        }
-        return seq
-      },
-      get features() {
-        const { regions } = self
-        const session = getSession(self) as ApolloSession
-        const features = new Map<string, Map<string, AnnotationFeature>>()
-        for (const region of regions) {
-          const assembly = session.apolloDataStore.assemblies.get(
-            region.assemblyName,
-          )
-          const ref = assembly?.getByRefName(region.refName)
-          let filteredRef = features.get(region.refName)
-          if (!filteredRef) {
-            filteredRef = new Map<string, AnnotationFeature>()
-            features.set(region.refName, filteredRef)
-          }
-          for (const [featureId, feature] of ref?.features.entries() ??
-            new Map()) {
-            if (region.start < feature.end && region.end > feature.start) {
-              filteredRef.set(featureId, feature)
-            }
-          }
-        }
-        return features
-      },
-      get featuresMinMax() {
-        const minMax: Record<string, [number, number]> = {}
-        for (const [refSeq, featuresForRefSeq] of this.features || []) {
-          let min: number | undefined
-          let max: number | undefined
-          for (const [, featureLocation] of featuresForRefSeq) {
-            if (min === undefined) {
-              ;({ min } = featureLocation)
-            }
-            if (max === undefined) {
-              ;({ max } = featureLocation)
-            }
-            if (featureLocation.min < min) {
-              ;({ min } = featureLocation)
-            }
-            if (featureLocation.max > max) {
-              ;({ max } = featureLocation)
-            }
-          }
-          if (min !== undefined && max !== undefined) {
-            minMax[refSeq] = [min, max]
-          }
-        }
-        return minMax
-      },
-      get codonLayout() {
-        const codonLayout = new Map<
-          number,
-          { starts: number[]; stops: number[] }
-        >()
-        let fullSeq = ''
-        let fullStart = 0
-        for (const [regionStart, seq] of this.sequence || []) {
-          if (!seq) {
-            continue
-          }
-          if (!fullSeq) {
-            fullStart = regionStart
-          }
-          fullSeq += seq
-        }
-        const rowCount = 6
-        for (let i = 0; i < rowCount; i++) {
-          const starts: number[] = []
-          const stops: number[] = []
-          const reversed = i in reversePhaseMap
-          // the tilt variable normalizes the frame to where we are starting from,
-          // which increases consistency across blocks
-          let tilt
-          // the effectiveFrame incorporates tilt and the frame to say what the
-          // effective frame that is plotted. The +3 is for when frame is -2 and this
-          // can otherwise result in effectiveFrame -1
-          let effectiveFrame
-          let seqSliced
-          if (reversed) {
-            tilt = (fullSeq.length + fullStart) % 3
-            effectiveFrame = (reversePhaseMap[i] + tilt + 3) % 3
-            seqSliced = reverse(fullSeq).slice(effectiveFrame)
-          } else {
-            tilt = 3 - (fullStart % 3)
-            effectiveFrame = (forwardPhaseMap[i] + tilt + 3) % 3
-            seqSliced = fullSeq.slice(effectiveFrame)
-          }
-          for (let j = 0; j < seqSliced.length; j += 3) {
-            const codon = seqSliced.slice(j, j + 3)
-            const normalizedCodon = reversed ? reverse(revcom(codon)) : codon
-            const start = reversed
-              ? fullStart + seqSliced.length - (3 + j)
-              : fullStart + j + effectiveFrame
-            if (defaultStarts.includes(normalizedCodon.toUpperCase())) {
-              starts.push(start)
-            } else if (defaultStops.includes(normalizedCodon.toUpperCase())) {
-              stops.push(start)
-            }
-          }
-          codonLayout.set(i, { starts, stops })
-        }
-        return codonLayout
-      },
-      get featureLayout() {
-        const { featureTypeOntology } =
-          self.session.apolloDataStore.ontologyManager
-        if (!featureTypeOntology) {
-          throw new Error('featureTypeOntology is undefined')
-        }
-        const featureLayout = new Map<number, [string, AnnotationFeature][]>()
-        for (const [refSeq, featuresForRefSeq] of this.features || []) {
-          if (!featuresForRefSeq) {
-            continue
-          }
-          const minMaxfeatures = this.featuresMinMax[refSeq]
-          if (!minMaxfeatures) {
-            continue
-          }
-          const [min, max] = minMaxfeatures
-          const rows: boolean[][] = []
-          const rowCount = 6
-          for (let i = 0; i < rowCount; i++) {
-            const newRowNumber = rows.length
-            rows[newRowNumber] = Array.from({ length: max - min })
-            featureLayout.set(newRowNumber, [])
-          }
-          for (const feature of [...featuresForRefSeq.values()].sort(
-            (f1, f2) => {
-              const { max: end1, min: start1 } = f1
-              const { max: end2, min: start2 } = f2
-              return start1 - start2 || end1 - end2
-            },
-          )) {
-            for (const [, childFeature] of feature.children ?? new Map()) {
-              if (
-                featureTypeOntology.isTypeOf(childFeature.type, 'transcript')
-              ) {
-                for (const [, grandChildFeature] of childFeature.children ||
-                  new Map()) {
-                  let startingRow
-                  if (
-                    featureTypeOntology.isTypeOf(grandChildFeature.type, 'CDS')
-                  ) {
-                    let discontinuousLocations
-                    if (grandChildFeature.discontinuousLocations.length > 0) {
-                      ;({ discontinuousLocations } = grandChildFeature)
-                    } else {
-                      discontinuousLocations = [grandChildFeature]
-                    }
-                    for (const cds of discontinuousLocations) {
-                      const min = cds.start + 3
-                      const max = cds.end - 3
-                      // Remove codons either end of feature when considering intersect.
-                      for (const [row, { stops }] of this.codonLayout) {
-                        if (
-                          (row < 3 && feature.strand === 1) ||
-                          (row >= 3 && feature.strand === -1)
-                        ) {
-                          const filteredArray = stops.filter(
-                            (value) => value >= min && value <= max,
-                          )
-                          if (filteredArray.length === 0) {
-                            startingRow = row
-                            const layoutRow = featureLayout.get(startingRow)
-                            layoutRow?.push([childFeature.featureId, cds])
-                            break
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        return featureLayout
-      },
-      getAssemblyId(assemblyName: string) {
-        const { assemblyManager } = getSession(self)
-        const assembly = assemblyManager.get(assemblyName)
-        if (!assembly) {
-          throw new Error(`Could not find assembly named ${assemblyName}`)
-        }
-        return assembly.name
-      },
-      get selectedFeature(): AnnotationFeature | undefined {
-        const session = getSession(self) as ApolloSession
-        return session.apolloSelectedFeature
-      },
-      get setSelectedFeature() {
-        const session = getSession(self) as ApolloSession
-        return session.apolloSetSelectedFeature
-      },
-    }))
-    .actions((self) => ({
-      setSelectedFeature(feature?: AnnotationFeature) {
-        const session = getSession(self) as ApolloSession
-        session.apolloSetSelectedFeature(feature)
-      },
-      setApolloFeatureUnderMouse(feature?: AnnotationFeature) {
-        self.apolloFeatureUnderMouse = feature
-      },
-      setApolloRowUnderMouse(row?: number) {
-        self.apolloRowUnderMouse = row
-      },
-      toggleShowStartCodons() {
-        self.showStartCodons = !self.showStartCodons
-      },
-      toggleShowStopCodons() {
-        self.showStopCodons = !self.showStopCodons
-      },
-      toggleShowIntronLines() {
-        self.showIntronLines = !self.showIntronLines
-      },
-    }))
-    .views((self) => ({
-      get highestRow() {
-        if (self.featureLayout.size === 0) {
-          return 0
-        }
-        return Math.max(...self.featureLayout.keys())
-      },
-      get featuresHeight() {
-        return (this.highestRow + 1) * self.apolloRowHeight
-      },
-      get detailsHeight() {
-        return Math.max(
-          self.detailsMinHeight,
-          self.height - this.featuresHeight,
-        )
-      },
-      trackMenuItems() {
-        return [
-          {
-            label: 'Show start codons',
-            type: 'checkbox',
-            checked: self.showStartCodons,
-            onClick: () => {
-              self.toggleShowStartCodons()
-            },
-          },
-          {
-            label: 'Show stop codons',
-            type: 'checkbox',
-            checked: self.showStopCodons,
-            onClick: () => {
-              self.toggleShowStopCodons()
-            },
-          },
-          {
-            label: 'Show intron lines',
-            type: 'checkbox',
-            checked: self.showIntronLines,
-            onClick: () => {
-              self.toggleShowIntronLines()
-            },
-          },
-        ]
-      },
-    }))
-}
-
-export type SixFrameFeatureDisplayStateModel = ReturnType<
-  typeof stateModelFactory
->
-// 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 SixFrameFeatureDisplay
-  extends Instance<SixFrameFeatureDisplayStateModel> {}