@jbrowse/app-core 2.6.1

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@jbrowse/app-core",
+  "version": "2.6.1",
+  "description": "JBrowse 2 code shared between the 'full featured' apps e.g. jbrowse-web and jbrowse-desktop",
+  "keywords": [
+    "jbrowse",
+    "jbrowse2",
+    "bionode",
+    "biojs",
+    "genomics"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://jbrowse.org",
+  "bugs": "https://github.com/GMOD/jbrowse-components/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GMOD/jbrowse-components.git",
+    "directory": "packages/app-core"
+  },
+  "author": "JBrowse Team",
+  "distMain": "dist/index.js",
+  "distModule": "esm/index.js",
+  "srcMain": "src/index.ts",
+  "srcModule": "src/index.ts",
+  "main": "dist/index.js",
+  "module": "esm/index.js",
+  "files": [
+    "dist",
+    "esm",
+    "src"
+  ],
+  "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",
+    "test": "cd ../..; jest packages/app-core",
+    "clean": "rimraf dist esm *.tsbuildinfo",
+    "prebuild": "yarn clean",
+    "prepack": "yarn build && yarn useDist",
+    "postpack": "yarn useSrc",
+    "useDist": "node ../../scripts/useDist.js",
+    "useSrc": "node ../../scripts/useSrc.js"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.16.3",
+    "@jbrowse/product-core": "^2.6.1",
+    "@mui/icons-material": "^5.0.0",
+    "@mui/material": "^5.10.17",
+    "copy-to-clipboard": "^3.3.1",
+    "react-error-boundary": "^4.0.3",
+    "shortid": "^2.2.15"
+  },
+  "peerDependencies": {
+    "mobx": "^6.0.0",
+    "mobx-react": "^7.0.0",
+    "mobx-state-tree": "^5.0.0",
+    "react": "^17.0.0",
+    "react-dom": "^17.0.0",
+    "rxjs": "^7.0.0",
+    "tss-react": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "1cbe7ba097fb2d2763c776e5e429e4670cdd583c"
+}

package/src/Assemblies/SessionAssembliesMixin.ts

@@ -0,0 +1,50 @@
+import { types } from 'mobx-state-tree'
+
+import PluginManager from '@jbrowse/core/PluginManager'
+import { AnyConfiguration } from '@jbrowse/core/configuration'
+import { BaseSession } from '@jbrowse/product-core'
+import { BaseAssemblyConfigSchema } from '@jbrowse/core/assemblyManager'
+
+/**
+ * #stateModel SessionAssembliesMixin
+ * #category root
+ */
+export function SessionAssembliesMixin(
+  pluginManager: PluginManager,
+  assemblyConfigSchemasType: BaseAssemblyConfigSchema,
+) {
+  return types
+    .model({
+      /**
+       * #property
+       */
+      sessionAssemblies: types.array(assemblyConfigSchemasType),
+    })
+    .actions(s => {
+      const self = s as typeof s & BaseSession
+      return {
+        /**
+         * #action
+         */
+        addSessionAssembly(conf: AnyConfiguration) {
+          const asm = self.sessionAssemblies.find(f => f.name === conf.name)
+          if (asm) {
+            console.warn(`Assembly ${conf.name} already exists`)
+            return asm
+          }
+          const length = self.sessionAssemblies.push(conf)
+          return self.sessionAssemblies[length - 1]
+        },
+
+        /**
+         * #action
+         */
+        removeSessionAssembly(assemblyName: string) {
+          const elt = self.sessionAssemblies.find(a => a.name === assemblyName)
+          if (elt) {
+            self.sessionAssemblies.remove(elt)
+          }
+        },
+      }
+    })
+}

package/src/Assemblies/TemporaryAssembliesMixin.ts

