@jbrowse/product-core 2.6.1 → 2.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/product-core",
-  "version": "2.6.1",
+  "version": "2.6.3",
   "sideEffects": false,
   "description": "JBrowse 2 code shared between products but not used by plugins",
   "keywords": [
@@ -27,13 +27,12 @@
   "module": "esm/index.js",
   "files": [
     "dist",
-    "esm",
-    "src"
+    "esm"
   ],
   "scripts": {
     "build:esm": "tsc --build tsconfig.build.esm.json",
-    "build:es5": "tsc --build tsconfig.build.es5.json",
-    "build": "npm run build:esm && npm run build:es5",
+    "build:commonjs": "tsc --build tsconfig.build.commonjs.json",
+    "build": "npm run build:esm && npm run build:commonjs",
     "test": "cd ../..; jest packages/product-core",
     "clean": "rimraf dist esm *.tsbuildinfo",
     "prebuild": "yarn clean",
@@ -47,7 +46,9 @@
     "@mui/icons-material": "^5.0.0",
     "@mui/material": "^5.10.17",
     "copy-to-clipboard": "^3.3.1",
+    "librpc-web-mod": "^1.0.0",
     "react-error-boundary": "^4.0.3",
+    "serialize-error": "^8.0.0",
     "shortid": "^2.2.15"
   },
   "peerDependencies": {
@@ -62,5 +63,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1cbe7ba097fb2d2763c776e5e429e4670cdd583c"
+  "gitHead": "ed402c87efb0904858d602c363bd1757d5742129"
 }

package/src/RootModel/BaseRootModel.ts

@@ -1,131 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import assemblyManagerFactory, {
-  BaseAssemblyConfigSchema,
-} from '@jbrowse/core/assemblyManager'
-import RpcManager from '@jbrowse/core/rpc/RpcManager'
-import {
-  IAnyType,
-  Instance,
-  SnapshotIn,
-  cast,
-  getSnapshot,
-  isStateTreeNode,
-  types,
-} from 'mobx-state-tree'
-import TextSearchManager from '@jbrowse/core/TextSearch/TextSearchManager'
-
-/**
- * #stateModel BaseRootModel
- * #category root
- * factory function for the Base-level root model shared by all products
- */
-export function BaseRootModelFactory({
-  pluginManager,
-  jbrowseModelType,
-  sessionModelType,
-  assemblyConfigSchema,
-}: {
-  pluginManager: PluginManager
-  jbrowseModelType: IAnyType
-  sessionModelType: IAnyType
-  assemblyConfigSchema: BaseAssemblyConfigSchema
-}) {
-  return types
-    .model('BaseRootModel', {
-      /**
-       * #property
-       * `jbrowse` is a mapping of the config.json into the in-memory state
-       * tree
-       */
-      jbrowse: jbrowseModelType,
-
-      /**
-       * #property
-       * `session` encompasses the currently active state of the app, including
-       * views open, tracks open in those views, etc.
-       */
-      session: types.maybe(sessionModelType),
-      /**
-       * #property
-       */
-      sessionPath: types.optional(types.string, ''),
-
-      /**
-       * #property
-       */
-      assemblyManager: types.optional(
-        assemblyManagerFactory(assemblyConfigSchema, pluginManager),
-        {},
-      ),
-    })
-    .volatile(self => ({
-      rpcManager: new RpcManager(
-        pluginManager,
-        self.jbrowse.configuration.rpc,
-        {
-          MainThreadRpcDriver: {},
-        },
-      ),
-
-      adminMode: false,
-      isAssemblyEditing: false,
-      error: undefined as unknown,
-      textSearchManager: new TextSearchManager(pluginManager),
-      pluginManager,
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       */
-      setError(error: unknown) {
-        self.error = error
-      },
-      /**
-       * #action
-       */
-      setSession(sessionSnapshot?: SnapshotIn<IAnyType>) {
-        self.session = cast(sessionSnapshot)
-      },
-      /**
-       * #action
-       */
-      setDefaultSession() {
-        this.setSession(self.jbrowse.defaultSession)
-      },
-      /**
-       * #action
-       */
-      setSessionPath(path: string) {
-        self.sessionPath = path
-      },
-      /**
-       * #action
-       */
-      renameCurrentSession(newName: string) {
-        if (self.session) {
-          const snapshot = JSON.parse(JSON.stringify(getSnapshot(self.session)))
-          snapshot.name = newName
-          this.setSession(snapshot)
-        }
-      },
-      /**
-       * #action
-       */
-      setAssemblyEditing(flag: boolean) {
-        self.isAssemblyEditing = flag
-      },
-    }))
-}
-
-export type BaseRootModelType = ReturnType<typeof BaseRootModelFactory>
-export type BaseRootModel = Instance<BaseRootModelType>
-
-/** Type guard for checking if something is a JB root model */
-export function isRootModel(thing: unknown): thing is BaseRootModelType {
-  return (
-    isStateTreeNode(thing) &&
-    'session' in thing &&
-    'jbrowse' in thing &&
-    'assemblyManager' in thing
-  )
-}

package/src/RootModel/InternetAccounts.ts

@@ -1,126 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { AnyConfigurationModel } from '@jbrowse/core/configuration'
-import { UriLocation } from '@jbrowse/core/util'
-import { autorun } from 'mobx'
-import { Instance, addDisposer, types } from 'mobx-state-tree'
-import { BaseRootModel } from './BaseRootModel'
-
-/**
- * #stateModel InternetAccountsMixin
- * #category root
- */
-export function InternetAccountsRootModelMixin(pluginManager: PluginManager) {
-  return types
-    .model({
-      /**
-       * #property
-       */
-      internetAccounts: types.array(
-        pluginManager.pluggableMstType('internet account', 'stateModel'),
-      ),
-    })
-    .actions(self => ({
-      /**
-       * #action
-       */
-      initializeInternetAccount(
-        internetAccountConfig: AnyConfigurationModel,
-        initialSnapshot = {},
-      ) {
-        const internetAccountType = pluginManager.getInternetAccountType(
-          internetAccountConfig.type,
-        )
-        if (!internetAccountType) {
-          throw new Error(
-            `unknown internet account type ${internetAccountConfig.type}`,
-          )
-        }
-
-        const length = self.internetAccounts.push({
-          ...initialSnapshot,
-          type: internetAccountConfig.type,
-          configuration: internetAccountConfig,
-        })
-        return self.internetAccounts[length - 1]
-      },
-
-      /**
-       * #action
-       */
-      createEphemeralInternetAccount(
-        internetAccountId: string,
-        initialSnapshot = {},
-        url: string,
-      ) {
-        let hostUri
-
-        try {
-          hostUri = new URL(url).origin
-        } catch (e) {
-          // ignore
-        }
-        // id of a custom new internaccount is `${type}-${name}`
-        const internetAccountSplit = internetAccountId.split('-')
-        const configuration = {
-          type: internetAccountSplit[0],
-          internetAccountId: internetAccountId,
-          name: internetAccountSplit.slice(1).join('-'),
-          description: '',
-          domains: hostUri ? [hostUri] : [],
-        }
-        const type = pluginManager.getInternetAccountType(configuration.type)
-        const internetAccount = type.stateModel.create({
-          ...initialSnapshot,
-          type: configuration.type,
-          configuration,
-        })
-        self.internetAccounts.push(internetAccount)
-        return internetAccount
-      },
-      /**
-       * #action
-       */
-      findAppropriateInternetAccount(location: UriLocation) {
-        // find the existing account selected from menu
-        const selectedId = location.internetAccountId
-        if (selectedId) {
-          const selectedAccount = self.internetAccounts.find(account => {
-            return account.internetAccountId === selectedId
-          })
-          if (selectedAccount) {
-            return selectedAccount
-          }
-        }
-
-        // if no existing account or not found, try to find working account
-        for (const account of self.internetAccounts) {
-          const handleResult = account.handlesLocation(location)
-          if (handleResult) {
-            return account
-          }
-        }
-
-        // if still no existing account, create ephemeral config to use
-        return selectedId
-          ? this.createEphemeralInternetAccount(selectedId, {}, location.uri)
-          : null
-      },
-    }))
-    .actions(self => ({
-      afterCreate() {
-        addDisposer(
-          self,
-          autorun(() => {
-            const { jbrowse } = self as typeof self & BaseRootModel
-            jbrowse.internetAccounts.forEach(self.initializeInternetAccount)
-          }),
-        )
-      },
-    }))
-}
-
-export type RootModelWithInternetAccountsType = ReturnType<
-  typeof InternetAccountsRootModelMixin
->
-export type RootModelWithInternetAccounts =
-  Instance<RootModelWithInternetAccountsType>

package/src/RootModel/index.ts

@@ -1,2 +0,0 @@
-export * from './BaseRootModel'
-export * from './InternetAccounts'

package/src/Session/BaseSession.ts

@@ -1,129 +0,0 @@
-import shortid from 'shortid'
-import PluginManager from '@jbrowse/core/PluginManager'
-import {
-  IAnyStateTreeNode,
-  Instance,
-  getParent,
-  isStateTreeNode,
-  types,
-} from 'mobx-state-tree'
-import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration'
-import { BaseAssemblyConfigSchema } from '@jbrowse/core/assemblyManager'
-
-// locals
-import type { BaseRootModelType } from '../RootModel/BaseRootModel'
-
-/**
- * #stateModel BaseSessionModel
- * base session shared by **all** JBrowse products. Be careful what you include
- * here, everything will use it.
- */
-export function BaseSessionModel<
-  ROOT_MODEL_TYPE extends BaseRootModelType,
-  JB_CONFIG_SCHEMA extends AnyConfigurationSchemaType,
->(pluginManager: PluginManager) {
-  return types
-    .model({
-      /**
-       * #property
-       */
-      id: types.optional(types.identifier, shortid()),
-      /**
-       * #property
-       */
-      name: types.string,
-      /**
-       * #property
-       */
-      margin: 0,
-    })
-    .volatile(() => ({
-      /**
-       * #volatile
-       * this is the globally "selected" object. can be anything. code that
-       * wants to deal with this should examine it to see what kind of thing it
-       * is.
-       */
-      selection: undefined as unknown,
-    }))
-    .views(self => ({
-      get root() {
-        return getParent<ROOT_MODEL_TYPE>(self)
-      },
-    }))
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get jbrowse() {
-        return self.root.jbrowse
-      },
-      /**
-       * #getter
-       */
-      get rpcManager() {
-        return self.root.rpcManager
-      },
-      /**
-       * #getter
-       */
-      get configuration(): Instance<JB_CONFIG_SCHEMA> {
-        return this.jbrowse.configuration
-      },
-      /**
-       * #getter
-       */
-      get adminMode() {
-        return self.root.adminMode
-      },
-
-      /**
-       * #getter
-       */
-      get textSearchManager() {
-        return self.root.textSearchManager
-      },
-    }))
-    .views(self => ({
-      /**
-       * #getter
-       */
-      get assemblies(): Instance<BaseAssemblyConfigSchema>[] {
-        return self.jbrowse.assemblies
-      },
-    }))
-    .actions(self => ({
-      /**
-       * #action
-       * set the global selection, i.e. the globally-selected object. can be a
-       * feature, a view, just about anything
-       */
-      setSelection(thing: unknown) {
-        self.selection = thing
-      },
-
-      /**
-       * #action
-       * clears the global selection
-       */
-      clearSelection() {
-        self.selection = undefined
-      },
-    }))
-}
-
-/** Session mixin MST type for the most basic session */
-export type BaseSessionType = ReturnType<typeof BaseSessionModel>
-
-/** Instance of the most basic possible session */
-export type BaseSession = Instance<BaseSessionType>
-
-/** Type guard for BaseSession */
-export function isBaseSession(thing: IAnyStateTreeNode): thing is BaseSession {
-  return 'id' in thing && 'name' in thing && 'root' in thing
-}
-
-/** Type guard for whether a thing is JBrowse session */
-export function isSession(thing: unknown): thing is BaseSession {
-  return isStateTreeNode(thing) && isBaseSession(thing)
-}

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