@jbrowse/core 2.17.0 → 2.18.0

package/pluggableElementTypes/renderers/RpcRenderedSvgGroup.js

@@ -24,18 +24,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importStar(require("react"));
-const mobx_react_1 = require("mobx-react");
-// locals
-const util_1 = require("../../util");
 const material_1 = require("@mui/material");
-const ui_1 = require("../../ui");
+const mobx_react_1 = require("mobx-react");
 const mobx_state_tree_1 = require("mobx-state-tree");
-// eslint-disable-next-line react/no-deprecated
 const react_dom_1 = require("react-dom");
+const ui_1 = require("../../ui");
+const util_1 = require("../../util");
 const NewHydrate = (0, mobx_react_1.observer)(function RpcRenderedSvgGroup(props) {
     const { html, theme, RenderingComponent, ...rest } = props;
     const ref = (0, react_1.useRef)(null);
-    // this `any` is a react-dom/client::Root
     const rootRef = (0, react_1.useRef)();
     const root = (0, mobx_state_tree_1.getRoot)(props.displayModel);
     const hydrateRoot = root.hydrateFn;
@@ -60,7 +57,6 @@ const NewHydrate = (0, mobx_react_1.observer)(function RpcRenderedSvgGroup(props
                 root === null || root === void 0 ? void 0 : root.unmount();
             });
         };
-        // biome-ignore lint/correctness/useExhaustiveDependencies:
     }, [RenderingComponent, hydrateRoot, theme, rest]);
     return react_1.default.createElement("g", { ref: ref, dangerouslySetInnerHTML: { __html: html } });
 });
@@ -74,13 +70,8 @@ const OldHydrate = (0, mobx_react_1.observer)(function OldHydrate(props) {
                 if (domNode.innerHTML) {
                     (0, react_dom_1.unmountComponentAtNode)(domNode);
                 }
-                // setting outline:none fixes react "focusable" element issue. see
-                // https://github.com/GMOD/jbrowse-components/issues/2160
                 domNode.style.outline = 'none';
                 domNode.innerHTML = html;
-                // use requestIdleCallback to defer main-thread rendering and
-                // hydration for when we have some free time. helps keep the
-                // framerate up.
                 (0, util_1.rIC)(() => {
                     (0, react_dom_1.hydrate)(react_1.default.createElement(RenderingComponent, { ...props }), domNode);
                 });

package/pluggableElementTypes/renderers/ServerSideRenderedContent.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ResultsSerialized, RenderArgs } from './ServerSideRendererType';
+import type { RenderArgs, ResultsSerialized } from './ServerSideRendererType';
 interface Props extends ResultsSerialized, RenderArgs {
     RenderingComponent: React.ComponentType<any>;
 }

package/pluggableElementTypes/renderers/ServerSideRenderedContent.js

@@ -25,31 +25,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importStar(require("react"));
 const styles_1 = require("@mui/material/styles");
-// locals
-const ui_1 = require("../../ui");
 const mobx_react_1 = require("mobx-react");
 const mobx_state_tree_1 = require("mobx-state-tree");
-// eslint-disable-next-line react/no-deprecated
 const react_dom_1 = require("react-dom");
+const ui_1 = require("../../ui");
 const util_1 = require("../../util");
 const NewHydrate = (0, mobx_react_1.observer)(function ServerSideRenderedContent({ theme, html, RenderingComponent, ...rest }) {
     const ref = (0, react_1.useRef)(null);
     const rootRef = (0, react_1.useRef)();
     const { hydrateFn } = (0, mobx_state_tree_1.getRoot)(rest.displayModel);
     (0, react_1.useEffect)(() => {
-        // requestIdleCallback here helps to avoid hydration mismatch because it
-        // provides time for dangerouslySetInnerHTML to set the innerHTML contents
-        // of the node, otherwise ref.current.innerHTML can be empty
+        if (ref.current) {
+            ref.current.innerHTML = html;
+        }
         const renderTimeout = (0, util_1.rIC)(() => {
             var _a;
             if (!ref.current) {
                 return;
             }
             const jbrowseTheme = (0, ui_1.createJBrowseTheme)(theme);
-            // if there is a hydration mismatch, investigate value of
-            // - value of ref.current.innerHTML
-            // - value of `html` variable
-            // - renderToString of the below React element
             rootRef.current =
                 (_a = rootRef.current) !== null && _a !== void 0 ? _a : hydrateFn(ref.current, react_1.default.createElement(styles_1.ThemeProvider, { theme: jbrowseTheme },
                     react_1.default.createElement(RenderingComponent, { ...rest })));
@@ -64,9 +58,8 @@ const NewHydrate = (0, mobx_react_1.observer)(function ServerSideRenderedContent
                 root === null || root === void 0 ? void 0 : root.unmount();
             });
         };
-        /* biome-ignore lint/correctness/useExhaustiveDependencies: */
-    }, [theme, rest, hydrateFn, RenderingComponent]);
-    return (react_1.default.createElement("div", { "data-testid": "hydrationContainer", ref: ref, dangerouslySetInnerHTML: { __html: html } }));
+    }, [theme, rest, html, hydrateFn, RenderingComponent]);
+    return react_1.default.createElement("div", { "data-testid": "hydrationContainer", ref: ref });
 });
 const OldHydrate = (0, mobx_react_1.observer)(function ({ theme, html, RenderingComponent, ...rest }) {
     const ref = (0, react_1.useRef)(null);
@@ -89,7 +82,6 @@ const OldHydrate = (0, mobx_react_1.observer)(function ({ theme, html, Rendering
                 (0, react_dom_1.unmountComponentAtNode)(domNode);
             }
         };
-        /* biome-ignore lint/correctness/useExhaustiveDependencies: */
     }, [html, jbrowseTheme, rest, RenderingComponent]);
     return react_1.default.createElement("div", { ref: ref });
 });

