@jbrowse/product-core 2.6.1 → 2.6.3

package/src/Session/DrawerWidgets.ts

@@ -1,222 +0,0 @@
-import {
-  IAnyStateTreeNode,
-  Instance,
-  addDisposer,
-  isAlive,
-  types,
-} from 'mobx-state-tree'
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import { localStorageGetItem, localStorageSetItem } from '@jbrowse/core/util'
-import { autorun } from 'mobx'
-import {
-  AnyConfigurationModel,
-  isConfigurationModel,
-} from '@jbrowse/core/configuration'
-import { isBaseSession } from './BaseSession'
-
-const minDrawerWidth = 128
-
-/**
- * #stateModel DrawerWidgetSessionMixin
- */
-export function DrawerWidgetSessionMixin(pluginManager: PluginManager) {
-  const widgetStateModelType = pluginManager.pluggableMstType(
-    'widget',
-    'stateModel',
-  )
-  type WidgetStateModel = Instance<typeof widgetStateModelType>
-  return types
-    .model({
-      /**
-       * #property
-       */
-      drawerPosition: types.optional(
-        types.string,
-        () => localStorageGetItem('drawerPosition') || 'right',
-      ),
-      /**
-       * #property
-       */
-      drawerWidth: types.optional(
-        types.refinement(types.integer, width => width >= minDrawerWidth),
-        384,
-      ),
-      /**
-       * #property
-       */
-      widgets: types.map(widgetStateModelType),
-      /**
-       * #property
-       */
-      activeWidgets: types.map(types.safeReference(widgetStateModelType)),
-
-      /**
-       * #property
-       */
-      minimized: types.optional(types.boolean, false),
-    })
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get visibleWidget() {
-        if (isAlive(self)) {
-          // returns most recently added item in active widgets
-          return [...self.activeWidgets.values()][self.activeWidgets.size - 1]
-        }
-        return undefined
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      setDrawerPosition(arg: string) {
-        self.drawerPosition = arg
-        localStorage.setItem('drawerPosition', arg)
-      },
-
-      /**
-       * #action
-       */
-      updateDrawerWidth(drawerWidth: number) {
-        if (drawerWidth === self.drawerWidth) {
-          return self.drawerWidth
-        }
-        let newDrawerWidth = drawerWidth
-        if (newDrawerWidth < minDrawerWidth) {
-          newDrawerWidth = minDrawerWidth
-        }
-        self.drawerWidth = newDrawerWidth
-        return newDrawerWidth
-      },
-
-      /**
-       * #action
-       */
-      resizeDrawer(distance: number) {
-        if (self.drawerPosition === 'left') {
-          distance *= -1
-        }
-        const oldDrawerWidth = self.drawerWidth
-        const newDrawerWidth = this.updateDrawerWidth(oldDrawerWidth - distance)
-        return oldDrawerWidth - newDrawerWidth
-      },
-
-      /**
-       * #action
-       */
-      addWidget(
-        typeName: string,
-        id: string,
-        initialState = {},
-        conf?: unknown,
-      ) {
-        const typeDefinition = pluginManager.getElementType('widget', typeName)
-        if (!typeDefinition) {
-          throw new Error(`unknown widget type ${typeName}`)
-        }
-        const data = {
-          ...initialState,
-          id,
-          type: typeName,
-          configuration: conf || { type: typeName },
-        }
-        self.widgets.set(id, data)
-        return self.widgets.get(id)
-      },
-
-      /**
-       * #action
-       */
-      showWidget(widget: WidgetStateModel) {
-        if (self.activeWidgets.has(widget.id)) {
-          self.activeWidgets.delete(widget.id)
-        }
-        self.activeWidgets.set(widget.id, widget)
-        self.minimized = false
-      },
-
-      /**
-       * #action
-       */
-      hasWidget(widget: WidgetStateModel) {
-        return self.activeWidgets.has(widget.id)
-      },
-
-      /**
-       * #action
-       */
-      hideWidget(widget: WidgetStateModel) {
-        self.activeWidgets.delete(widget.id)
-      },
-
-      /**
-       * #action
-       */
-      minimizeWidgetDrawer() {
-        self.minimized = true
-      },
-      /**
-       * #action
-       */
-      showWidgetDrawer() {
-        self.minimized = false
-      },
-      /**
-       * #action
-       */
-      hideAllWidgets() {
-        self.activeWidgets.clear()
-      },
-
-      /**
-       * #action
-       * opens a configuration editor to configure the given thing,
-       * and sets the current task to be configuring it
-       * @param configuration -
-       */
-      editConfiguration(configuration: AnyConfigurationModel) {
-        if (!isConfigurationModel(configuration)) {
-          throw new Error(
-            'must pass a configuration model to editConfiguration',
-          )
-        }
-        const editor = this.addWidget(
-          'ConfigurationEditorWidget',
-          'configEditor',
-          { target: configuration },
-        )
-        this.showWidget(editor)
-      },
-
-      afterAttach() {
-        addDisposer(
-          self,
-          autorun(() => {
-            localStorageSetItem('drawerPosition', self.drawerPosition)
-          }),
-        )
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that manages drawer widgets */
-export type SessionWithDrawerWidgetsType = ReturnType<
-  typeof DrawerWidgetSessionMixin
->
-
-/** Instance of a session that manages drawer widgets */
-export type SessionWithDrawerWidgets = Instance<SessionWithDrawerWidgetsType>
-
-/** Type guard for SessionWithDrawerWidgets */
-export function isSessionWithDrawerWidgets(
-  session: IAnyStateTreeNode,
-): session is SessionWithDrawerWidgets {
-  return (
-    isBaseSession(session) &&
-    'widgets' in session &&
-    'drawerPosition' in session
-  )
-}

package/src/Session/MultipleViews.ts

@@ -1,151 +0,0 @@
-import {
-  IAnyStateTreeNode,
-  Instance,
-  getSnapshot,
-  types,
-} from 'mobx-state-tree'
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import { readConfObject } from '@jbrowse/core/configuration'
-import { Region } from '@jbrowse/core/util'
-import { DrawerWidgetSessionMixin } from './DrawerWidgets'
-import { IBaseViewModel } from '@jbrowse/core/pluggableElementTypes'
-import { IBaseViewModelWithDisplayedRegions } from '@jbrowse/core/pluggableElementTypes/models/BaseViewModel'
-
-// locals
-import { BaseSessionModel, isBaseSession } from './BaseSession'
-
-/**
- * #stateModel MultipleViewsSessionMixin
- */
-export function MultipleViewsSessionMixin(pluginManager: PluginManager) {
-  return types
-    .compose(
-      BaseSessionModel(pluginManager),
-      DrawerWidgetSessionMixin(pluginManager),
-    )
-    .props({
-      /**
-       * #property
-       */
-      views: types.array(pluginManager.pluggableMstType('view', 'stateModel')),
-    })
-    .actions(self => ({
-      /**
-       * #action
-       */
-      moveViewUp(id: string) {
-        const idx = self.views.findIndex(v => v.id === id)
-
-        if (idx === -1) {
-          return
-        }
-        if (idx > 0) {
-          self.views.splice(idx - 1, 2, self.views[idx], self.views[idx - 1])
-        }
-      },
-      /**
-       * #action
-       */
-      moveViewDown(id: string) {
-        const idx = self.views.findIndex(v => v.id === id)
-
-        if (idx === -1) {
-          return
-        }
-
-        if (idx < self.views.length - 1) {
-          self.views.splice(idx, 2, self.views[idx + 1], self.views[idx])
-        }
-      },
-
-      /**
-       * #action
-       */
-      addView(typeName: string, initialState = {}) {
-        const typeDefinition = pluginManager.getElementType('view', typeName)
-        if (!typeDefinition) {
-          throw new Error(`unknown view type ${typeName}`)
-        }
-
-        const length = self.views.push({
-          ...initialState,
-          type: typeName,
-        })
-        return self.views[length - 1]
-      },
-
-      /**
-       * #action
-       */
-      removeView(view: IBaseViewModel) {
-        for (const [, widget] of self.activeWidgets) {
-          if (widget.view && widget.view.id === view.id) {
-            self.hideWidget(widget)
-          }
-        }
-        self.views.remove(view)
-      },
-
-      /**
-       * #action
-       */
-      addLinearGenomeViewOfAssembly(assemblyName: string, initialState = {}) {
-        return this.addViewOfAssembly(
-          'LinearGenomeView',
-          assemblyName,
-          initialState,
-        )
-      },
-
-      /**
-       * #action
-       */
-      addViewOfAssembly(
-        viewType: string,
-        assemblyName: string,
-        initialState: Record<string, unknown> = {},
-      ) {
-        const asm = self.assemblies.find(
-          s => readConfObject(s, 'name') === assemblyName,
-        )
-        if (!asm) {
-          throw new Error(
-            `Could not add view of assembly "${assemblyName}", assembly name not found`,
-          )
-        }
-        return this.addView(viewType, {
-          ...initialState,
-          displayRegionsFromAssemblyName: readConfObject(asm, 'name'),
-        })
-      },
-
-      /**
-       * #action
-       */
-      addViewFromAnotherView(
-        viewType: string,
-        otherView: IBaseViewModelWithDisplayedRegions,
-        initialState: { displayedRegions?: Region[] } = {},
-      ) {
-        const state = { ...initialState }
-        state.displayedRegions = getSnapshot(otherView.displayedRegions)
-        return this.addView(viewType, state)
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that manages multiple views */
-export type SessionWithMultipleViewsType = ReturnType<
-  typeof MultipleViewsSessionMixin
->
-
-/** Instance of a session with multiple views */
-export type SessionWithMultipleViews = Instance<SessionWithMultipleViewsType>
-
-/** Type guard for SessionWithMultipleViews */
-export function isSessionWithMultipleViews(
-  session: IAnyStateTreeNode,
-): session is SessionWithMultipleViews {
-  return isBaseSession(session) && 'views' in session
-}

package/src/Session/ReferenceManagement.ts

@@ -1,134 +0,0 @@
-/** MST props, views, actions, etc related to managing connections */
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import {
-  TrackViewModel,
-  getContainingView,
-  isSessionModelWithWidgets,
-} from '@jbrowse/core/util'
-import {
-  IAnyStateTreeNode,
-  Instance,
-  getMembers,
-  getParent,
-  getSnapshot,
-  getType,
-  isModelType,
-  isReferenceType,
-  types,
-  walk,
-} from 'mobx-state-tree'
-
-import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes'
-// locals
-import { isBaseSession } from './BaseSession'
-
-export interface ReferringNode {
-  node: IAnyStateTreeNode
-  key: string
-}
-
-/**
- * #stateModel ReferenceManagementSessionMixin
- */
-export function ReferenceManagementSessionMixin(pluginManager: PluginManager) {
-  return types
-    .model('ReferenceManagementSessionMixin', {})
-    .views(self => ({
-      /**
-       * #method
-       * See if any MST nodes currently have a types.reference to this object.
-       *
-       * @param object - object
-       * @returns An array where the first element is the node referring
-       * to the object and the second element is they property name the node is
-       * using to refer to the object
-       */
-      getReferring(object: IAnyStateTreeNode) {
-        const refs: ReferringNode[] = []
-        walk(getParent(self), node => {
-          if (isModelType(getType(node))) {
-            const members = getMembers(node)
-            Object.entries(members.properties).forEach(([key, value]) => {
-              if (isReferenceType(value) && node[key] === object) {
-                refs.push({ node, key })
-              }
-            })
-          }
-        })
-        return refs
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      removeReferring(
-        referring: ReferringNode[],
-        track: BaseTrackConfig,
-        callbacks: Function[],
-        dereferenceTypeCount: Record<string, number>,
-      ) {
-        referring.forEach(({ node }) => {
-          let dereferenced = false
-          try {
-            // If a view is referring to the track config, remove the track
-            // from the view
-            const type = 'open track(s)'
-            const view = getContainingView(node) as TrackViewModel
-            callbacks.push(() => view.hideTrack(track.trackId))
-            dereferenced = true
-            if (!dereferenceTypeCount[type]) {
-              dereferenceTypeCount[type] = 0
-            }
-            dereferenceTypeCount[type] += 1
-          } catch (err1) {
-            // ignore
-          }
-
-          if (isSessionModelWithWidgets(self) && self.widgets.has(node.id)) {
-            // If a configuration editor widget has the track config
-            // open, close the widget
-            const type = 'configuration editor widget(s)'
-            if (isSessionModelWithWidgets(self)) {
-              callbacks.push(() => self.hideWidget(node))
-            }
-            dereferenced = true
-            if (!dereferenceTypeCount[type]) {
-              dereferenceTypeCount[type] = 0
-            }
-            dereferenceTypeCount[type] += 1
-          }
-          if (!dereferenced) {
-            throw new Error(
-              `Error when closing this connection, the following node is still referring to a track configuration: ${JSON.stringify(
-                getSnapshot(node),
-              )}`,
-            )
-          }
-        })
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that manages multiple views */
-export type SessionWithReferenceManagementType = ReturnType<
-  typeof ReferenceManagementSessionMixin
->
-
-/** Instance of a session with MST reference management (`getReferring()`, `removeReferring()`)  */
-export type SessionWithReferenceManagement =
-  Instance<SessionWithReferenceManagementType>
-
-/** Type guard for SessionWithReferenceManagement */
-export function isSessionWithReferenceManagement(
-  thing: IAnyStateTreeNode,
-): thing is SessionWithReferenceManagement {
-  return (
-    isBaseSession(thing) &&
-    'getReferring' in thing &&
-    typeof thing.getReferring === 'function' &&
-    'removeReferring' in thing &&
-    typeof thing.removeReferring === 'function'
-  )
-}

package/src/Session/SessionTracks.ts

@@ -1,98 +0,0 @@
-import { IAnyStateTreeNode, Instance, types } from 'mobx-state-tree'
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import {
-  AnyConfiguration,
-  AnyConfigurationModel,
-} from '@jbrowse/core/configuration'
-
-// locals
-import { TracksManagerSessionMixin } from './Tracks'
-import { isBaseSession } from './BaseSession'
-
-/**
- * #stateModel SessionTracksManagerSessionMixin
- */
-export function SessionTracksManagerSessionMixin(pluginManager: PluginManager) {
-  return TracksManagerSessionMixin(pluginManager)
-    .named('SessionTracksManagerSessionMixin')
-    .props({
-      /**
-       * #property
-       */
-      sessionTracks: types.array(
-        pluginManager.pluggableConfigSchemaType('track'),
-      ),
-    })
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get tracks(): AnyConfigurationModel[] {
-        return self.jbrowse.tracks
-      },
-    }))
-    .actions(self => {
-      const {
-        addTrackConf: superAddTrackConf,
-        deleteTrackConf: superDeleteTrackConf,
-      } = self
-      return {
-        /**
-         * #action
-         */
-        addTrackConf(trackConf: AnyConfiguration) {
-          if (self.adminMode) {
-            return superAddTrackConf(trackConf)
-          }
-          const { trackId, type } = trackConf as {
-            type: string
-            trackId: string
-          }
-          if (!type) {
-            throw new Error(`unknown track type ${type}`)
-          }
-          const track = self.sessionTracks.find(t => t.trackId === trackId)
-          if (track) {
-            return track
-          }
-          const length = self.sessionTracks.push(trackConf)
-          return self.sessionTracks[length - 1]
-        },
-
-        /**
-         * #action
-         */
-        deleteTrackConf(trackConf: AnyConfigurationModel) {
-          // try to delete it in the main config if in admin mode
-          const found = superDeleteTrackConf(trackConf)
-          if (found) {
-            return found
-          }
-          // if not found or not in admin mode, try to delete it in the
-          // sessionTracks
-          const { trackId } = trackConf
-          const idx = self.sessionTracks.findIndex(t => t.trackId === trackId)
-          if (idx === -1) {
-            return undefined
-          }
-          return self.sessionTracks.splice(idx, 1)
-        },
-      }
-    })
-}
-
-/** Session mixin MST type for a session that has `sessionTracks` */
-export type SessionWithSessionTracksType = ReturnType<
-  typeof SessionTracksManagerSessionMixin
->
-
-/** Instance of a session that has `sessionTracks` */
-export type SessionWithSessionTracks = Instance<SessionWithSessionTracksType>
-
-/** Type guard for SessionWithSessionTracks */
-export function isSessionWithSessionTracks(
-  thing: IAnyStateTreeNode,
-): thing is SessionWithSessionTracks {
-  return isBaseSession(thing) && 'sessionTracks' in thing
-}

package/src/Session/Themes.ts

@@ -1,85 +0,0 @@
-import {
-  IAnyStateTreeNode,
-  Instance,
-  addDisposer,
-  types,
-} from 'mobx-state-tree'
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import { getConf } from '@jbrowse/core/configuration'
-import { createJBrowseTheme, defaultThemes } from '@jbrowse/core/ui'
-import { localStorageGetItem, localStorageSetItem } from '@jbrowse/core/util'
-import { ThemeOptions } from '@mui/material'
-import { autorun } from 'mobx'
-
-// locals
-import { BaseSession } from './BaseSession'
-
-type ThemeMap = { [key: string]: ThemeOptions }
-
-/**
- * #stateModel ThemeManagerSessionMixin
- */
-export function ThemeManagerSessionMixin(pluginManager: PluginManager) {
-  return types
-    .model({})
-    .volatile(() => ({
-      sessionThemeName: localStorageGetItem('themeName') || 'default',
-    }))
-    .views(s => ({
-      /**
-       * #method
-       */
-      allThemes(): ThemeMap {
-        const self = s as typeof s & BaseSession
-        const extraThemes = getConf(self.jbrowse, 'extraThemes')
-        return { ...defaultThemes, ...extraThemes }
-      },
-      /**
-       * #getter
-       */
-      get themeName() {
-        const { sessionThemeName } = s
-        const all = this.allThemes()
-        return all[sessionThemeName] ? sessionThemeName : 'default'
-      },
-      /**
-       * #getter
-       */
-      get theme() {
-        const self = s as typeof s & BaseSession
-        const configTheme = getConf(self.jbrowse, 'theme')
-        const all = this.allThemes()
-        return createJBrowseTheme(configTheme, all, this.themeName)
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      setThemeName(name: string) {
-        self.sessionThemeName = name
-      },
-      afterAttach() {
-        addDisposer(
-          self,
-          autorun(() => {
-            localStorageSetItem('themeName', self.themeName)
-          }),
-        )
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that supports theming */
-export type SessionWithThemesType = ReturnType<typeof ThemeManagerSessionMixin>
-
-/** Instance of a session that has theming support */
-export type SessionWithThemes = Instance<SessionWithThemesType>
-
-/** Type guard for SessionWithThemes */
-export function isSessionWithThemes(
-  session: IAnyStateTreeNode,
-): session is SessionWithThemes {
-  return 'theme' in session
-}