@jbrowse/plugin-data-management 2.6.1 → 2.6.2

package/src/HierarchicalTrackSelectorWidget/index.ts

@@ -1,25 +0,0 @@
-import stateModelFactory from './model'
-import configSchema from './configSchema'
-import PluginManager from '@jbrowse/core/PluginManager'
-import { WidgetType } from '@jbrowse/core/pluggableElementTypes'
-import { lazy } from 'react'
-
-export default (pluginManager: PluginManager) => {
-  pluginManager.addWidgetType(() => {
-    return new WidgetType({
-      name: 'HierarchicalTrackSelectorWidget',
-      heading: 'Available tracks',
-      configSchema,
-      stateModel: stateModelFactory(pluginManager),
-      ReactComponent: lazy(
-        () => import('./components/HierarchicalTrackSelector'),
-      ),
-    })
-  })
-}
-
-export {
-  type HierarchicalTrackSelectorModel,
-  default as stateModelFactory,
-} from './model'
-export { default as configSchema } from './configSchema'

package/src/HierarchicalTrackSelectorWidget/model.test.js

@@ -1,24 +0,0 @@
-import { generateHierarchy } from './model'
-
-xtest('can generate hierarchy correctly', () => {
-  const trackConfigurations = [
-    {
-      trackId: 'zonker',
-      category: { expr: { evalSync: () => ['Bar', 'Baz'] } },
-    },
-    { trackId: 'zoo' },
-    { trackId: 'bee', category: { expr: { evalSync: () => ['Bar'] } } },
-  ]
-  expect(generateHierarchy(trackConfigurations)).toEqual(
-    new Map([
-      [
-        'Bar',
-        new Map([
-          ['bee', trackConfigurations[2]],
-          ['Baz', new Map([['zonker', trackConfigurations[0]]])],
-        ]),
-      ],
-      ['zoo', trackConfigurations[1]],
-    ]),
-  )
-})

package/src/HierarchicalTrackSelectorWidget/model.ts

