Add 'matrix' display for multi-sample VCFs

packages/core/ReExports/DataGrid.tsx

@@ -1,3 +1,2 @@
 // convert named export to default for lazy react
-
 export { DataGrid as default } from '@mui/x-data-grid'

packages/core/configuration/util.ts

@@ -42,9 +42,8 @@ export function readConfObject<CONFMODEL extends AnyConfigurationModel>(
   args: Record<string, unknown> = {},
 ): any {
   if (!slotPath) {
-    return JSON.parse(JSON.stringify(getSnapshot(confObject)))
-  }
-  if (typeof slotPath === 'string') {
+    return structuredClone(getSnapshot(confObject))
+  } else if (typeof slotPath === 'string') {
     let slot = confObject[slotPath]
     // check for the subconf being a map if we don't find it immediately
     if (
@@ -66,15 +65,13 @@ export function readConfObject<CONFMODEL extends AnyConfigurationModel>(
       //     schemaType.name
       //   })`,
       // )
+    } else {
+      const val = slot.expr ? slot.expr.evalSync(args) : slot
+      return isStateTreeNode(val)
+        ? JSON.parse(JSON.stringify(getSnapshot(val)))
+        : val
     }
-
-    const val = slot.expr ? slot.expr.evalSync(args) : slot
-    return isStateTreeNode(val)
-      ? JSON.parse(JSON.stringify(getSnapshot(val)))
-      : val
-  }
-
-  if (Array.isArray(slotPath)) {
+  } else if (Array.isArray(slotPath)) {
     const slotName = slotPath[0]!
     if (slotPath.length > 1) {
       const newPath = slotPath.slice(1)
@@ -172,39 +169,35 @@ export function isBareConfigurationSchemaType(
 export function isConfigurationSchemaType(
   thing: unknown,
 ): thing is AnyConfigurationSchemaType {
-  if (!isType(thing)) {
-    return false
-  }
-
-  // written as a series of if-statements instead of a big logical OR
-  // because this construction gives much better debugging backtraces.
+  // written as a series of if-statements instead of a big logical because this
+  // construction gives much better debugging backtraces.
 
-  // also, note that the order of these statements matters, because
-  // for example some union types are also optional types
+  // also, note that the order of these statements matters, because for example
+  // some union types are also optional types
 
-  if (isBareConfigurationSchemaType(thing)) {
+  if (!isType(thing)) {
+    return false
+  } else if (isBareConfigurationSchemaType(thing)) {
     return true
-  }
-
-  if (isUnionType(thing)) {
+  } else if (isUnionType(thing)) {
     return getUnionSubTypes(thing).every(
       t => isConfigurationSchemaType(t) || t.name === 'undefined',
     )
-  }
-
-  if (isOptionalType(thing) && isConfigurationSchemaType(getSubType(thing))) {
+  } else if (
+    isOptionalType(thing) &&
+    isConfigurationSchemaType(getSubType(thing))
+  ) {
     return true
-  }
-
-  if (isArrayType(thing) && isConfigurationSchemaType(getSubType(thing))) {
+  } else if (
+    isArrayType(thing) &&
+    isConfigurationSchemaType(getSubType(thing))
+  ) {
     return true
-  }
-
-  if (isMapType(thing) && isConfigurationSchemaType(getSubType(thing))) {
+  } else if (isMapType(thing) && isConfigurationSchemaType(getSubType(thing))) {
     return true
+  } else {
+    return false
   }
-
-  return false
 }
 
 export function isConfigurationModel(

packages/core/package.json

@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.17.9",
+    "@floating-ui/react": "^0.27.0",
     "@gmod/abortable-promise-cache": "^2.0.0",
     "@gmod/bgzf-filehandle": "^1.4.3",
     "@gmod/http-range-fetcher": "^3.0.4",

packages/core/pluggableElementTypes/PluggableElementBase.ts

@@ -2,9 +2,9 @@ export default abstract class PluggableElementBase {
   name: string
   maybeDisplayName?: string
 
-  constructor(args: { name?: string; displayName?: string }) {
-    this.name = args.name || 'UNKNOWN'
-    this.maybeDisplayName = args.displayName
+  constructor(args?: { name?: string; displayName?: string }) {
+    this.name = args?.name || 'UNKNOWN'
+    this.maybeDisplayName = args?.displayName
   }
 
   get displayName() {

packages/core/pluggableElementTypes/RpcMethodType.ts

@@ -15,7 +15,7 @@ export type RpcMethodConstructor = new (pm: PluginManager) => RpcMethodType
 
 export default abstract class RpcMethodType extends PluggableElementBase {
   constructor(public pluginManager: PluginManager) {
-    super({})
+    super()
   }
 
   async serializeArguments(

packages/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.ts

@@ -0,0 +1,40 @@
+import RpcMethodType from './RpcMethodType'
+import { renameRegionsIfNeeded } from '../util'
+import SerializableFilterChain from './renderers/util/serializableFilterChain'
+
+import type { RenderArgs } from '@jbrowse/core/rpc/coreRpcMethods'
+
+export default abstract class RpcMethodTypeWithFiltersAndRenameRegions extends RpcMethodType {
+  async deserializeArguments(args: any, rpcDriverClassName: string) {
+    const l = await super.deserializeArguments(args, rpcDriverClassName)
+    return {
+      ...l,
+      filters: args.filters
+        ? new SerializableFilterChain({
+            filters: args.filters,
+          })
+        : undefined,
+    }
+  }
+
+  async serializeArguments(
+    args: RenderArgs & {
+      stopToken?: string
+      statusCallback?: (arg: string) => void
+    },
+    rpcDriverClassName: string,
+  ) {
+    const pm = this.pluginManager
+    const assemblyManager = pm.rootModel?.session?.assemblyManager
+    if (!assemblyManager) {
+      throw new Error('no assembly manager')
+    }
+
+    const renamedArgs = await renameRegionsIfNeeded(assemblyManager, {
+      ...args,
+      filters: args.filters?.toJSON().filters,
+    })
+
+    return super.serializeArguments(renamedArgs, rpcDriverClassName)
+  }
+}

packages/core/rpc/BaseRpcDriver.ts

@@ -31,32 +31,10 @@ function isCloneable(thing: unknown) {
   return !(typeof thing === 'function') && !(thing instanceof Error)
 }
 
-// watches the given worker object, returns a promise that will be rejected if
-// the worker times out
-export async function watchWorker(
-  worker: WorkerHandle,
-  pingTime: number,
-  rpcDriverClassName: string,
-) {
-  // after first ping succeeds, apply wait for timeout
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  while (true) {
-    await worker.call('ping', [], {
-      timeout: pingTime * 2,
-      rpcDriverClassName,
-    })
-    await new Promise(resolve => setTimeout(resolve, pingTime))
-  }
-}
-
 function detectHardwareConcurrency() {
   const mainThread = typeof window !== 'undefined'
   const canDetect = mainThread && 'hardwareConcurrency' in window.navigator
-  if (mainThread && canDetect) {
-    return window.navigator.hardwareConcurrency
-  }
-  return 1
+  return mainThread && canDetect ? window.navigator.hardwareConcurrency : 1
 }
 class LazyWorker {
   workerP?: Promise<WorkerHandle> | undefined
@@ -65,27 +43,10 @@ class LazyWorker {
 
   async getWorker() {
     if (!this.workerP) {
-      this.workerP = this.driver
-        .makeWorker()
-        .then(worker => {
-          watchWorker(worker, this.driver.maxPingTime, this.driver.name).catch(
-            (error: unknown) => {
-              console.error(
-                'worker did not respond, killing and generating new one',
-              )
-              console.error(error)
-              worker.destroy()
-              worker.status = 'killed'
-              worker.error = error
-              this.workerP = undefined
-            },
-          )
-          return worker
-        })
-        .catch((e: unknown) => {
-          this.workerP = undefined
-          throw e
-        })
+      this.workerP = this.driver.makeWorker().catch((e: unknown) => {
+        this.workerP = undefined
+        throw e
+      })
     }
     return this.workerP
   }
@@ -197,7 +158,6 @@ export default abstract class BaseRpcDriver {
     if (!sessionId) {
       throw new TypeError('sessionId is required')
     }
-    let done = false
     const unextendedWorker = await this.getWorker(sessionId)
     const worker = pluginManager.evaluateExtensionPoint(
       'Core-extendWorker',
@@ -211,41 +171,13 @@ export default abstract class BaseRpcDriver {
     const filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId)
 
     // now actually call the worker
-    const callP = worker
-      .call(functionName, filteredAndSerializedArgs, {
-        timeout: 5 * 60 * 1000, // 5 minutes
-        statusCallback: args.statusCallback,
-        rpcDriverClassName: this.name,
-        ...options,
-      })
-      .finally(() => {
-        done = true
-      })
-
-    // check every 5 seconds to see if the worker has been killed, and
-    // reject the killedP promise if it has
-    let killedCheckInterval: ReturnType<typeof setInterval>
-    const killedP = new Promise((resolve, reject) => {
-      killedCheckInterval = setInterval(() => {
-        // must've been killed
-        if (worker.status === 'killed') {
-          reject(
-            new Error(
-              `operation timed out, worker process stopped responding, ${worker.error}`,
-            ),
-          )
-        } else if (done) {
-          resolve(true)
-        }
-      }, this.workerCheckFrequency)
-    }).finally(() => {
-      clearInterval(killedCheckInterval)
+    const call = await worker.call(functionName, filteredAndSerializedArgs, {
+      timeout: 5 * 60 * 1000, // 5 minutes
+      statusCallback: args.statusCallback,
+      rpcDriverClassName: this.name,
+      ...options,
     })
 
-    // the result is a race between the actual result promise, and the "killed"
-    // promise. the killed promise will only actually win if the worker was
-    // killed before the call could return
-    const resultP = Promise.race([callP, killedP])
-    return rpcMethod.deserializeReturn(resultP, args, this.name)
+    return rpcMethod.deserializeReturn(call, args, this.name)
   }
 }

packages/core/ui/LoadingEllipses.tsx

@@ -40,9 +40,13 @@ export default function LoadingEllipses({
   variant = 'body2',
   ...rest
 }: Props) {
-  const { classes } = useStyles()
+  const { cx, classes } = useStyles()
   return (
-    <Typography className={classes.dots} {...rest} variant={variant}>
+    <Typography
+      className={cx(classes.dots, rest.className)}
+      {...rest}
+      variant={variant}
+    >
       {message || 'Loading'}
     </Typography>
   )

packages/product-core/src/rpcWorker.ts

@@ -87,13 +87,7 @@ export async function initializeWorker(
     )
 
     // @ts-expect-error
-    self.rpcServer = new RpcServer.Server({
-      ...rpcConfig,
-      ping: async () => {
-        // the ping method is required by the worker driver for checking the
-        // health of the worker
-      },
-    })
+    self.rpcServer = new RpcServer.Server(rpcConfig)
     postMessage({ message: 'ready' })
   } catch (e) {
     postMessage({ message: 'error', error: serializeError(e) })

packages/sv-core/package.json

@@ -41,11 +41,11 @@
     "useSrc": "node ../../scripts/useSrc.js"
   },
   "dependencies": {
-    "@jbrowse/plugin-linear-genome-view": "^2.17.0",
+    "@gmod/vcf": "^6.0.0",
     "@jbrowse/core": "^2.17.0",
+    "@jbrowse/plugin-linear-genome-view": "^2.17.0",
     "@mui/icons-material": "^6.0.0",
-    "@mui/material": "^6.0.0",
-    "@gmod/vcf": "^5.0.9"
+    "@mui/material": "^6.0.0"
   },
   "peerDependencies": {
     "mobx": "^6.0.0",

plugins/alignments/src/LinearPileupDisplay/components/LinearPileupDisplayBlurb.tsx

@@ -3,16 +3,13 @@ import React from 'react'
 import { Typography } from '@mui/material'
 import { observer } from 'mobx-react'
 
+import type { SortedBy } from '../../shared/types'
+
 const LinearPileupDisplayBlurb = observer(function ({
   model,
 }: {
   model: {
-    sortedBy?: {
-      pos: number
-      refName: number
-      type: string
-      tag?: string
-    }
+    sortedBy?: SortedBy
   }
 }) {
   const { sortedBy } = model

plugins/authentication/src/ExternalTokenModel/ExternalTokenEntryForm.tsx

@@ -17,6 +17,9 @@ export const ExternalTokenEntryForm = ({
       open
       maxWidth="xl"
       data-testid="externalToken-form"
+      onClose={() => {
+        handleClose()
+      }}
       title={`Enter token for ${internetAccountId}`}
     >
       <DialogContent style={{ display: 'flex', flexDirection: 'column' }}>

plugins/authentication/src/HTTPBasicModel/HTTPBasicLoginForm.tsx

@@ -19,6 +19,9 @@ export function HTTPBasicLoginForm({
       maxWidth="xl"
       data-testid="login-httpbasic"
       title={`Log in for ${internetAccountId}`}
+      onClose={() => {
+        handleClose()
+      }}
     >
       <form
         onSubmit={event => {

plugins/breakpoint-split-view/package.json

@@ -36,7 +36,7 @@
     "clean": "rimraf dist esm *.tsbuildinfo"
   },
   "dependencies": {
-    "@gmod/vcf": "^5.0.9",
+    "@gmod/vcf": "^6.0.0",
     "@mui/icons-material": "^6.0.0",
     "@types/file-saver": "^2.0.1",
     "file-saver": "^2.0.0"