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

package/src/LinearApolloDisplay/stateModel/layouts.ts

@@ -11,6 +11,39 @@ import { ApolloSessionModel } from '../../session'
 import { baseModelFactory } from './base'
 import { boxGlyph, geneGlyph, genericChildGlyph } from '../glyphs'
 
+function getRowsForFeature(
+  startingRow: number,
+  rowCount: number,
+  filledRowLocations: Map<number, [number, number][]>,
+) {
+  const rowsForFeature = []
+  for (let i = startingRow; i < startingRow + rowCount; i++) {
+    const row = filledRowLocations.get(i)
+    if (row) {
+      rowsForFeature.push(row)
+    }
+  }
+  return rowsForFeature
+}
+
+function canPlaceFeatureInRows(
+  rowsForFeature: [number, number][][],
+  feature: AnnotationFeature,
+) {
+  for (const rowForFeature of rowsForFeature) {
+    for (const [rowStart, rowEnd] of rowForFeature) {
+      if (
+        doesIntersect2(feature.min, feature.max, rowStart, rowEnd) ||
+        doesIntersect2(rowStart, rowEnd, feature.min, feature.max)
+      ) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
 export function layoutsModelFactory(
   pluginManager: PluginManager,
   configSchema: AnyConfigurationSchemaType,
@@ -19,48 +52,14 @@ export function layoutsModelFactory(
 
   return BaseLinearApolloDisplay.named('LinearApolloDisplayLayouts')
     .props({
-      featuresMinMaxLimit: 500_000,
+      cleanupBoundary: 200_000,
     })
     .volatile(() => ({
       seenFeatures: observable.map<string, AnnotationFeature>(),
     }))
     .views((self) => ({
-      get featuresMinMax() {
-        const { assemblyManager } =
-          self.session as unknown as AbstractSessionModel
-        return self.lgv.displayedRegions.map((region) => {
-          const assembly = assemblyManager.get(region.assemblyName)
-          let min: number | undefined
-          let max: number | undefined
-          const { end, refName, start } = region
-          for (const [, feature] of self.seenFeatures) {
-            if (
-              refName !== assembly?.getCanonicalRefName(feature.refSeq) ||
-              !doesIntersect2(start, end, feature.min, feature.max) ||
-              feature.length > self.featuresMinMaxLimit ||
-              (self.filteredFeatureTypes.length > 0 &&
-                !self.filteredFeatureTypes.includes(feature.type))
-            ) {
-              continue
-            }
-            if (min === undefined) {
-              ;({ min } = feature)
-            }
-            if (max === undefined) {
-              ;({ max } = feature)
-            }
-            if (feature.minWithChildren < min) {
-              ;({ min } = feature)
-            }
-            if (feature.maxWithChildren > max) {
-              ;({ max } = feature)
-            }
-          }
-          if (min !== undefined && max !== undefined) {
-            return [min, max]
-          }
-          return
-        })
+      getAnnotationFeatureById(id: string) {
+        return self.seenFeatures.get(id)
       },
       getGlyph(feature: AnnotationFeature) {
         if (this.looksLikeGene(feature)) {
@@ -91,15 +90,9 @@ export function layoutsModelFactory(
             if (!grandChildren?.size) {
               return false
             }
-            const hasCDS = [...grandChildren.values()].some((grandchild) =>
-              featureTypeOntology.isTypeOf(grandchild.type, 'CDS'),
-            )
-            const hasExon = [...grandChildren.values()].some((grandchild) =>
+            return [...grandChildren.values()].some((grandchild) =>
               featureTypeOntology.isTypeOf(grandchild.type, 'exon'),
             )
-            if (hasCDS && hasExon) {
-              return true
-            }
           }
         }
         return false
@@ -117,15 +110,11 @@ export function layoutsModelFactory(
       get featureLayouts() {
         const { assemblyManager } =
           self.session as unknown as AbstractSessionModel
-        return self.lgv.displayedRegions.map((region, idx) => {
+        return self.lgv.displayedRegions.map((region) => {
           const assembly = assemblyManager.get(region.assemblyName)
-          const featureLayout = new Map<number, [number, AnnotationFeature][]>()
-          const minMax = self.featuresMinMax[idx]
-          if (!minMax) {
-            return featureLayout
-          }
-          const [min, max] = minMax
-          const rows: boolean[][] = []
+          const featureLayout = new Map<number, [number, string][]>()
+          // Track the occupied coordinates in each row
+          const filledRowLocations = new Map<number, [number, number][]>()
           const { end, refName, start } = region
           for (const [id, feature] of self.seenFeatures.entries()) {
             if (!isAlive(feature)) {
@@ -151,36 +140,24 @@ export function layoutsModelFactory(
             let startingRow = 0
             let placed = false
             while (!placed) {
-              let rowsForFeature = rows.slice(
+              let rowsForFeature = getRowsForFeature(
                 startingRow,
-                startingRow + rowCount,
+                rowCount,
+                filledRowLocations,
               )
               if (rowsForFeature.length < rowCount) {
                 for (let i = 0; i < rowCount - rowsForFeature.length; i++) {
-                  const newRowNumber = rows.length
-                  rows[newRowNumber] = Array.from({ length: max - min })
+                  const newRowNumber = filledRowLocations.size
+                  filledRowLocations.set(newRowNumber, [])
                   featureLayout.set(newRowNumber, [])
                 }
-                rowsForFeature = rows.slice(startingRow, startingRow + rowCount)
+                rowsForFeature = getRowsForFeature(
+                  startingRow,
+                  rowCount,
+                  filledRowLocations,
+                )
               }
-              if (
-                rowsForFeature
-                  .map((rowForFeature) => {
-                    // zero-length features are allowed in the spec
-                    const featureMax =
-                      feature.max - feature.min === 0
-                        ? feature.min + 1
-                        : feature.max
-                    let start = feature.min - min,
-                      end = featureMax - min
-                    if (feature.min - min < 0) {
-                      start = 0
-                      end = featureMax - feature.min
-                    }
-                    return rowForFeature.slice(start, end).some(Boolean)
-                  })
-                  .some(Boolean)
-              ) {
+              if (!canPlaceFeatureInRows(rowsForFeature, feature)) {
                 startingRow += 1
                 continue
               }
@@ -189,16 +166,9 @@ export function layoutsModelFactory(
                 rowNum < startingRow + rowCount;
                 rowNum++
               ) {
-                const row = rows[rowNum]
-                let start = feature.min - min,
-                  end = feature.max - min
-                if (feature.min - min < 0) {
-                  start = 0
-                  end = feature.max - feature.min
-                }
-                row.fill(true, start, end)
+                filledRowLocations.get(rowNum)?.push([feature.min, feature.max])
                 const layoutRow = featureLayout.get(rowNum)
-                layoutRow?.push([rowNum - startingRow, feature])
+                layoutRow?.push([rowNum - startingRow, feature._id])
               }
               placed = true
             }
@@ -212,12 +182,17 @@ export function layoutsModelFactory(
           self.session.apolloDataStore.ontologyManager
         for (const [idx, layout] of featureLayouts.entries()) {
           for (const [layoutRowNum, layoutRow] of layout) {
-            for (const [featureRowNum, layoutFeature] of layoutRow) {
+            for (const [featureRowNum, layoutFeatureId] of layoutRow) {
               if (featureRowNum !== 0) {
                 // Same top-level feature in all feature rows, so only need to
                 // check the first one
                 continue
               }
+              const layoutFeature =
+                self.getAnnotationFeatureById(layoutFeatureId)
+              if (!layoutFeature) {
+                continue
+              }
               if (feature._id === layoutFeature._id) {
                 return {
                   layoutIndex: idx,
@@ -263,6 +238,30 @@ export function layoutsModelFactory(
               if (!self.lgv.initialized || self.regionCannotBeRendered()) {
                 return
               }
+              // Clear out features that are no longer in the view and out of the cleanup boundary
+              // cleanup boundary + region boundary + cleanup boundary
+              for (const [id, feature] of self.seenFeatures.entries()) {
+                let shouldKeep = false
+                for (const region of self.regions) {
+                  const extendedStart = region.start - self.cleanupBoundary
+                  const extendedEnd = region.end + self.cleanupBoundary
+                  if (
+                    doesIntersect2(
+                      extendedStart,
+                      extendedEnd,
+                      feature.min,
+                      feature.max,
+                    )
+                  ) {
+                    shouldKeep = true
+                    break
+                  }
+                }
+                if (!shouldKeep) {
+                  self.deleteSeenFeature(id)
+                }
+              }
+              // Add features that are in the current view
               for (const region of self.regions) {
                 const assembly = (
                   self.session as unknown as ApolloSessionModel

package/src/LinearApolloDisplay/stateModel/mouseEvents.ts

@@ -139,13 +139,18 @@ export function mouseEventsModelIntermediateFactory(
         if (!layoutRow) {
           return mousePosition
         }
-        const foundFeature = layoutRow.find(
-          (f) => bp >= f[1].min && bp <= f[1].max,
-        )
+        const foundFeature = layoutRow.find((f) => {
+          const feature = self.getAnnotationFeatureById(f[1])
+          return feature && bp >= feature.min && bp <= feature.max
+        })
         if (!foundFeature) {
           return mousePosition
         }
-        const [featureRow, topLevelFeature] = foundFeature
+        const [featureRow, topLevelFeatureId] = foundFeature
+        const topLevelFeature = self.getAnnotationFeatureById(topLevelFeatureId)
+        if (!topLevelFeature) {
+          return mousePosition
+        }
         const glyph = self.getGlyph(topLevelFeature)
         const { featureTypeOntology } =
           self.session.apolloDataStore.ontologyManager

package/src/LinearApolloDisplay/stateModel/rendering.ts

@@ -413,8 +413,9 @@ export function renderingModelFactory(
             for (const [idx, featureLayout] of featureLayouts.entries()) {
               const displayedRegion = displayedRegions[idx]
               for (const [row, featureLayoutRow] of featureLayout.entries()) {
-                for (const [featureRow, feature] of featureLayoutRow) {
-                  if (featureRow > 0) {
+                for (const [featureRow, featureId] of featureLayoutRow) {
+                  const feature = self.getAnnotationFeatureById(featureId)
+                  if (featureRow > 0 || !feature) {
                     continue
                   }
                   if (

package/src/OntologyManager/index.ts

@@ -35,6 +35,7 @@ export const OntologyRecordType = types
   })
   .volatile((_self) => ({
     dataStore: undefined as undefined | OntologyStore,
+    startedEquivalentTypeRequests: new Set<string>(),
   }))
   .actions((self) => ({
     /** does nothing, just used to access the model to force its lifecycle hooks to run */
@@ -66,6 +67,10 @@ export const OntologyRecordType = types
       if (!self.dataStore) {
         return
       }
+      if (self.startedEquivalentTypeRequests.has(type)) {
+        return
+      }
+      self.startedEquivalentTypeRequests.add(type)
       const terms = (yield self.dataStore.getTermsWithLabelOrSynonym(
         type,
       )) as unknown as OntologyTerm[]
@@ -75,6 +80,23 @@ export const OntologyRecordType = types
       self.setEquivalentTypes(type, equivalents)
     }),
   }))
+  .actions((self) => ({
+    afterCreate() {
+      autorun((reaction) => {
+        if (!self.dataStore) {
+          return
+        }
+        void self.loadEquivalentTypes('gene')
+        void self.loadEquivalentTypes('transcript')
+        void self.loadEquivalentTypes('CDS')
+        void self.loadEquivalentTypes('mRNA')
+        reaction.dispose()
+      })
+    },
+    setEquivalentTypes(type: string, equivalentTypes: string[]) {
+      self.equivalentTypes.set(type, equivalentTypes)
+    },
+  }))
   .views((self) => ({
     isTypeOf(queryType: string, typeOf: string): boolean {
       if (queryType === typeOf) {