@@ -1,339 +0,0 @@
-import { types, getSnapshot, Instance } from 'mobx-state-tree'
-import {
-  getConf,
-  readConfObject,
-  AnyConfigurationModel,
-} from '@jbrowse/core/configuration'
-import {
-  AbstractSessionModel,
-  dedupe,
-  getSession,
-  getEnv,
-  notEmpty,
-} from '@jbrowse/core/util'
-import { getTrackName } from '@jbrowse/core/util/tracks'
-import { ElementId } from '@jbrowse/core/util/types/mst'
-import PluginManager from '@jbrowse/core/PluginManager'
-
-function hasAnyOverlap<T>(a1: T[] = [], a2: T[] = []) {
-  // shortcut case is that arrays are single entries, and are equal
-  // long case is that we use a set
-  if (a1[0] === a2[0]) {
-    return true
-  } else {
-    const s1 = new Set(a1)
-    return a2.some(a => s1.has(a))
-  }
-}
-
-export function matches(
-  query: string,
-  conf: AnyConfigurationModel,
-  session: AbstractSessionModel,
-) {
-  const categories = readConfObject(conf, 'category') as string[] | undefined
-  const queryLower = query.toLowerCase()
-  return (
-    getTrackName(conf, session).toLowerCase().includes(queryLower) ||
-    !!categories?.filter(c => c.toLowerCase().includes(queryLower)).length
-  )
-}
-
-export type TreeNode = {
-  name: string
-  id: string
-  conf?: AnyConfigurationModel
-  checked?: boolean
-  isOpenByDefault?: boolean
-  children: TreeNode[]
-}
-
-function filterTracks(
-  tracks: AnyConfigurationModel[],
-  self: {
-    view: { type: string; trackSelectorAnyOverlap?: boolean }
-    assemblyNames: string[]
-  },
-) {
-  const { assemblyManager } = getSession(self)
-  const { pluginManager } = getEnv(self)
-  const { view } = self
-  const { trackSelectorAnyOverlap } = view
-  const trackListAssemblies = self.assemblyNames
-    .map(a => assemblyManager.get(a))
-    .filter(notEmpty)
-
-  return tracks
-    .filter(c => {
-      const trackAssemblyNames = readConfObject(c, 'assemblyNames') as string[]
-      const trackAssemblies = new Set(
-        trackAssemblyNames
-          ?.map(name => assemblyManager.get(name))
-          .filter(notEmpty) || [],
-      )
-      return trackSelectorAnyOverlap
-        ? trackListAssemblies.some(a => trackAssemblies.has(a))
-        : trackListAssemblies.every(a => trackAssemblies.has(a))
-    })
-    .filter(c => {
-      const { displayTypes } = pluginManager.getViewType(view.type)
-      const compatDisplays = displayTypes.map(d => d.name)
-      const trackDisplays = c.displays.map((d: { type: string }) => d.type)
-      return hasAnyOverlap(compatDisplays, trackDisplays)
-    })
-}
-
-export function generateHierarchy(
-  model: HierarchicalTrackSelectorModel,
-  trackConfigurations: AnyConfigurationModel[],
-  collapsed: { get: (arg: string) => boolean | undefined },
-  extra?: string,
-) {
-  const hierarchy = { children: [] as TreeNode[] } as TreeNode
-  const { filterText, view } = model
-  const session = getSession(model)
-
-  trackConfigurations
-    .filter(conf => matches(filterText, conf, session))
-    .forEach(conf => {
-      // copy the categories since this array can be mutated downstream
-      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 (conf.trackId.endsWith('sessionTrack')) {
-        categories.unshift(' Session tracks')
-      }
-
-      let currLevel = hierarchy
-
-      // find existing category to put track into or create it
-      for (let i = 0; i < categories.length; i++) {
-        const category = categories[i]
-        const ret = currLevel.children.find(c => c.name === category)
-        const id = extra + '-' + categories.slice(0, i + 1).join(',')
-        if (!ret) {
-          const n = {
-            children: [],
-            name: category,
-            id,
-            isOpenByDefault: !collapsed.get(id),
-          }
-          currLevel.children.push(n)
-          currLevel = n
-        } else {
-          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: conf.trackId,
-          name: getTrackName(conf, session),
-          conf,
-          checked: tracks.some(f => f.configuration === conf),
-          children: [],
-        },
-      )
-    })
-
-  return hierarchy.children
-}
-
-/**
- * #stateModel HierarchicalTrackSelectorWidget
- */
-export default function stateTreeFactory(pluginManager: PluginManager) {
-  return types
-    .model('HierarchicalTrackSelectorWidget', {
-      /**
-       * #property
-       */
-      id: ElementId,
-      /**
-       * #property
-       */
-      type: types.literal('HierarchicalTrackSelectorWidget'),
-      /**
-       * #property
-       */
-      collapsed: types.map(types.boolean),
-      /**
-       * #property
-       */
-      view: types.safeReference(
-        pluginManager.pluggableMstType('view', 'stateModel'),
-      ),
-    })
-    .volatile(() => ({
-      selection: [] as AnyConfigurationModel[],
-      filterText: '',
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      setSelection(elt: AnyConfigurationModel[]) {
-        self.selection = elt
-      },
-      /**
-       * #action
-       */
-      addToSelection(elt: AnyConfigurationModel[]) {
-        self.selection = dedupe([...self.selection, ...elt], e => e.trackId)
-      },
-      /**
-       * #action
-       */
-      removeFromSelection(elt: AnyConfigurationModel[]) {
-        self.selection = self.selection.filter(f => !elt.includes(f))
-      },
-      /**
-       * #action
-       */
-      clearSelection() {
-        self.selection = []
-      },
-      /**
-       * #action
-       */
-      setView(view: unknown) {
-        self.view = view
-      },
-      /**
-       * #action
-       */
-      toggleCategory(pathName: string) {
-        self.collapsed.set(pathName, !self.collapsed.get(pathName))
-      },
-      /**
-       * #action
-       */
-      clearFilterText() {
-        self.filterText = ''
-      },
-      /**
-       * #action
-       */
-      setFilterText(newText: string) {
-        self.filterText = newText
-      },
-    }))
-    .views(self => ({
-      /**
-       * #method
-       */
-      getRefSeqTrackConf(
-        assemblyName: string,
-      ): AnyConfigurationModel | undefined {
-        const { assemblyManager } = getSession(self)
-        const assembly = assemblyManager.get(assemblyName)
-        const trackConf = assembly?.configuration.sequence
-        const viewType = pluginManager.getViewType(self.view.type)
-        if (!trackConf) {
-          return undefined
-        }
-        for (const display of trackConf.displays) {
-          if (viewType.displayTypes.some(d => d.name === display.type)) {
-            return trackConf
-          }
-        }
-        return undefined
-      },
-    }))
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get assemblyNames(): string[] {
-        return self.view?.assemblyNames || []
-      },
-    }))
-    .views(self => ({
-      /**
-       * #method
-       * filter out tracks that don't match the current display types
-       */
-      connectionTrackConfigurations(connection: {
-        tracks: AnyConfigurationModel[]
-      }) {
-        return !self.view ? [] : filterTracks(connection.tracks, self)
-      },
-
-      /**
-       * #getter
-       * filter out tracks that don't match the current assembly/display types
-       */
-      get trackConfigurations(): AnyConfigurationModel[] {
-        return !self.view
-          ? ([] as AnyConfigurationModel[])
-          : [
-              ...self.assemblyNames.map(a => self.getRefSeqTrackConf(a)),
-              ...filterTracks(getSession(self).tracks, self),
-            ].filter(notEmpty)
-      },
-    }))
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get hierarchy() {
-        const hier = generateHierarchy(
-          self as HierarchicalTrackSelectorModel,
-          self.trackConfigurations,
-          self.collapsed,
-        )
-
-        const session = getSession(self)
-        const { connectionInstances } = session
-
-        const conns =
-          connectionInstances
-            ?.map(c => ({
-              // @ts-expect-error
-              id: getSnapshot(c).configuration,
-              name: getConf(c, 'name'),
-              children: this.connectionHierarchy(c),
-              state: {
-                expanded: true,
-              },
-            }))
-            .filter(f => f.children.length) || []
-
-        return {
-          name: 'Root',
-          id: 'Root',
-          children: [
-            { name: 'Tracks', id: 'Tracks', children: hier },
-            ...conns,
-          ],
-        }
-      },
-
-      /**
-       * #method
-       */
-      connectionHierarchy(connection: {
-        name: string
-        tracks: AnyConfigurationModel[]
-      }) {
-        return generateHierarchy(
-          self as HierarchicalTrackSelectorModel,
-          self.connectionTrackConfigurations(connection),
-          self.collapsed,
-          connection.name,
-        )
-      },
-    }))
-}
-
-export type HierarchicalTrackSelectorStateModel = ReturnType<
-  typeof stateTreeFactory
->
-export type HierarchicalTrackSelectorModel =
-  Instance<HierarchicalTrackSelectorStateModel>

