@jbrowse/product-core 2.6.1 → 2.6.2

package/src/Session/Connections.ts

@@ -1,145 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import {
-  AnyConfigurationModel,
-  readConfObject,
-} from '@jbrowse/core/configuration'
-import { IAnyStateTreeNode, Instance, types } from 'mobx-state-tree'
-import { BaseConnectionConfigModel } from '@jbrowse/core/pluggableElementTypes/models/baseConnectionConfig'
-import { BaseConnectionModel } from '@jbrowse/core/pluggableElementTypes/models/BaseConnectionModelFactory'
-
-// locals
-import type { BaseRootModelType } from '../RootModel/BaseRootModel'
-import type { SessionWithReferenceManagementType } from './ReferenceManagement'
-import { isBaseSession } from './BaseSession'
-
-/**
- * #stateModel ConnectionManagementSessionMixin
- */
-export function ConnectionManagementSessionMixin(pluginManager: PluginManager) {
-  return types
-    .model({
-      /**
-       * #property
-       */
-      connectionInstances: types.array(
-        pluginManager.pluggableMstType(
-          'connection',
-          'stateModel',
-        ) as BaseConnectionModel,
-      ),
-    })
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get connections(): BaseConnectionConfigModel[] {
-        const { jbrowse } = self as typeof self & Instance<BaseRootModelType>
-        return jbrowse.connections
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      makeConnection(
-        configuration: AnyConfigurationModel,
-        initialSnapshot = {},
-      ) {
-        const type = configuration.type as string
-        if (!type) {
-          throw new Error('track configuration has no `type` listed')
-        }
-        const name = readConfObject(configuration, 'name')
-        const connectionType = pluginManager.getConnectionType(type)
-        if (!connectionType) {
-          throw new Error(`unknown connection type ${type}`)
-        }
-        const length = self.connectionInstances.push({
-          ...initialSnapshot,
-          name,
-          // @ts-expect-error unsure why ts doesn't like `type` here, but is
-          // needed
-          type,
-          configuration,
-        })
-        return self.connectionInstances[length - 1]
-      },
-
-      /**
-       * #action
-       */
-      prepareToBreakConnection(configuration: AnyConfigurationModel) {
-        const root = self as typeof self &
-          Instance<SessionWithReferenceManagementType>
-        const callbacksToDeref: Function[] = []
-        const derefTypeCount: Record<string, number> = {}
-        const name = readConfObject(configuration, 'name')
-        const connection = self.connectionInstances.find(c => c.name === name)
-        if (!connection) {
-          return undefined
-        }
-        for (const track of connection.tracks) {
-          const ref = root.getReferring(track)
-          root.removeReferring(ref, track, callbacksToDeref, derefTypeCount)
-        }
-        return [
-          () => {
-            callbacksToDeref.forEach(cb => cb())
-            this.breakConnection(configuration)
-          },
-          derefTypeCount,
-        ]
-      },
-
-      /**
-       * #action
-       */
-      breakConnection(configuration: AnyConfigurationModel) {
-        const name = readConfObject(configuration, 'name')
-        const connection = self.connectionInstances.find(c => c.name === name)
-        if (!connection) {
-          throw new Error(`no connection found with name ${name}`)
-        }
-        self.connectionInstances.remove(connection)
-      },
-
-      /**
-       * #action
-       */
-      deleteConnection(configuration: AnyConfigurationModel) {
-        const { jbrowse } = self as typeof self & Instance<BaseRootModelType>
-        return jbrowse.deleteConnectionConf(configuration)
-      },
-
-      /**
-       * #action
-       */
-      addConnectionConf(connectionConf: BaseConnectionConfigModel) {
-        const { jbrowse } = self as typeof self & Instance<BaseRootModelType>
-        return jbrowse.addConnectionConf(connectionConf)
-      },
-
-      /**
-       * #action
-       */
-      clearConnections() {
-        self.connectionInstances.clear()
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that has connections */
-export type SessionWithConnectionsType = ReturnType<
-  typeof ConnectionManagementSessionMixin
->
-
-/** Instance of a session that has connections: `connectionInstances`,
- * `makeConnection()`, etc. */
-export type SessionWithConnections = Instance<SessionWithConnectionsType>
-
-/** Type guard for SessionWithConnections */
-export function isSessionWithConnections(
-  session: IAnyStateTreeNode,
-): session is SessionWithConnections {
-  return isBaseSession(session) && 'connectionInstances' in session
-}

package/src/Session/DialogQueue.ts

@@ -1,63 +0,0 @@
-/** MST mixin for managing a queue of dialogs at the level of the session */
-
-import PluginManager from '@jbrowse/core/PluginManager'
-import { DialogComponentType } from '@jbrowse/core/util'
-import { IAnyStateTreeNode, Instance, types } from 'mobx-state-tree'
-import { isBaseSession } from './BaseSession'
-
-/**
- * #stateModel DialogQueueSessionMixin
- */
-export function DialogQueueSessionMixin(pluginManager: PluginManager) {
-  return types
-    .model('DialogQueueSessionMixin', {})
-    .volatile(() => ({
-      queueOfDialogs: [] as [DialogComponentType, unknown][],
-    }))
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get DialogComponent() {
-        return self.queueOfDialogs[0]?.[0]
-      },
-      /**
-       * #getter
-       */
-      get DialogProps() {
-        return self.queueOfDialogs[0]?.[1]
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      removeActiveDialog() {
-        self.queueOfDialogs = self.queueOfDialogs.slice(1)
-      },
-      /**
-       * #action
-       */
-      queueDialog(
-        cb: (doneCallback: () => void) => [DialogComponentType, unknown],
-      ) {
-        const [component, props] = cb(() => {
-          this.removeActiveDialog()
-        })
-        self.queueOfDialogs = [...self.queueOfDialogs, [component, props]]
-      },
-    }))
-}
-
-/** Session mixin MST type for a session that has `queueOfDialogs`, etc. */
-export type SessionWithDialogsType = ReturnType<typeof DialogQueueSessionMixin>
-
-/** Instance of a session that has dialogs */
-export type SessionWithDialogs = Instance<SessionWithDialogsType>
-
-/** Type guard for SessionWithDialogs */
-export function isSessionWithDialogs(
-  session: IAnyStateTreeNode,
-): session is SessionWithDialogs {
-  return isBaseSession(session) && 'queueOfDialogs' in session
-}

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'
-  )
-}