@jbrowse/plugin-linear-genome-view 2.5.0 → 2.6.2

package/src/BaseLinearDisplay/models/configSchema.ts

@@ -1,59 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config BaseLinearDisplay
- * `BaseLinearDisplay` is a "base" config that is extended by classes like
- * `LinearBasicDisplay` (used for feature tracks, etc) and `LinearBareDisplay`
- * (more stripped down than even the basic display, not commonly used)
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const baseLinearDisplayConfigSchema = ConfigurationSchema(
-  'BaseLinearDisplay',
-  {
-    /**
-     * #slot
-     */
-    maxFeatureScreenDensity: {
-      type: 'number',
-      description:
-        'maximum features per pixel that is displayed in the view, used if byte size estimates not available',
-      defaultValue: 0.3,
-    },
-    /**
-     * #slot
-     */
-    fetchSizeLimit: {
-      type: 'number',
-      defaultValue: 1_000_000,
-      description:
-        "maximum data to attempt to download for a given track, used if adapter doesn't specify one",
-    },
-    /**
-     * #slot
-     */
-    height: {
-      type: 'number',
-      defaultValue: 100,
-      description: 'default height for the track',
-    },
-    /**
-     * #slot
-     */
-    mouseover: {
-      type: 'string',
-      description: 'text to display when the cursor hovers over a feature',
-      defaultValue: `jexl:get(feature,'name')`,
-
-      contextVariable: ['feature'],
-    },
-  },
-  {
-    /**
-     * #identifier
-     */
-    explicitIdentifier: 'displayId',
-  },
-)
-
-export default baseLinearDisplayConfigSchema

package/src/BaseLinearDisplay/models/serverSideRenderedBlock.ts