package/pluggableElementTypes/renderers/ServerSideRendererType.d.ts

@@ -1,12 +1,14 @@
-import { ThemeOptions } from '@mui/material';
-import { SnapshotOrInstance, SnapshotIn } from 'mobx-state-tree';
-import SerializableFilterChain, { SerializedFilterChain } from './util/serializableFilterChain';
-import { AnyConfigurationModel } from '../../configuration';
-import RpcManager from '../../rpc/RpcManager';
-import RendererType, { RenderProps, RenderResults } from './RendererType';
+import RendererType from './RendererType';
+import SerializableFilterChain from './util/serializableFilterChain';
+import type { RenderProps, RenderResults } from './RendererType';
+import type { AnyConfigurationModel } from '../../configuration';
+import type { SerializedFilterChain } from './util/serializableFilterChain';
+import type RpcManager from '../../rpc/RpcManager';
+import type { ThemeOptions } from '@mui/material';
+import type { SnapshotIn, SnapshotOrInstance } from 'mobx-state-tree';
 interface BaseRenderArgs extends RenderProps {
     sessionId: string;
-    signal?: AbortSignal;
+    stopToken?: string;
     theme: ThemeOptions;
     exportSVG?: {
         rasterizeLayers?: boolean;
@@ -36,53 +38,11 @@ export interface ResultsSerializedSvgExport extends ResultsSerialized {
 }
 export type ResultsDeserialized = RenderResults;
 export default class ServerSideRenderer extends RendererType {
-    /**
-     * directly modifies the render arguments to prepare them to be serialized and
-     * sent to the worker.
-     *
-     * @param args - the arguments passed to render
-     * @returns the same object
-     */
     serializeArgsInClient(args: RenderArgs): RenderArgsSerialized;
-    /**
-     * Deserialize the render results from the worker in the client. Includes
-     * hydrating of the React HTML string, and not hydrating the result if SVG is
-     * being rendered
-     *
-     * @param results - the results of the render
-     * @param args - the arguments passed to render
-     */
     deserializeResultsInClient(res: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    /**
-     * modifies the passed arguments object to inflate arguments as necessary.
-     * called in the worker process.
-     *
-     * @param args - the converted arguments to modify
-     */
     deserializeArgsInWorker(args: RenderArgsSerialized): RenderArgsDeserialized;
-    /**
-     * Serialize results of the render to send them to the client. Includes
-     * rendering React to an HTML string.
-     *
-     * @param results - object containing the results of calling the `render`
-     * method
-     * @param args - deserialized render args
-     */
     serializeResultsInWorker(results: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
-    /**
-     * Render method called on the client. Serializes args, then calls
-     * "CoreRender" with the RPC manager.
-     *
-     * @param rpcManager - RPC manager
-     * @param args - render args
-     */
     renderInClient(rpcManager: RpcManager, args: RenderArgs): Promise<ResultsSerialized>;
-    /**
-     * Render method called on the worker. `render` is called here in server-side
-     * rendering
-     *
-     * @param args - serialized render args
-     */
     renderInWorker(args: RenderArgsSerialized): Promise<ResultsSerialized>;
     freeResourcesInClient(rpcManager: RpcManager, args: RenderArgs): Promise<number>;
 }

package/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -5,25 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
 const styles_1 = require("@mui/material/styles");
-const server_1 = require("react-dom/server");
 const mobx_state_tree_1 = require("mobx-state-tree");
-// locals
-const util_1 = require("../../util");
-const serializableFilterChain_1 = __importDefault(require("./util/serializableFilterChain"));
-const ui_1 = require("../../ui");
+const server_1 = require("react-dom/server");
 const RendererType_1 = __importDefault(require("./RendererType"));
 const ServerSideRenderedContent_1 = __importDefault(require("./ServerSideRenderedContent"));
+const ui_1 = require("../../ui");
+const serializableFilterChain_1 = __importDefault(require("./util/serializableFilterChain"));
+const util_1 = require("../../util");
+const stopToken_1 = require("../../util/stopToken");
 function isSvgExport(e) {
     return 'canvasRecordedData' in e;
 }
 class ServerSideRenderer extends RendererType_1.default {
-    /**
-     * directly modifies the render arguments to prepare them to be serialized and
-     * sent to the worker.
-     *
-     * @param args - the arguments passed to render
-     * @returns the same object
-     */
     serializeArgsInClient(args) {
         var _a;
         return {
@@ -34,20 +27,8 @@ class ServerSideRenderer extends RendererType_1.default {
             filters: (_a = args.filters) === null || _a === void 0 ? void 0 : _a.toJSON().filters,
         };
     }
-    /**
-     * Deserialize the render results from the worker in the client. Includes
-     * hydrating of the React HTML string, and not hydrating the result if SVG is
-     * being rendered
-     *
-     * @param results - the results of the render
-     * @param args - the arguments passed to render
-     */
     deserializeResultsInClient(res, args) {
-        // if we are rendering svg, we skip hydration
         if (args.exportSVG) {
-            // only return the res if the renderer explicitly has
-            // this.supportsSVG support to avoid garbage being rendered in SVG
-            // document
             return {
                 ...res,
                 html: this.supportsSVG
@@ -55,18 +36,11 @@ class ServerSideRenderer extends RendererType_1.default {
                     : '<text y="12" fill="black">SVG export not supported for this track</text>',
             };
         }
-        // get res using ServerSideRenderedContent
         return {
             ...res,
             reactElement: (react_1.default.createElement(ServerSideRenderedContent_1.default, { ...args, ...res, RenderingComponent: this.ReactComponent })),
         };
     }
-    /**
-     * modifies the passed arguments object to inflate arguments as necessary.
-     * called in the worker process.
-     *
-     * @param args - the converted arguments to modify
-     */
     deserializeArgsInWorker(args) {
         const deserialized = { ...args };
         deserialized.config = this.configSchema.create(args.config || {}, {
@@ -79,26 +53,11 @@ class ServerSideRenderer extends RendererType_1.default {
             : undefined;
         return deserialized;
     }
-    /**
-     * Serialize results of the render to send them to the client. Includes
-     * rendering React to an HTML string.
-     *
-     * @param results - object containing the results of calling the `render`
-     * method
-     * @param args - deserialized render args
-     */
     serializeResultsInWorker(results, args) {
         const html = (0, server_1.renderToString)(react_1.default.createElement(styles_1.ThemeProvider, { theme: (0, ui_1.createJBrowseTheme)(args.theme) }, results.reactElement));
         results.reactElement = undefined;
         return { ...results, html };
     }
-    /**
-     * Render method called on the client. Serializes args, then calls
-     * "CoreRender" with the RPC manager.
-     *
-     * @param rpcManager - RPC manager
-     * @param args - render args
-     */
     async renderInClient(rpcManager, args) {
         const results = (await rpcManager.call(args.sessionId, 'CoreRender', args));
         if (isSvgExport(results)) {
@@ -107,20 +66,11 @@ class ServerSideRenderer extends RendererType_1.default {
         }
         return results;
     }
-    /**
-     * Render method called on the worker. `render` is called here in server-side
-     * rendering
-     *
-     * @param args - serialized render args
-     */
     async renderInWorker(args) {
-        const { signal, statusCallback = () => { } } = args;
+        const { stopToken, statusCallback = () => { } } = args;
         const deserializedArgs = this.deserializeArgsInWorker(args);
         const results = await (0, util_1.updateStatus)('Rendering plot', statusCallback, () => this.render(deserializedArgs));
-        (0, util_1.checkAbortSignal)(signal);
-        // serialize the results for passing back to the main thread.
-        // these will be transmitted to the main process, and will come out
-        // as the result of renderRegionWithWorker.
+        (0, stopToken_1.checkStopToken)(stopToken);
         return (0, util_1.updateStatus)('Serializing results', statusCallback, () => this.serializeResultsInWorker(results, deserializedArgs));
     }
     async freeResourcesInClient(rpcManager, args) {

package/pluggableElementTypes/renderers/index.d.ts

@@ -1,7 +1,7 @@
 export { default as BoxRendererType } from './BoxRendererType';
 export { default as ComparativeServerSideRendererType } from './ComparativeServerSideRendererType';
 export { default as CircularChordRendererType } from './CircularChordRendererType';
-export { default as RendererType, type RenderProps } from './RendererType';
+export { type RenderProps, default as RendererType } from './RendererType';
 export { default as FeatureRendererType } from './FeatureRendererType';
 export { default as ServerSideRenderedContent } from './ServerSideRenderedContent';
 export { default as ServerSideRendererType } from './ServerSideRendererType';

package/pluggableElementTypes/renderers/util/serializableFilterChain.js

@@ -16,9 +16,7 @@ class SerializableFilterChain {
     }
     passes(...args) {
         for (const entry of this.filterChain) {
-            if (
-            // @ts-expect-error
-            !entry.expr.evalSync({ feature: args[0] })) {
+            if (!entry.expr.evalSync({ feature: args[0] })) {
                 return false;
             }
         }

package/rpc/BaseRpcDriver.d.ts

@@ -1,5 +1,5 @@
-import PluginManager from '../PluginManager';
-import { AnyConfigurationModel } from '../configuration';
+import type PluginManager from '../PluginManager';
+import type { AnyConfigurationModel } from '../configuration';
 export interface WorkerHandle {
     status?: string;
     error?: unknown;
@@ -15,7 +15,6 @@ export interface WorkerHandle {
 export interface RpcDriverConstructorArgs {
     config: AnyConfigurationModel;
 }
-export declare function watchWorker(worker: WorkerHandle, pingTime: number, rpcDriverClassName: string): Promise<void>;
 declare class LazyWorker {
     driver: BaseRpcDriver;
     workerP?: Promise<WorkerHandle> | undefined;
@@ -33,7 +32,7 @@ export default abstract class BaseRpcDriver {
     config: AnyConfigurationModel;
     constructor(args: RpcDriverConstructorArgs);
     filterArgs<THING_TYPE>(thing: THING_TYPE, sessionId: string): THING_TYPE;
-    remoteAbort(sessionId: string, functionName: string, signalId: number): Promise<void>;
+    remoteAbort(sessionId: string, functionName: string, stopTokenId: number): Promise<void>;
     createWorkerPool(): LazyWorker[];
     getWorkerPool(): LazyWorker[];
     getWorker(sessionId: string): Promise<WorkerHandle>;

package/rpc/BaseRpcDriver.js

@@ -1,33 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchWorker = watchWorker;
 const mobx_state_tree_1 = require("mobx-state-tree");
-const util_1 = require("../util");
-const remoteAbortSignals_1 = require("./remoteAbortSignals");
 const configuration_1 = require("../configuration");
+const util_1 = require("../util");
 function isCloneable(thing) {
     return !(typeof thing === 'function') && !(thing instanceof Error);
 }
-// watches the given worker object, returns a promise that will be rejected if
-// the worker times out
-async function watchWorker(worker, pingTime, rpcDriverClassName) {
-    // 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 {
     constructor(driver) {
@@ -35,20 +17,7 @@ class LazyWorker {
     }
     async getWorker() {
         if (!this.workerP) {
-            this.workerP = this.driver
-                .makeWorker()
-                .then(worker => {
-                watchWorker(worker, this.driver.maxPingTime, this.driver.name).catch((error) => {
-                    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) => {
+            this.workerP = this.driver.makeWorker().catch((e) => {
                 this.workerP = undefined;
                 throw e;
             });
@@ -59,40 +28,37 @@ class LazyWorker {
 class BaseRpcDriver {
     constructor(args) {
         this.lastWorkerAssignment = -1;
-        this.workerAssignments = new Map(); // sessionId -> worker number
+        this.workerAssignments = new Map();
         this.maxPingTime = 30000;
         this.workerCheckFrequency = 5000;
         this.config = args.config;
     }
-    // filter the given object and just remove any non-cloneable things from it
     filterArgs(thing, sessionId) {
         if (Array.isArray(thing)) {
             return thing
                 .filter(thing => isCloneable(thing))
                 .map(t => this.filterArgs(t, sessionId));
         }
-        if (typeof thing === 'object' && thing !== null) {
-            // AbortSignals are specially handled
-            if (thing instanceof AbortSignal) {
-                return (0, remoteAbortSignals_1.serializeAbortSignal)(thing, this.remoteAbort.bind(this, sessionId));
-            }
+        else if (typeof thing === 'object' && thing !== null) {
             if ((0, mobx_state_tree_1.isStateTreeNode)(thing) && !(0, mobx_state_tree_1.isAlive)(thing)) {
                 throw new Error('dead state tree node passed to RPC call');
             }
-            // special case, don't try to iterate the file's subelements as the
-            // object entries below would
-            if (thing instanceof File) {
+            else if (thing instanceof File) {
                 return thing;
             }
-            return Object.fromEntries(Object.entries(thing)
-                .filter(e => isCloneable(e[1]))
-                .map(([k, v]) => [k, this.filterArgs(v, sessionId)]));
+            else {
+                return Object.fromEntries(Object.entries(thing)
+                    .filter(e => isCloneable(e[1]))
+                    .map(([k, v]) => [k, this.filterArgs(v, sessionId)]));
+            }
+        }
+        else {
+            return thing;
         }
-        return thing;
     }
-    async remoteAbort(sessionId, functionName, signalId) {
+    async remoteAbort(sessionId, functionName, stopTokenId) {
         const worker = await this.getWorker(sessionId);
-        await worker.call(functionName, { signalId }, { timeout: 1000000, rpcDriverClassName: this.name });
+        await worker.call(functionName, { stopTokenId }, { timeout: 1000000, rpcDriverClassName: this.name });
     }
     createWorkerPool() {
         const hardwareConcurrency = detectHardwareConcurrency();
@@ -108,7 +74,7 @@ class BaseRpcDriver {
         if (!this.workerPool) {
             const res = this.createWorkerPool();
             this.workerPool = res;
-            return res; // making this several steps makes TS happy
+            return res;
         }
         return this.workerPool;
     }
@@ -127,7 +93,6 @@ 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', unextendedWorker);
         const rpcMethod = pluginManager.getRpcMethodType(functionName);
@@ -136,38 +101,13 @@ class BaseRpcDriver {
         }
         const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
         const filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId);
-        // now actually call the worker
-        const callP = worker
-            .call(functionName, filteredAndSerializedArgs, {
-            timeout: 5 * 60 * 1000, // 5 minutes
+        const call = await worker.call(functionName, filteredAndSerializedArgs, {
+            timeout: 5 * 60 * 1000,
             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;
-        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);
         });
-        // 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);
     }
 }
 exports.default = BaseRpcDriver;

package/rpc/MainThreadRpcDriver.d.ts

@@ -1,14 +1,10 @@
-import BaseRpcDriver, { RpcDriverConstructorArgs } from './BaseRpcDriver';
-import PluginManager from '../PluginManager';
+import BaseRpcDriver from './BaseRpcDriver';
+import type { RpcDriverConstructorArgs } from './BaseRpcDriver';
+import type PluginManager from '../PluginManager';
 declare class DummyHandle {
     destroy(): void;
     call(_functionName: string, _filteredArgs?: Record<string, unknown>, _options?: {}): Promise<unknown>;
 }
-/**
- * Stub RPC driver class that runs RPC functions in-band in the main thread.
- *
- * @param rpcFuncs - object containing runnable rpc functions
- */
 export default class MainThreadRpcDriver extends BaseRpcDriver {
     name: string;
     makeWorker: () => Promise<DummyHandle>;

package/rpc/MainThreadRpcDriver.js

@@ -10,11 +10,6 @@ class DummyHandle {
         return undefined;
     }
 }
-/**
- * Stub RPC driver class that runs RPC functions in-band in the main thread.
- *
- * @param rpcFuncs - object containing runnable rpc functions
- */
 class MainThreadRpcDriver extends BaseRpcDriver_1.default {
     constructor(args) {
         super(args);

package/rpc/RpcManager.d.ts

@@ -1,7 +1,7 @@
-import PluginManager from '../PluginManager';
-import { AnyConfigurationModel } from '../configuration';
-import WebWorkerRpcDriver from './WebWorkerRpcDriver';
 import MainThreadRpcDriver from './MainThreadRpcDriver';
+import WebWorkerRpcDriver from './WebWorkerRpcDriver';
+import type PluginManager from '../PluginManager';
+import type { AnyConfigurationModel } from '../configuration';
 type DriverClass = WebWorkerRpcDriver | MainThreadRpcDriver;
 interface BackendConfigurations {
     WebWorkerRpcDriver?: Omit<ConstructorParameters<typeof WebWorkerRpcDriver>[0], 'config'>;

package/rpc/RpcManager.js

@@ -4,10 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../configuration");
-const configSchema_1 = __importDefault(require("./configSchema"));
-const WebWorkerRpcDriver_1 = __importDefault(require("./WebWorkerRpcDriver"));
 const MainThreadRpcDriver_1 = __importDefault(require("./MainThreadRpcDriver"));
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const WebWorkerRpcDriver_1 = __importDefault(require("./WebWorkerRpcDriver"));
+const configSchema_1 = __importDefault(require("./configSchema"));
 const DriverClasses = {
     WebWorkerRpcDriver: WebWorkerRpcDriver_1.default,
     MainThreadRpcDriver: MainThreadRpcDriver_1.default,
@@ -37,7 +36,6 @@ class RpcManager {
             this.driverObjects.set(backendName, newDriver);
             return newDriver;
         }
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         else if (backendName === 'WebWorkerRpcDriver') {
             const backendConfiguration = this.backendConfigurations.WebWorkerRpcDriver;
             if (!backendConfiguration) {

package/rpc/WebWorkerRpcDriver.d.ts

@@ -1,6 +1,7 @@
 import Rpc from 'librpc-web-mod';
-import BaseRpcDriver, { RpcDriverConstructorArgs } from './BaseRpcDriver';
-import { PluginDefinition } from '../PluginLoader';
+import BaseRpcDriver from './BaseRpcDriver';
+import type { RpcDriverConstructorArgs } from './BaseRpcDriver';
+import type { PluginDefinition } from '../PluginLoader';
 interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
     makeWorkerInstance: () => Worker;
 }

package/rpc/WebWorkerRpcDriver.js

@@ -3,11 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const serialize_error_1 = require("serialize-error");
 const librpc_web_mod_1 = __importDefault(require("librpc-web-mod"));
-// locals
-const nanoid_1 = require("../util/nanoid");
+const serialize_error_1 = require("serialize-error");
 const BaseRpcDriver_1 = __importDefault(require("./BaseRpcDriver"));
+const nanoid_1 = require("../util/nanoid");
 class WebWorkerHandle extends librpc_web_mod_1.default.Client {
     destroy() {
         this.workers[0].terminate();
@@ -32,21 +31,12 @@ class WebWorkerRpcDriver extends BaseRpcDriver_1.default {
         this.makeWorkerInstance = args.makeWorkerInstance;
     }
     async makeWorker() {
-        // note that we are making a Rpc.Client connection with a worker pool of
-        // one for each worker, because we want to do our own state-group-aware
-        // load balancing rather than using librpc's builtin round-robin
         const instance = this.makeWorkerInstance();
-        // @ts-ignore this is used to avoid warning in jbrowse-web startup
-        // (because this file is referred to via src, declare.d.ts file is in
-        // e.g. products/jbrowse-web)
         const worker = new WebWorkerHandle({ workers: [instance] });
         const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
         if (isSafari) {
-            // xref https://github.com/GMOD/jbrowse-components/issues/3245
-            // eslint-disable-next-line no-console
             console.log('console logging the webworker handle avoids the track going into an infinite loading state, this is a hacky workaround for safari', instance);
         }
-        // send the worker its boot configuration using info from the pluginManager
         return new Promise((resolve, reject) => {
             const listener = (e) => {
                 switch (e.data.message) {
@@ -66,7 +56,6 @@ class WebWorkerRpcDriver extends BaseRpcDriver_1.default {
                         reject((0, serialize_error_1.deserializeError)(e.data.error));
                         break;
                     }
-                    // No default
                 }
             };
             worker.workers[0].addEventListener('message', listener);

package/rpc/baseRpcConfig.d.ts

@@ -1,7 +1,4 @@
 declare const BaseRpcDriverConfigSchema: import("../configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     workerCount: {
         type: string;
         description: string;