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

package/src/BaseLinearDisplay/models/autorunFeatureDensityStats.ts

@@ -1,46 +0,0 @@
-import { getContainingView, isAbortException } from '@jbrowse/core/util'
-import { LinearGenomeViewModel } from '../../LinearGenomeView'
-import { isAlive } from 'mobx-state-tree'
-import { BaseLinearDisplayModel } from './BaseLinearDisplayModel'
-
-// stats estimation autorun calls getFeatureDensityStats against the data
-// adapter which by default uses featureDensity, but can also respond with a
-// byte size estimate and fetch size limit (data adapter can define what is too
-// much data)
-export default async function autorunFeatureDensityStats(
-  self: BaseLinearDisplayModel,
-) {
-  try {
-    const view = getContainingView(self) as LinearGenomeViewModel
-
-    // extra check for contentBlocks.length
-    // https://github.com/GMOD/jbrowse-components/issues/2694
-    if (
-      !view.initialized ||
-      !view.staticBlocks.contentBlocks.length ||
-      view.bpPerPx === self.currStatsBpPerPx ||
-      self.error
-    ) {
-      return
-    }
-
-    // don't re-estimate featureDensity even if zoom level changes,
-    // jbrowse1-style assume it's sort of representative
-    if (self.featureDensityStats?.featureDensity !== undefined) {
-      self.setCurrStatsBpPerPx(view.bpPerPx)
-      return
-    }
-
-    self.clearFeatureDensityStats()
-    self.setCurrStatsBpPerPx(view.bpPerPx)
-    const stats = await self.getFeatureDensityStats()
-    if (isAlive(self)) {
-      self.setFeatureDensityStats(stats)
-    }
-  } catch (e) {
-    if (!isAbortException(e) && isAlive(self)) {
-      console.error(e)
-      self.setError(e)
-    }
-  }
-}

package/src/BaseLinearDisplay/models/configSchema.ts

@@ -1,60 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config BaseLinearDisplay
- * #category display
- * `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/renderSvg.tsx

@@ -1,101 +0,0 @@
-import React from 'react'
-import { ThemeOptions } from '@mui/material'
-import {
-  getContainingView,
-  getViewParams,
-  ReactRendering,
-} from '@jbrowse/core/util'
-
-// locals
-import { ExportSvgOptions, LinearGenomeViewModel } from '../../LinearGenomeView'
-import BlockState, { renderBlockData } from './serverSideRenderedBlock'
-import { getId } from './util'
-
-import { BaseLinearDisplayModel } from './BaseLinearDisplayModel'
-
-export default async function renderBaseLinearDisplaySvg(
-  self: BaseLinearDisplayModel,
-  opts: ExportSvgOptions & {
-    overrideHeight: number
-    theme: ThemeOptions
-  },
-) {
-  const { height, id } = self
-  const { overrideHeight } = opts
-  const view = getContainingView(self) as LinearGenomeViewModel
-  const { offsetPx: viewOffsetPx, roundedDynamicBlocks, width } = view
-  const renderings = await Promise.all(
-    roundedDynamicBlocks.map(async block => {
-      const blockState = BlockState.create({
-        key: block.key,
-        region: block,
-      })
-
-      // regionCannotBeRendered can return jsx so look for plaintext
-      // version, or just get the default if none available
-      const cannotBeRenderedReason =
-        self.regionCannotBeRenderedText(block) ||
-        self.regionCannotBeRendered(block)
-
-      if (cannotBeRenderedReason) {
-        return [
-          block,
-          {
-            reactElement: (
-              <>
-                <rect x={0} y={0} width={width} height={20} fill="#aaa" />
-                <text x={0} y={15}>
-                  {cannotBeRenderedReason}
-                </text>
-              </>
-            ),
-          },
-        ] as const
-      }
-
-      const { rpcManager, renderArgs, renderProps, rendererType } =
-        renderBlockData(blockState, self)
-
-      return [
-        block,
-        await rendererType.renderInClient(rpcManager, {
-          ...renderArgs,
-          ...renderProps,
-          viewParams: getViewParams(self, true),
-          exportSVG: opts,
-          theme: opts.theme || renderProps.theme,
-        }),
-      ] as const
-    }),
-  )
-
-  return (
-    <>
-      {renderings.map(([block, rendering], index) => {
-        const { offsetPx, widthPx } = block
-        const offset = offsetPx - viewOffsetPx
-        const clipid = getId(id, index)
-
-        return (
-          <React.Fragment key={`frag-${index}`}>
-            <defs>
-              <clipPath id={clipid}>
-                <rect
-                  x={0}
-                  y={0}
-                  width={widthPx}
-                  height={overrideHeight || height}
-                />
-              </clipPath>
-            </defs>
-            <g transform={`translate(${offset} 0)`}>
-              <g clipPath={`url(#${clipid})`}>
-                <ReactRendering rendering={rendering} />
-              </g>
-            </g>
-          </React.Fragment>
-        )
-      })}
-    </>
-  )
-}

package/src/BaseLinearDisplay/models/serverSideRenderedBlock.ts

@@ -1,320 +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() {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        ;(async () => {
-          try {
-            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) {
-              await rendererType.freeResourcesInClient(
-                rpcManager,
-                JSON.parse(JSON.stringify(renderArgs)),
-              )
-            }
-          } catch (e) {
-            console.error('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,24 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-
-/**
- * #config BasicTrack
- * #category track
- * 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,28 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes'
-import PluginManager from '@jbrowse/core/PluginManager'
-
-/**
- * #config FeatureTrack
- * #category track
- * 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),
-    })
-  })
-}