@@ -1,318 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import React from 'react'
-import {
-  types,
-  getParent,
-  isAlive,
-  cast,
-  Instance,
-  getSnapshot,
-} from 'mobx-state-tree'
-import { readConfObject } from '@jbrowse/core/configuration'
-import {
-  assembleLocString,
-  getSession,
-  getContainingDisplay,
-  getContainingView,
-  getViewParams,
-  makeAbortableReaction,
-  Feature,
-} from '@jbrowse/core/util'
-import { Region } from '@jbrowse/core/util/types/mst'
-import {
-  AbstractDisplayModel,
-  isRetryException,
-} from '@jbrowse/core/util/types'
-
-import {
-  getTrackAssemblyNames,
-  getRpcSessionId,
-} from '@jbrowse/core/util/tracks'
-
-// locals
-import ServerSideRenderedBlockContent from '../components/ServerSideRenderedBlockContent'
-
-// the MST state of a single server-side-rendered block in a display
-const blockState = types
-  .model('BlockState', {
-    key: types.string,
-    region: Region,
-    reloadFlag: 0,
-    isLeftEndOfDisplayedRegion: false,
-    isRightEndOfDisplayedRegion: false,
-  })
-  // NOTE: all this volatile stuff has to be filled in at once, so that it stays consistent
-  .volatile(() => ({
-    renderInProgress: undefined as AbortController | undefined,
-    filled: false,
-    reactElement: undefined as React.ReactElement | undefined,
-    features: undefined as Map<string, Feature> | undefined,
-    layout: undefined as any,
-    status: '',
-    error: undefined as unknown,
-    message: undefined as string | undefined,
-    maxHeightReached: false,
-    ReactComponent: ServerSideRenderedBlockContent,
-    renderProps: undefined as any,
-  }))
-  .actions(self => {
-    let renderInProgress: undefined | AbortController
-    return {
-      doReload() {
-        self.reloadFlag = self.reloadFlag + 1
-      },
-      afterAttach() {
-        const display = getContainingDisplay(self)
-        setTimeout(() => {
-          if (isAlive(self)) {
-            makeAbortableReaction(
-              self as any,
-              renderBlockData,
-              renderBlockEffect, // reaction doesn't expect async here
-              {
-                name: `${display.id}/${assembleLocString(
-                  self.region,
-                )} rendering`,
-                delay: display.renderDelay,
-                fireImmediately: true,
-              },
-              this.setLoading,
-              this.setRendered,
-              this.setError,
-            )
-          }
-        }, display.renderDelay)
-      },
-      setStatus(message: string) {
-        self.status = message
-      },
-      setLoading(abortController: AbortController) {
-        if (
-          renderInProgress !== undefined &&
-          !renderInProgress.signal.aborted
-        ) {
-          renderInProgress.abort()
-        }
-        self.filled = false
-        self.message = undefined
-        self.reactElement = undefined
-        self.features = undefined
-        self.layout = undefined
-        self.error = undefined
-        self.maxHeightReached = false
-        self.renderProps = undefined
-        renderInProgress = abortController
-      },
-      setMessage(messageText: string) {
-        if (renderInProgress && !renderInProgress.signal.aborted) {
-          renderInProgress.abort()
-        }
-        self.filled = false
-        self.message = messageText
-        self.reactElement = undefined
-        self.features = undefined
-        self.layout = undefined
-        self.error = undefined
-        self.maxHeightReached = false
-        self.renderProps = undefined
-        renderInProgress = undefined
-      },
-      setRendered(
-        props:
-          | {
-              reactElement: React.ReactElement
-              features: Map<string, Feature>
-              layout: any
-              maxHeightReached: boolean
-              renderProps: any
-            }
-          | undefined,
-      ) {
-        if (!props) {
-          return
-        }
-        const {
-          reactElement,
-          features,
-          layout,
-          maxHeightReached,
-          renderProps,
-        } = props
-        self.filled = true
-        self.message = undefined
-        self.reactElement = reactElement
-        self.features = features
-        self.layout = layout
-        self.error = undefined
-        self.maxHeightReached = maxHeightReached
-        self.renderProps = renderProps
-        renderInProgress = undefined
-      },
-      setError(error: unknown) {
-        console.error(error)
-        if (renderInProgress && !renderInProgress.signal.aborted) {
-          renderInProgress.abort()
-        }
-        // the rendering failed for some reason
-        self.filled = false
-        self.message = undefined
-        self.reactElement = undefined
-        self.features = undefined
-        self.layout = undefined
-        self.maxHeightReached = false
-        self.error = error
-        self.renderProps = undefined
-        renderInProgress = undefined
-        if (isRetryException(error as Error)) {
-          this.reload()
-        }
-      },
-      reload() {
-        self.renderInProgress = undefined
-        self.filled = false
-        self.reactElement = undefined
-        self.features = undefined
-        self.layout = undefined
-        self.error = undefined
-        self.message = undefined
-        self.maxHeightReached = false
-        self.ReactComponent = ServerSideRenderedBlockContent
-        self.renderProps = undefined
-        getParent<any>(self, 2).reload()
-      },
-      beforeDestroy() {
-        if (renderInProgress && !renderInProgress.signal.aborted) {
-          renderInProgress.abort()
-        }
-        const display = getContainingDisplay(self)
-        const { rpcManager } = getSession(self)
-        const { rendererType } = display
-        const { renderArgs } = renderBlockData(cast(self))
-        // renderArgs can be undefined if an error occurred in this block
-        if (renderArgs) {
-          rendererType
-            .freeResourcesInClient(
-              rpcManager,
-              JSON.parse(JSON.stringify(renderArgs)),
-            )
-            .catch((e: Error) => {
-              // just console.error if it's something while it's being destroyed
-              console.warn('Error while destroying block', e)
-            })
-        }
-      },
-    }
-  })
-
-export default blockState
-export type BlockStateModel = typeof blockState
-export type BlockModel = Instance<BlockStateModel>
-
-// calls the render worker to render the block content not using a flow for
-// this, because the flow doesn't work with autorun
-export function renderBlockData(
-  self: BlockModel,
-  optDisplay?: AbstractDisplayModel,
-) {
-  try {
-    const display = optDisplay || (getContainingDisplay(self) as any)
-    const { assemblyManager, rpcManager } = getSession(display)
-    const { adapterConfig, rendererType, error, parentTrack } = display
-    const assemblyNames = getTrackAssemblyNames(parentTrack)
-    const regionAsm = self.region.assemblyName
-    if (
-      !assemblyNames.includes(regionAsm) &&
-      !assemblyNames.some(name => assemblyManager.get(name)?.hasName(regionAsm))
-    ) {
-      throw new Error(
-        `region assembly (${regionAsm}) does not match track assemblies (${assemblyNames})`,
-      )
-    }
-
-    const renderProps = display.renderProps()
-    const { config } = renderProps
-
-    // This line is to trigger the mobx reaction when the config changes
-    // It won't trigger the reaction if it doesn't think we're accessing it
-    readConfObject(config)
-
-    const sessionId = getRpcSessionId(display)
-    const layoutId = getContainingView(display).id
-    const cannotBeRenderedReason = display.regionCannotBeRendered(self.region)
-
-    return {
-      rendererType,
-      rpcManager,
-      renderProps,
-      cannotBeRenderedReason,
-      displayError: error,
-      renderArgs: {
-        statusCallback: (message: string) => {
-          if (isAlive(self)) {
-            self.setStatus(message)
-          }
-        },
-        assemblyName: self.region.assemblyName,
-        regions: [getSnapshot(self.region)],
-        adapterConfig,
-        rendererType: rendererType.name,
-        sessionId,
-        layoutId,
-        blockKey: self.key,
-        reloadFlag: self.reloadFlag,
-        timeout: 1000000, // 10000,
-      },
-    }
-  } catch (e) {
-    return { displayError: e }
-  }
-}
-
-async function renderBlockEffect(
-  props: ReturnType<typeof renderBlockData> | undefined,
-  signal: AbortSignal,
-  self: BlockModel,
-) {
-  if (!props) {
-    return
-  }
-  const {
-    rendererType,
-    renderProps,
-    rpcManager,
-    renderArgs,
-    cannotBeRenderedReason,
-    displayError,
-  } = props
-  if (!isAlive(self)) {
-    return undefined
-  }
-
-  if (displayError) {
-    self.setError(displayError)
-    return undefined
-  }
-  if (cannotBeRenderedReason) {
-    self.setMessage(cannotBeRenderedReason)
-    return undefined
-  }
-
-  if (renderProps.notReady) {
-    return undefined
-  }
-
-  const { reactElement, features, layout, maxHeightReached } =
-    await rendererType.renderInClient(rpcManager, {
-      ...renderArgs,
-      ...renderProps,
-      viewParams: getViewParams(self),
-      signal,
-    })
-  return {
-    reactElement,
-    features,
-    layout,
-    maxHeightReached,
-    renderProps,
-  }
-}