@@ -0,0 +1,51 @@
+import { types } from 'mobx-state-tree'
+
+import PluginManager from '@jbrowse/core/PluginManager'
+import { AnyConfiguration } from '@jbrowse/core/configuration'
+import { BaseSession } from '@jbrowse/product-core'
+
+/**
+ * #stateModel TemporaryAssembliesMixin
+ * #category root
+ */
+export function TemporaryAssembliesMixin(
+  pluginManager: PluginManager,
+  assemblyConfigSchemasType = types.frozen(),
+) {
+  return types
+    .model({
+      /**
+       * #property
+       */
+      temporaryAssemblies: types.array(assemblyConfigSchemasType),
+    })
+
+    .actions(s => {
+      const self = s as typeof s & BaseSession
+      return {
+        /**
+         * #action
+         * used for read vs ref type assemblies.
+         */
+        addTemporaryAssembly(conf: AnyConfiguration) {
+          const asm = self.temporaryAssemblies.find(f => f.name === conf.name)
+          if (asm) {
+            console.warn(`Assembly ${conf.name} was already existing`)
+            return asm
+          }
+          const length = self.temporaryAssemblies.push(conf)
+          return self.temporaryAssemblies[length - 1]
+        },
+
+        /**
+         * #action
+         */
+        removeTemporaryAssembly(name: string) {
+          const elt = self.temporaryAssemblies.find(a => a.name === name)
+          if (elt) {
+            self.temporaryAssemblies.remove(elt)
+          }
+        },
+      }
+    })
+}

package/src/Assemblies/index.ts

@@ -0,0 +1,2 @@
+export * from './SessionAssembliesMixin'
+export * from './TemporaryAssembliesMixin'

package/src/HistoryManagement/index.ts