package/src/PluginStoreWidget/components/CustomPluginForm.tsx

@@ -1,165 +0,0 @@
-import React, { useState } from 'react'
-import { observer } from 'mobx-react'
-import { getRoot } from 'mobx-state-tree'
-import { Dialog } from '@jbrowse/core/ui'
-import {
-  Button,
-  Collapse,
-  DialogActions,
-  DialogContent,
-  DialogContentText,
-  TextField,
-} from '@mui/material'
-import { makeStyles } from 'tss-react/mui'
-
-// icons
-import IconButton from '@mui/material/IconButton'
-import ExpandMoreIcon from '@mui/icons-material/ExpandMore'
-
-// locals
-import { PluginStoreModel } from '../model'
-
-const useStyles = makeStyles()(theme => ({
-  dialogContent: {
-    display: 'flex',
-    flexDirection: 'column',
-  },
-  expand: {
-    transform: 'rotate(0deg)',
-    marginLeft: 'auto',
-    transition: theme.transitions.create('transform', {
-      duration: theme.transitions.duration.shortest,
-    }),
-  },
-  expandOpen: {
-    transform: 'rotate(180deg)',
-  },
-}))
-
-function CustomPluginForm({
-  open,
-  onClose,
-  model,
-}: {
-  open: boolean
-  onClose(): void
-  model: PluginStoreModel
-}) {
-  const { classes, cx } = useStyles()
-  const [umdPluginName, setUMDPluginName] = useState('')
-  const [umdPluginUrl, setUMDPluginUrl] = useState('')
-  const [esmPluginUrl, setESMPluginUrl] = useState('')
-  const [cjsPluginUrl, setCJSPluginUrl] = useState('')
-  const [advancedOptionsOpen, setAdvancedOptionsOpen] = useState(false)
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const { jbrowse } = getRoot<any>(model)
-
-  const ready = Boolean(
-    (umdPluginName && umdPluginUrl) || esmPluginUrl || cjsPluginUrl,
-  )
-
-  function handleSubmit() {
-    if (umdPluginName && umdPluginUrl) {
-      jbrowse.addPlugin({ name: umdPluginName, umdUrl: umdPluginUrl })
-    }
-    if (esmPluginUrl) {
-      jbrowse.addPlugin({ esmUrl: esmPluginUrl })
-    }
-    if (cjsPluginUrl) {
-      jbrowse.addPlugin({ cjsUrl: cjsPluginUrl })
-    }
-  }
-
-  function handleClose() {
-    setUMDPluginName('')
-    setUMDPluginUrl('')
-    setESMPluginUrl('')
-    setCJSPluginUrl('')
-    onClose()
-  }
-
-  return (
-    <Dialog open={open} onClose={handleClose} title="Add custom plugin">
-      <form onSubmit={handleSubmit}>
-        <DialogContent className={classes.dialogContent}>
-          <DialogContentText>
-            Enter the name of the plugin and its URL. The name should match what
-            is defined in the plugin&apos;s build.
-          </DialogContentText>
-          <TextField
-            id="umd-name-input"
-            name="umdName"
-            label="Plugin name"
-            variant="outlined"
-            value={umdPluginName}
-            onChange={event => setUMDPluginName(event.target.value)}
-          />
-          <TextField
-            id="umd-url-input"
-            name="umdUrl"
-            label="Plugin URL"
-            variant="outlined"
-            value={umdPluginUrl}
-            onChange={event => setUMDPluginUrl(event.target.value)}
-          />
-          <DialogContentText
-            onClick={() => setAdvancedOptionsOpen(!advancedOptionsOpen)}
-          >
-            <IconButton
-              className={cx(classes.expand, {
-                [classes.expandOpen]: advancedOptionsOpen,
-              })}
-              aria-expanded={advancedOptionsOpen}
-              aria-label="show more"
-            >
-              <ExpandMoreIcon />
-            </IconButton>
-            Advanced options
-          </DialogContentText>
-          <Collapse in={advancedOptionsOpen}>
-            <div className={classes.dialogContent}>
-              <DialogContentText>
-                The above fields assume that the plugin is built in UMD format.
-                If your plugin is in another format, or you have additional
-                builds you want to add (such as a CJS build for using NodeJS
-                APIs in desktop), you can enter the URLs for those builds below.
-              </DialogContentText>
-              <TextField
-                id="esm-url-input"
-                name="esmUrl"
-                label="ESM build URL"
-                variant="outlined"
-                value={esmPluginUrl}
-                onChange={event => setESMPluginUrl(event.target.value)}
-              />
-              <TextField
-                id="cjs-url-input"
-                name="cjsUrl"
-                label="CJS build URL"
-                variant="outlined"
-                value={cjsPluginUrl}
-                onChange={event => setCJSPluginUrl(event.target.value)}
-              />
-            </div>
-          </Collapse>
-        </DialogContent>
-        <DialogActions>
-          <Button variant="contained" onClick={handleClose}>
-            Cancel
-          </Button>
-          <Button
-            variant="contained"
-            color="primary"
-            onClick={handleSubmit}
-            disabled={!ready}
-          >
-            Submit
-          </Button>
-        </DialogActions>
-      </form>
-    </Dialog>
-  )
-}
-
-export default observer(CustomPluginForm)