package/src/BaseLinearDisplay/models/util.ts

@@ -1,67 +0,0 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration'
-import { FeatureDensityStats } from '@jbrowse/core/data_adapters/BaseAdapter'
-import { getContainingView, getSession } from '@jbrowse/core/util'
-import { getRpcSessionId } from '@jbrowse/core/util/tracks'
-import { IAnyStateTreeNode, isAlive } from 'mobx-state-tree'
-import { LinearGenomeViewModel } from '../../LinearGenomeView'
-
-export interface RenderProps {
-  rendererType: any // eslint-disable-line @typescript-eslint/no-explicit-any
-  renderArgs: { [key: string]: any } // eslint-disable-line @typescript-eslint/no-explicit-any
-  renderProps: { [key: string]: any } // eslint-disable-line @typescript-eslint/no-explicit-any
-  displayError: unknown
-  rpcManager: { call: Function }
-  cannotBeRenderedReason: string
-}
-
-export interface ErrorProps {
-  displayError: string
-}
-
-export function getDisplayStr(totalBytes: number) {
-  let displayBp
-  if (Math.floor(totalBytes / 1000000) > 0) {
-    displayBp = `${Number.parseFloat((totalBytes / 1000000).toPrecision(3))} Mb`
-  } else if (Math.floor(totalBytes / 1000) > 0) {
-    displayBp = `${Number.parseFloat((totalBytes / 1000).toPrecision(3))} Kb`
-  } else {
-    displayBp = `${Math.floor(totalBytes)} bytes`
-  }
-  return displayBp
-}
-
-// stabilize clipid under test for snapshot
-export function getId(id: string, index: number) {
-  const isJest = typeof jest === 'undefined'
-  return `clip-${isJest ? id : 'jest'}-${index}`
-}
-
-export async function getFeatureDensityStatsPre(
-  self: IAnyStateTreeNode & {
-    adapterConfig?: AnyConfigurationModel
-    setMessage: (arg: string) => void
-  },
-) {
-  const view = getContainingView(self) as LinearGenomeViewModel
-  const regions = view.staticBlocks.contentBlocks
-
-  const { rpcManager } = getSession(self)
-  const { adapterConfig } = self
-  if (!adapterConfig) {
-    // A track extending the base track might not have an adapter config
-    // e.g. Apollo tracks don't use adapters
-    return {}
-  }
-  const sessionId = getRpcSessionId(self)
-
-  return rpcManager.call(sessionId, 'CoreGetFeatureDensityStats', {
-    sessionId,
-    regions,
-    adapterConfig,
-    statusCallback: (message: string) => {
-      if (isAlive(self)) {
-        self.setMessage(message)
-      }
-    },
-  }) as Promise<FeatureDensityStats>
-}

