@jbrowse/plugin-data-management 1.7.8 → 1.7.11

package/src/HierarchicalTrackSelectorWidget/{model.js → model.ts}

@@ -1,22 +1,28 @@
-import { types, getParent } from 'mobx-state-tree'
-import { readConfObject } from '@jbrowse/core/configuration'
+import { types, getParent, Instance } from 'mobx-state-tree'
+import {
+  AnyConfigurationModel,
+  getConf,
+  readConfObject,
+} from '@jbrowse/core/configuration'
 import { getSession } from '@jbrowse/core/util'
 import { ElementId } from '@jbrowse/core/util/types/mst'
+import PluginManager from '@jbrowse/core/PluginManager'
+import { AbstractView } from 'react'
 
-const hasAnyOverlap = (a1 = [], a2 = []) =>
-  !!a1.find(value => a2.includes(value))
+function hasAnyOverlap<T>(a1: T[] = [], a2: T[] = []) {
+  return !!a1.find(value => a2.includes(value))
+}
 
-function passesFilter(filter, config) {
-  const name = getTrackName(config)
-  const categories = readConfObject(config, 'category') || []
+function passesFilter(filter: string, config: AnyConfigurationModel) {
+  const categories = readConfObject(config, 'category') as string[] | undefined
   const filterLower = filter.toLowerCase()
   return (
-    !!name.toLowerCase().includes(filterLower) ||
-    categories.filter(cat => !!cat.toLowerCase().includes(filterLower)).length
+    getTrackName(config).toLowerCase().includes(filterLower) ||
+    categories?.filter(c => c.toLowerCase().includes(filterLower)).length
   )
 }
 
-function getTrackName(config) {
+function getTrackName(config: AnyConfigurationModel) {
   if (!config.trackId) {
     throw new Error('not a track')
   }
@@ -26,20 +32,33 @@ function getTrackName(config) {
   )
 }
 
-export function generateHierarchy(model, trackConfigurations, collapsed) {
-  const hierarchy = { children: [] }
+export type TreeNode = {
+  name: string
+  id: string
+  conf?: AnyConfigurationModel
+  checked?: boolean
+  isOpenByDefault?: boolean
+  children: TreeNode[]
+}
+
+export function generateHierarchy(
+  model: HierarchicalTrackSelectorModel,
+  trackConfigurations: AnyConfigurationModel[],
+  collapsed: { get: (arg: string) => boolean | undefined },
+) {
+  const hierarchy = { children: [] as TreeNode[] } as TreeNode
   const { filterText, view } = model
 
   trackConfigurations
-    .filter(trackConf => passesFilter(filterText, trackConf))
-    .forEach(trackConf => {
+    .filter(conf => passesFilter(filterText, conf))
+    .forEach(conf => {
       // copy the categories since this array can be mutated downstream
-      const categories = [...(readConfObject(trackConf, 'category') || [])]
+      const categories = [...(readConfObject(conf, 'category') || [])]
 
       // silly thing where if trackId ends with sessionTrack, then push it to
       // a category that starts with a space to force sort to the top...
       // double whammy hackyness
-      if (trackConf.trackId.endsWith('sessionTrack')) {
+      if (conf.trackId.endsWith('sessionTrack')) {
         categories.unshift(' Session tracks')
       }
 
@@ -63,16 +82,17 @@ export function generateHierarchy(model, trackConfigurations, collapsed) {
           currLevel = ret
         }
       }
+      const tracks = view.tracks as { configuration: AnyConfigurationModel }[]
 
       // using splice here tries to group leaf nodes above hierarchical nodes
       currLevel.children.splice(
         currLevel.children.findIndex(elt => elt.children.length),
         0,
         {
-          id: trackConf.trackId,
-          name: getTrackName(trackConf),
-          conf: trackConf,
-          checked: !!view.tracks.find(f => f.configuration === trackConf),
+          id: conf.trackId,
+          name: getTrackName(conf),
+          conf,
+          checked: !!tracks.find(f => f.configuration === conf),
           children: [],
         },
       )
@@ -81,8 +101,8 @@ export function generateHierarchy(model, trackConfigurations, collapsed) {
   return hierarchy.children
 }
 
-export default pluginManager =>
-  types
+export default function stateTreeFactory(pluginManager: PluginManager) {
+  return types
     .model('HierarchicalTrackSelectorWidget', {
       id: ElementId,
       type: types.literal('HierarchicalTrackSelectorWidget'),
@@ -93,44 +113,41 @@ export default pluginManager =>
       ),
     })
     .actions(self => ({
-      setView(view) {
+      setView(view: AbstractView) {
         self.view = view
       },
-      toggleCategory(pathName) {
+      toggleCategory(pathName: string) {
         self.collapsed.set(pathName, !self.collapsed.get(pathName))
       },
       clearFilterText() {
         self.filterText = ''
       },
-      setFilterText(newText) {
+      setFilterText(newText: string) {
         self.filterText = newText
       },
     }))
     .views(self => ({
-      getRefSeqTrackConf(assemblyName) {
+      getRefSeqTrackConf(assemblyName: string) {
         const { assemblyManager } = getSession(self)
         const assembly = assemblyManager.get(assemblyName)
         const trackConf = assembly?.configuration.sequence
         const viewType = pluginManager.getViewType(self.view.type)
-        if (trackConf) {
-          for (const display of trackConf.displays) {
-            if (
-              viewType.displayTypes.find(
-                displayType => displayType.name === display.type,
-              )
-            ) {
-              return trackConf
-            }
+        if (!trackConf) {
+          return undefined
+        }
+        for (const display of trackConf.displays) {
+          if (viewType.displayTypes.find(d => d.name === display.type)) {
+            return trackConf
           }
         }
-        return undefined
       },
-      trackConfigurations(assemblyName) {
+    }))
+    .views(self => ({
+      trackConfigurations(assemblyName: string) {
         if (!self.view) {
           return []
         }
-        const session = getSession(self)
-        const { tracks: trackConfigurations, assemblyManager } = session
+        const { tracks, assemblyManager } = getSession(self)
         const assembly = assemblyManager.get(assemblyName)
         if (!assembly) {
           return []
@@ -139,34 +156,36 @@ export default pluginManager =>
         // filter out tracks that don't match the current assembly (check all
         // assembly aliases) and display types
         return (refseq ? [refseq] : []).concat([
-          ...trackConfigurations
-            .filter(conf => {
-              const trackConfAssemblies = readConfObject(conf, 'assemblyNames')
+          ...tracks
+            .filter(c => {
+              const trackConfAssemblies = readConfObject(c, 'assemblyNames')
               const { allAliases } = assembly
               return hasAnyOverlap(allAliases, trackConfAssemblies)
             })
-            .filter(conf => {
+            .filter(c => {
               const { displayTypes } = pluginManager.getViewType(self.view.type)
-              const compatibleDisplays = displayTypes.map(
-                display => display.name,
+              const compatibleDisplays = displayTypes.map(d => d.name)
+              const trackDisplays = c.displays.map(
+                (d: { type: string }) => d.type,
               )
-              const trackDisplays = conf.displays.map(display => display.type)
               return hasAnyOverlap(compatibleDisplays, trackDisplays)
             }),
         ])
       },
 
-      get assemblyNames() {
-        return self.view ? self.view.assemblyNames : []
+      get assemblyNames(): string[] {
+        return self.view?.assemblyNames || []
       },
 
-      connectionTrackConfigurations(assemblyName, connection) {
+      connectionTrackConfigurations(
+        assemblyName: string,
+        connection: { tracks: AnyConfigurationModel[] },
+      ) {
         if (!self.view) {
           return []
         }
         const trackConfigurations = connection.tracks
-        const session = getSession(self)
-        const { assemblyManager } = session
+        const { assemblyManager } = getSession(self)
         const assembly = assemblyManager.get(assemblyName)
 
         if (!(assembly && assembly.initialized)) {
@@ -175,49 +194,49 @@ export default pluginManager =>
 
         // filter out tracks that don't match the current display types
         return trackConfigurations
-          .filter(conf => {
-            const trackConfAssemblies = readConfObject(conf, 'assemblyNames')
+          .filter(c => {
+            const trackConfAssemblies = readConfObject(c, 'assemblyNames')
             const { allAliases } = assembly
             return hasAnyOverlap(allAliases, trackConfAssemblies)
           })
-          .filter(conf => {
+          .filter(c => {
             const { displayTypes } = pluginManager.getViewType(self.view.type)
-            const compatibleDisplays = displayTypes.map(display => display.name)
-            const trackDisplays = conf.displays.map(display => display.type)
+            const compatibleDisplays = displayTypes.map(d => d.name)
+            const trackDisplays = c.displays.map(
+              (d: { type: string }) => d.type,
+            )
             return hasAnyOverlap(compatibleDisplays, trackDisplays)
           })
       },
-
-      hierarchy(assemblyName) {
+    }))
+    .views(self => ({
+      hierarchy(assemblyName: string) {
         const hier = generateHierarchy(
-          self,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          self as any,
           self.trackConfigurations(assemblyName),
           self.collapsed,
         )
 
         const session = getSession(self)
-        const conns = session.connectionInstances
-          .filter(conn => {
-            const configAssemblyNames = readConfObject(
-              conn.configuration,
-              'assemblyNames',
-            )
-            if (configAssemblyNames.length === 0) {
-              return true
-            }
-            return configAssemblyNames.includes(assemblyName)
-          })
-          .map((conn, index) => {
-            const c = session.connections[index]
-            return {
-              id: c.connectionId,
-              name: readConfObject(c, 'name'),
-              children: this.connectionHierarchy(assemblyName, conn),
-              state: {
-                expanded: true,
-              },
-            }
-          })
+        const { connections, connectionInstances } = session
+        const conns =
+          connectionInstances
+            ?.filter(c => {
+              const names = getConf(c, 'assemblyNames')
+              return names.length === 0 ? true : names.includes(assemblyName)
+            })
+            .map((conn, index) => {
+              const c = connections[index]
+              return {
+                id: c.connectionId,
+                name: readConfObject(c, 'name'),
+                children: this.connectionHierarchy(assemblyName, conn),
+                state: {
+                  expanded: true,
+                },
+              }
+            }) || []
 
         return {
           name: 'Root',
@@ -229,33 +248,22 @@ export default pluginManager =>
         }
       },
 
-      connectionHierarchy(assemblyName, connection) {
+      connectionHierarchy(
+        assemblyName: string,
+        connection: { tracks: AnyConfigurationModel[] },
+      ) {
         return generateHierarchy(
-          self,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          self as any,
           self.connectionTrackConfigurations(assemblyName, connection),
           self.collapsed,
         )
       },
-
-      // This recursively gets tracks from lower paths
-      allTracksInCategoryPath(path, connection, assemblyName) {
-        let currentHier = connection
-          ? self.connectionHierarchy(connection)
-          : self.hierarchy(assemblyName)
-        path.forEach(pathItem => {
-          currentHier = currentHier.get(pathItem) || new Map()
-        })
-        let tracks = {}
-        currentHier.forEach((contents, name) => {
-          if (contents.trackId) {
-            tracks[contents.trackId] = contents
-          } else {
-            tracks = Object.assign(
-              tracks,
-              self.allTracksInCategoryPath(path.concat([name])),
-            )
-          }
-        })
-        return tracks
-      },
     }))
+}
+
+export type HierarchicalTrackSelectorStateModel = ReturnType<
+  typeof stateTreeFactory
+>
+export type HierarchicalTrackSelectorModel =
+  Instance<HierarchicalTrackSelectorStateModel>