@@ -0,0 +1,56 @@
+import TimeTraveller from '@jbrowse/core/util/TimeTraveller'
+import type { BaseRootModel } from '@jbrowse/product-core'
+import { autorun } from 'mobx'
+import { addDisposer, types } from 'mobx-state-tree'
+
+/**
+ * #stateModel HistoryManagementMixin
+ * #category root
+ */
+export function HistoryManagementMixin() {
+  return types
+    .model({
+      /**
+       * #property
+       * used for undo/redo
+       */
+      history: types.optional(TimeTraveller, { targetPath: '../session' }),
+    })
+    .actions(self => ({
+      afterCreate() {
+        document.addEventListener('keydown', e => {
+          if (
+            self.history.canRedo &&
+            // ctrl+shift+z or cmd+shift+z
+            (((e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'KeyZ') ||
+              // ctrl+y
+              (e.ctrlKey && !e.shiftKey && e.code === 'KeyY'))
+          ) {
+            self.history.redo()
+          }
+          if (
+            self.history.canUndo &&
+            // ctrl+z or cmd+z
+            (e.ctrlKey || e.metaKey) &&
+            !e.shiftKey &&
+            e.code === 'KeyZ'
+          ) {
+            self.history.undo()
+          }
+        })
+        addDisposer(
+          self,
+          autorun(() => {
+            const { session } = self as typeof self & BaseRootModel
+            if (session) {
+              // we use a specific initialization routine after session is
+              // created to get it to start tracking itself sort of related
+              // issue here
+              // https://github.com/mobxjs/mobx-state-tree/issues/1089#issuecomment-441207911
+              self.history.initialize()
+            }
+          }),
+        )
+      },
+    }))
+}

package/src/JBrowseConfig/index.ts

@@ -0,0 +1,173 @@
+import {
+  AnyConfigurationSchemaType,
+  ConfigurationSchema,
+} from '@jbrowse/core/configuration'
+
+import { PluginDefinition } from '@jbrowse/core/PluginLoader'
+import PluginManager from '@jbrowse/core/PluginManager'
+import RpcManager from '@jbrowse/core/rpc/RpcManager'
+import { types } from 'mobx-state-tree'
+
+/**
+ * #config JBrowseRootConfig
+ * #category root
+ * configuration in a config.json/file.jbrowse
+ */
+export function JBrowseConfigF({
+  pluginManager,
+  assemblyConfigSchema,
+}: {
+  pluginManager: PluginManager
+  assemblyConfigSchema: AnyConfigurationSchemaType
+}) {
+  return types.model('JBrowseConfig', {
+    configuration: ConfigurationSchema('Root', {
+      /**
+       * #slot configuration.rpc
+       */
+      rpc: RpcManager.configSchema,
+
+      /**
+       * #slot configuration.highResolutionScaling
+       */
+      highResolutionScaling: {
+        type: 'number',
+        defaultValue: 2,
+      },
+
+      formatDetails: ConfigurationSchema('FormatDetails', {
+        /**
+         * #slot configuration.formatDetails.feature
+         */
+        feature: {
+          type: 'frozen',
+          description: 'adds extra fields to the feature details',
+          defaultValue: {},
+          contextVariable: ['feature'],
+        },
+        /**
+         * #slot configuration.formatDetails.subfeatures
+         */
+        subfeatures: {
+          type: 'frozen',
+          description: 'adds extra fields to the subfeatures of a feature',
+          defaultValue: {},
+          contextVariable: ['feature'],
+        },
+        /**
+         * #slot configuration.formatDetails.depth
+         */
+        depth: {
+          type: 'number',
+          defaultValue: 2,
+          description: 'depth to iterate on subfeatures',
+        },
+      }),
+      formatAbout: ConfigurationSchema('FormatAbout', {
+        /**
+         * #slot configuration.formatAbout.config
+         */
+        config: {
+          type: 'frozen',
+          description: 'formats configuration object in about dialog',
+          defaultValue: {},
+          contextVariable: ['config'],
+        },
+        /**
+         * #slot configuration.formatAbout.hideUris
+         */
+
+        hideUris: {
+          type: 'boolean',
+          defaultValue: false,
+        },
+      }),
+
+      /*
+       * #slot configuration.shareURL
+       */
+      shareURL: {
+        type: 'string',
+        defaultValue: 'https://share.jbrowse.org/api/v1/',
+      },
+      /**
+       * #slot configuration.disableAnalytics
+       */
+      disableAnalytics: {
+        type: 'boolean',
+        defaultValue: false,
+      },
+      /**
+       * #slot configuration.theme
+       */
+      theme: {
+        type: 'frozen',
+        defaultValue: {},
+      },
+      /**
+       * #slot configuration.extraThemes
+       */
+      extraThemes: { type: 'frozen', defaultValue: {} },
+      /**
+       * #slot configuration.logoPath
+       */
+      logoPath: {
+        type: 'fileLocation',
+        defaultValue: { uri: '', locationType: 'UriLocation' },
+      },
+      ...pluginManager.pluginConfigurationSchemas(),
+    }),
+    /**
+     * #slot
+     * defines plugins of the format
+     * ```typescript
+     * type PluginDefinition=
+     *    { umdUrl: string, name:string } |
+     *    { url: string, name: string } |
+     *    { esmUrl: string } |
+     *    { cjsUrl: string } |
+     *    { umdLoc: { uri: string } } |
+     *    { esmLoc: { uri: string } } |
+     * ```
+     */
+    plugins: types.array(types.frozen<PluginDefinition>()),
+    /**
+     * #slot
+     * configuration of the assemblies in the instance, see BaseAssembly
+     */
+    assemblies: types.array(assemblyConfigSchema),
+    /**
+     * #slot
+     * track configuration is an array of track config schemas. multiple
+     * instances of a track can exist that use the same configuration
+     */
+    tracks: types.array(pluginManager.pluggableConfigSchemaType('track')),
+    /**
+     * #slot
+     * configuration for internet accounts, see InternetAccounts
+     */
+    internetAccounts: types.array(
+      pluginManager.pluggableConfigSchemaType('internet account'),
+    ),
+    /**
+     * #slot
+     */
+    aggregateTextSearchAdapters: types.array(
+      pluginManager.pluggableConfigSchemaType('text search adapter'),
+    ),
+
+    /**
+     * #slot
+     */
+    connections: types.array(
+      pluginManager.pluggableConfigSchemaType('connection'),
+    ),
+
+    /**
+     * #slot
+     */
+    defaultSession: types.optional(types.frozen(), {
+      name: `New Session`,
+    }),
+  })
+}

package/src/JBrowseModel/index.ts

@@ -0,0 +1,150 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import { BaseAssemblyConfigSchema } from '@jbrowse/core/assemblyManager'
+import { cast, getParent } from 'mobx-state-tree'
+import RpcManager from '@jbrowse/core/rpc/RpcManager'
+import {
+  AnyConfigurationModel,
+  readConfObject,
+} from '@jbrowse/core/configuration'
+import { PluginDefinition } from '@jbrowse/core/PluginLoader'
+
+// locals
+import { JBrowseConfigF } from '../JBrowseConfig'
+
+export function JBrowseModelF({
+  pluginManager,
+  assemblyConfigSchema,
+}: {
+  pluginManager: PluginManager
+  assemblyConfigSchema: BaseAssemblyConfigSchema
+}) {
+  return JBrowseConfigF({ pluginManager, assemblyConfigSchema })
+    .views(self => ({
+      /**
+       * #getter
+       */
+      get assemblyNames(): string[] {
+        return self.assemblies.map(assembly => readConfObject(assembly, 'name'))
+      },
+      /**
+       * #getter
+       */
+      get rpcManager(): RpcManager {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return getParent<any>(self).rpcManager
+      },
+    }))
+    .actions(self => ({
+      /**
+       * #action
+       */
+      addAssemblyConf(conf: AnyConfigurationModel) {
+        const { name } = conf
+        if (!name) {
+          throw new Error('Can\'t add assembly with no "name"')
+        }
+        if (self.assemblyNames.includes(name)) {
+          throw new Error(
+            `Can't add assembly with name "${name}", an assembly with that name already exists`,
+          )
+        }
+        const length = self.assemblies.push({
+          ...conf,
+          sequence: {
+            type: 'ReferenceSequenceTrack',
+            trackId: `${name}-${Date.now()}`,
+            ...conf.sequence,
+          },
+        })
+        return self.assemblies[length - 1]
+      },
+      /**
+       * #action
+       */
+      removeAssemblyConf(assemblyName: string) {
+        const toRemove = self.assemblies.find(a => a.name === assemblyName)
+        if (toRemove) {
+          self.assemblies.remove(toRemove)
+        }
+      },
+      /**
+       * #action
+       */
+      addTrackConf(trackConf: AnyConfigurationModel) {
+        const { type } = trackConf
+        if (!type) {
+          throw new Error(`unknown track type ${type}`)
+        }
+        const length = self.tracks.push(trackConf)
+        return self.tracks[length - 1]
+      },
+      /**
+       * #action
+       */
+      addConnectionConf(connectionConf: AnyConfigurationModel) {
+        const { type } = connectionConf
+        if (!type) {
+          throw new Error(`unknown connection type ${type}`)
+        }
+        const length = self.connections.push(connectionConf)
+        return self.connections[length - 1]
+      },
+      /**
+       * #action
+       */
+      deleteConnectionConf(configuration: AnyConfigurationModel) {
+        const elt = self.connections.find(conn => conn.id === configuration.id)
+        return self.connections.remove(elt)
+      },
+      /**
+       * #action
+       */
+      deleteTrackConf(trackConf: AnyConfigurationModel) {
+        const elt = self.tracks.find(t => t.trackId === trackConf.trackId)
+        return self.tracks.remove(elt)
+      },
+      /**
+       * #action
+       */
+      addPlugin(pluginDefinition: PluginDefinition) {
+        self.plugins.push(pluginDefinition)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rootModel = getParent<any>(self)
+        rootModel.setPluginsUpdated(true)
+      },
+      /**
+       * #action
+       */
+      removePlugin(pluginDefinition: PluginDefinition) {
+        self.plugins = cast(
+          self.plugins.filter(
+            plugin =>
+              plugin.url !== pluginDefinition.url ||
+              plugin.umdUrl !== pluginDefinition.umdUrl ||
+              plugin.cjsUrl !== pluginDefinition.cjsUrl ||
+              plugin.esmUrl !== pluginDefinition.esmUrl,
+          ),
+        )
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getParent<any>(self).setPluginsUpdated(true)
+      },
+      /**
+       * #action
+       */
+      addInternetAccountConf(internetAccountConf: AnyConfigurationModel) {
+        const { type } = internetAccountConf
+        if (!type) {
+          throw new Error(`unknown internetAccount type ${type}`)
+        }
+        const length = self.internetAccounts.push(internetAccountConf)
+        return self.internetAccounts[length - 1]
+      },
+      /**
+       * #action
+       */
+      deleteInternetAccountConf(configuration: AnyConfigurationModel) {
+        const elt = self.internetAccounts.find(a => a.id === configuration.id)
+        return self.internetAccounts.remove(elt)
+      },
+    }))
+}