package/src/BasicTrack/configSchema.ts

@@ -1,23 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-
-/**
- * #config BasicTrack
- * synonym for FeatureTrack
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const configSchema = (pluginManager: PluginManager) =>
-  ConfigurationSchema(
-    'BasicTrack',
-    {},
-    {
-      /**
-       * #baseConfiguration
-       */
-      baseConfiguration: createBaseTrackConfig(pluginManager),
-      explicitIdentifier: 'trackId',
-    },
-  )
-export default configSchema

package/src/BasicTrack/index.ts

@@ -1,18 +0,0 @@
-import {
-  createBaseTrackModel,
-  TrackType,
-} from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-import configSchemaF from './configSchema'
-
-export default (pm: PluginManager) => {
-  pm.addTrackType(() => {
-    const configSchema = configSchemaF(pm)
-
-    return new TrackType({
-      name: 'BasicTrack',
-      configSchema,
-      stateModel: createBaseTrackModel(pm, 'BasicTrack', configSchema),
-    })
-  })
-}

package/src/FeatureTrack/configSchema.ts

@@ -1,27 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-
-/**
- * #config FeatureTrack
- * used for basic gene and feature tracks, generally used with LinearBasicDisplay
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const configSchema = (pluginManager: PluginManager) =>
-  ConfigurationSchema(
-    'FeatureTrack',
-    {},
-    {
-      /**
-       * #baseConfiguration
-       */
-      baseConfiguration: createBaseTrackConfig(pluginManager),
-      /**
-       * #identifier
-       */
-      explicitIdentifier: 'trackId',
-    },
-  )
-
-export default configSchema

package/src/FeatureTrack/index.ts

@@ -1,18 +0,0 @@
-import {
-  createBaseTrackModel,
-  TrackType,
-} from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-import configSchemaF from './configSchema'
-
-export default (pm: PluginManager) => {
-  pm.addTrackType(() => {
-    const configSchema = configSchemaF(pm)
-    return new TrackType({
-      name: 'FeatureTrack',
-      displayName: 'Feature track',
-      configSchema,
-      stateModel: createBaseTrackModel(pm, 'FeatureTrack', configSchema),
-    })
-  })
-}

package/src/LaunchLinearGenomeView/index.ts

@@ -1,66 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { AbstractSessionModel, when } from '@jbrowse/core/util'
-import { LinearGenomeViewModel } from '../LinearGenomeView'
-
-type LGV = LinearGenomeViewModel
-
-export default (pluginManager: PluginManager) => {
-  pluginManager.addToExtensionPoint(
-    'LaunchView-LinearGenomeView',
-    // @ts-expect-error
-    async ({
-      session,
-      assembly,
-      loc,
-      tracks = [],
-    }: {
-      session: AbstractSessionModel
-      assembly?: string
-      loc: string
-      tracks?: string[]
-    }) => {
-      try {
-        const { assemblyManager } = session
-        const view = session.addView('LinearGenomeView', {}) as LGV
-
-        await when(() => !!view.volatileWidth)
-
-        if (!assembly) {
-          throw new Error(
-            'No assembly provided when launching linear genome view',
-          )
-        }
-
-        const asm = await assemblyManager.waitForAssembly(assembly)
-        if (!asm) {
-          throw new Error(
-            `Assembly "${assembly}" not found when launching linear genome view`,
-          )
-        }
-
-        await view.navToLocString(loc, assembly)
-
-        const idsNotFound = [] as string[]
-        tracks.forEach(track => {
-          try {
-            view.showTrack(track)
-          } catch (e) {
-            if (`${e}`.match('Could not resolve identifier')) {
-              idsNotFound.push(track)
-            } else {
-              throw e
-            }
-          }
-        })
-        if (idsNotFound.length) {
-          throw new Error(
-            `Could not resolve identifiers: ${idsNotFound.join(',')}`,
-          )
-        }
-      } catch (e) {
-        session.notify(`${e}`, 'error')
-        throw e
-      }
-    },
-  )
-}

package/src/LinearBareDisplay/configSchema.ts

@@ -1,27 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { baseLinearDisplayConfigSchema } from '../BaseLinearDisplay'
-
-/**
- * #config LinearBareDisplay
- */
-function configSchemaFactory(pluginManager: PluginManager) {
-  return ConfigurationSchema(
-    'LinearBareDisplay',
-    {
-      /**
-       * #slot
-       */
-      renderer: pluginManager.pluggableConfigSchemaType('renderer'),
-    },
-    {
-      /**
-       * #baseConfiguration
-       */
-      baseConfiguration: baseLinearDisplayConfigSchema,
-      explicitlyTyped: true,
-    },
-  )
-}
-
-export { configSchemaFactory }

package/src/LinearBareDisplay/index.test.js

@@ -1,34 +0,0 @@
-import { types } from 'mobx-state-tree'
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { configSchemaFactory } from '.'
-
-test('config schema renderer type', () => {
-  const stubPluginManager = {
-    pluggableConfigSchemaType(type) {
-      const one = ConfigurationSchema(
-        `${type}_TypeOne`,
-        {},
-        { explicitlyTyped: true },
-      )
-      const two = ConfigurationSchema(
-        `${type}_TypeTwo`,
-        {},
-        { explicitlyTyped: true },
-      )
-      const three = ConfigurationSchema(
-        `${type}_TypeThree`,
-        {},
-        { explicitlyTyped: true },
-      )
-      return types.union(one, two, three)
-    },
-  }
-
-  const configSchema = configSchemaFactory(stubPluginManager)
-  const instance = configSchema.create({
-    type: 'LinearBareDisplay',
-    displayId: 'displayId0',
-    renderer: { type: 'renderer_TypeTwo' },
-  })
-  expect(instance.renderer.type).toBe('renderer_TypeTwo')
-})

package/src/LinearBareDisplay/index.ts

@@ -1,25 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import { DisplayType } from '@jbrowse/core/pluggableElementTypes'
-
-// locals
-import { configSchemaFactory } from './configSchema'
-import { stateModelFactory } from './model'
-import { BaseLinearDisplayComponent } from '../BaseLinearDisplay/'
-
-export default (pluginManager: PluginManager) => {
-  pluginManager.addDisplayType(() => {
-    const configSchema = configSchemaFactory(pluginManager)
-    return new DisplayType({
-      name: 'LinearBareDisplay',
-      configSchema,
-      displayName: 'Bare feature display',
-      stateModel: stateModelFactory(configSchema),
-      trackType: 'BasicTrack',
-      viewType: 'LinearGenomeView',
-      ReactComponent: BaseLinearDisplayComponent,
-    })
-  })
-}
-
-export { configSchemaFactory } from './configSchema'
-export { stateModelFactory } from './model'