@jbrowse/core 3.7.0 → 4.0.1

package/esm/pluggableElementTypes/renderers/FeatureRendererType.js

@@ -0,0 +1,77 @@
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import ServerSideRendererType from "./ServerSideRendererType.js";
+import { normalizeRegion } from "./util.js";
+import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
+import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
+import { iterMap } from "../../util/index.js";
+import SimpleFeature from "../../util/simpleFeature.js";
+export default class FeatureRendererType extends ServerSideRendererType {
+    async renderDirect(args) {
+        const result = await super.renderDirect(args);
+        return {
+            ...result,
+            blockKey: args.blockKey,
+        };
+    }
+    serializeArgsInClient(args) {
+        return super.serializeArgsInClient({
+            ...args,
+            displayModel: undefined,
+            regions: structuredClone(args.regions),
+        });
+    }
+    deserializeResultsInClient(result, args) {
+        const deserializedFeatures = new Map(result.features
+            ?.map(f => SimpleFeature.fromJSON(f))
+            .map(f => [f.id(), f]));
+        const deserialized = super.deserializeResultsInClient({
+            ...result,
+            features: deserializedFeatures,
+        }, args);
+        return {
+            ...deserialized,
+            blockKey: args.blockKey,
+            features: deserializedFeatures,
+        };
+    }
+    serializeResultsInWorker(result, args) {
+        const serialized = super.serializeResultsInWorker(result, args);
+        const { features } = result;
+        return {
+            ...serialized,
+            features: features instanceof Map
+                ? iterMap(features.values(), f => f.toJSON(), features.size)
+                : undefined,
+        };
+    }
+    getExpandedRegion(region, _renderArgs) {
+        return region;
+    }
+    async getFeatures(renderArgs) {
+        const pm = this.pluginManager;
+        const { regions, sessionId, adapterConfig } = renderArgs;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        if (!isFeatureAdapter(dataAdapter)) {
+            throw new Error('Adapter does not support retrieving features');
+        }
+        const requestRegions = regions.map(r => normalizeRegion(r));
+        const featureObservable = requestRegions.length === 1
+            ? dataAdapter.getFeatures(this.getExpandedRegion(requestRegions[0], renderArgs), renderArgs)
+            : dataAdapter.getFeaturesInMultipleRegions(requestRegions, renderArgs);
+        const feats = await firstValueFrom(featureObservable.pipe(toArray()));
+        return new Map(feats
+            .filter(feat => this.featurePassesFilters(renderArgs, feat))
+            .map(feat => [feat.id(), feat]));
+    }
+    featurePassesFilters(renderArgs, feature) {
+        return renderArgs.filters
+            ? renderArgs.filters.passes(feature, renderArgs)
+            : true;
+    }
+    async render(renderArgs) {
+        const features = await this.getFeatures(renderArgs);
+        const result = await super.render({ ...renderArgs, features });
+        return { ...result, features };
+    }
+}

package/esm/pluggableElementTypes/renderers/LayoutSession.d.ts

@@ -0,0 +1,31 @@
+import GranularRectLayout from '../../util/layouts/GranularRectLayout.ts';
+import MultiLayout from '../../util/layouts/MultiLayout.ts';
+import type SerializableFilterChain from './util/serializableFilterChain.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { Region } from '../../util/index.ts';
+import type { BaseLayout } from '../../util/layouts/index.ts';
+export interface LayoutSessionProps {
+    regions: Region[];
+    config: AnyConfigurationModel;
+    bpPerPx: number;
+    filters?: SerializableFilterChain;
+}
+export type BaseMultiLayout = MultiLayout<BaseLayout<unknown>, unknown>;
+export type MyMultiLayout = MultiLayout<GranularRectLayout<unknown>, unknown>;
+export interface CachedLayout {
+    layout: BaseMultiLayout;
+    props: LayoutSessionProps;
+}
+export interface LayoutSessionLike {
+    layout: BaseMultiLayout;
+    update(props: LayoutSessionProps): LayoutSessionLike;
+}
+export declare class LayoutSession implements LayoutSessionLike {
+    props: LayoutSessionProps;
+    cachedLayout: CachedLayout | undefined;
+    constructor(props: LayoutSessionProps);
+    update(props: LayoutSessionProps): this;
+    makeLayout(): MultiLayout<GranularRectLayout<unknown>, unknown>;
+    cachedLayoutIsValid(cachedLayout: CachedLayout): boolean;
+    get layout(): BaseMultiLayout;
+}

package/esm/pluggableElementTypes/renderers/LayoutSession.js

@@ -0,0 +1,37 @@
+import deepEqual from 'fast-deep-equal';
+import { readConfObject } from "../../configuration/index.js";
+import GranularRectLayout from "../../util/layouts/GranularRectLayout.js";
+import MultiLayout from "../../util/layouts/MultiLayout.js";
+export class LayoutSession {
+    props;
+    cachedLayout;
+    constructor(props) {
+        this.props = props;
+    }
+    update(props) {
+        this.props = props;
+        return this;
+    }
+    makeLayout() {
+        return new MultiLayout(GranularRectLayout, {
+            maxHeight: readConfObject(this.props.config, 'maxHeight'),
+            displayMode: readConfObject(this.props.config, 'displayMode'),
+            pitchX: this.props.bpPerPx,
+            pitchY: readConfObject(this.props.config, 'noSpacing') ? 1 : 3,
+        });
+    }
+    cachedLayoutIsValid(cachedLayout) {
+        return (cachedLayout.props.bpPerPx === this.props.bpPerPx &&
+            deepEqual(readConfObject(this.props.config), readConfObject(cachedLayout.props.config)) &&
+            deepEqual(this.props.filters, cachedLayout.props.filters));
+    }
+    get layout() {
+        if (!this.cachedLayout || !this.cachedLayoutIsValid(this.cachedLayout)) {
+            this.cachedLayout = {
+                layout: this.makeLayout(),
+                props: this.props,
+            };
+        }
+        return this.cachedLayout.layout;
+    }
+}

package/esm/pluggableElementTypes/renderers/RendererType.d.ts

@@ -0,0 +1,28 @@
+import type React from 'react';
+import PluggableElementBase from '../PluggableElementBase.ts';
+import type PluginManager from '../../PluginManager.ts';
+import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
+import type { AnyReactComponentType } from '../../util/index.ts';
+import type { RpcResult } from '../../util/librpc.ts';
+export type RenderProps = Record<string, unknown>;
+export interface RenderResults {
+    reactElement?: React.ReactElement;
+    html?: string;
+    [key: string]: unknown;
+}
+export type RenderReturn = RenderResults | RpcResult;
+export default class RendererType extends PluggableElementBase {
+    ReactComponent: AnyReactComponentType;
+    supportsSVG: boolean;
+    configSchema: AnyConfigurationSchemaType;
+    pluginManager: PluginManager;
+    constructor(stuff: {
+        name: string;
+        ReactComponent: AnyReactComponentType;
+        displayName?: string;
+        configSchema: AnyConfigurationSchemaType;
+        pluginManager: PluginManager;
+    });
+    render(props: RenderProps): Promise<RenderReturn>;
+    freeResources(_args: any): void;
+}

package/esm/pluggableElementTypes/renderers/RendererType.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import PluggableElementBase from "../PluggableElementBase.js";
+export default class RendererType extends PluggableElementBase {
+    ReactComponent;
+    supportsSVG = true;
+    configSchema;
+    pluginManager;
+    constructor(stuff) {
+        super(stuff);
+        this.ReactComponent = stuff.ReactComponent;
+        this.configSchema = stuff.configSchema;
+        this.pluginManager = stuff.pluginManager;
+    }
+    async render(props) {
+        return {
+            reactElement: _jsx(this.ReactComponent, { ...props }),
+        };
+    }
+    freeResources(_args) { }
+}

package/esm/pluggableElementTypes/renderers/ServerSideRendererType.d.ts

@@ -0,0 +1,57 @@
+import RendererType from './RendererType.tsx';
+import SerializableFilterChain from './util/serializableFilterChain.ts';
+import type { RenderProps, RenderResults } from './RendererType.tsx';
+import type { SerializedFilterChain } from './util/serializableFilterChain.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type RpcManager from '../../rpc/RpcManager.ts';
+import type { SnapshotIn, SnapshotOrInstance } from '@jbrowse/mobx-state-tree';
+import type { ThemeOptions } from '@mui/material';
+interface BaseRenderArgs extends RenderProps {
+    sessionId: string;
+    trackInstanceId: string;
+    stopToken?: string;
+    theme: ThemeOptions;
+    exportSVG?: {
+        rasterizeLayers?: boolean;
+    };
+}
+export interface RenderArgs extends BaseRenderArgs {
+    config: SnapshotOrInstance<AnyConfigurationModel>;
+    filters?: SerializableFilterChain;
+    renderingProps?: Record<string, unknown>;
+}
+export interface RenderArgsSerialized extends BaseRenderArgs {
+    statusCallback?: (arg: string) => void;
+    config: SnapshotIn<AnyConfigurationModel>;
+    filters?: SerializedFilterChain;
+}
+export interface RenderArgsDeserialized extends BaseRenderArgs {
+    config: AnyConfigurationModel;
+    filters?: SerializableFilterChain;
+}
+export type ResultsSerialized = Omit<RenderResults, 'reactElement'> & {
+    imageData?: ImageBitmap;
+};
+export interface ResultsSerializedSvgExport extends ResultsSerialized {
+    canvasRecordedData: unknown;
+    width: number;
+    height: number;
+    reactElement: unknown;
+}
+export type ResultsDeserialized = RenderResults;
+export default class ServerSideRenderer extends RendererType {
+    renderDirect(args: RenderArgs): Promise<RenderResults | {
+        reactElement: import("react/jsx-runtime").JSX.Element | undefined;
+        html?: string;
+    }>;
+    serializeArgsInClient(args: RenderArgs): RenderArgsSerialized;
+    deserializeResultsInClient(res: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
+    deserializeArgsInWorker(args: RenderArgsSerialized): RenderArgsDeserialized;
+    serializeResultsInWorker(results: RenderResults & {
+        imageData?: ImageBitmap;
+    }, _args: RenderArgsDeserialized): ResultsSerialized;
+    renderInClient(rpcManager: RpcManager, args: RenderArgs): Promise<ResultsSerialized>;
+    renderInWorker(args: RenderArgsSerialized): Promise<ResultsSerialized>;
+    freeResourcesInClient(rpcManager: RpcManager, args: RenderArgs): Promise<void>;
+}
+export { type RenderResults, type RenderReturn } from './RendererType.tsx';

package/esm/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import RendererType from "./RendererType.js";
+import SerializableFilterChain from "./util/serializableFilterChain.js";
+import { getSerializedSvg, updateStatus } from "../../util/index.js";
+import { isRpcResult } from "../../util/rpc.js";
+import { checkStopToken } from "../../util/stopToken.js";
+function isCanvasRecordedSvgExport(e) {
+    return 'canvasRecordedData' in e;
+}
+function hasPreRenderedContent(res) {
+    return !!res.html;
+}
+function createSvgExportElement(res, args, ReactComponent, supportsSVG) {
+    if (hasPreRenderedContent(res)) {
+        return undefined;
+    }
+    if (supportsSVG) {
+        return _jsx(ReactComponent, { ...args, ...res });
+    }
+    return (_jsx("text", { y: "12", fill: "black", children: "SVG export not supported for this track" }));
+}
+function createNormalElement(res, args, ReactComponent, renderingProps) {
+    return _jsx(ReactComponent, { ...args, ...res, ...renderingProps });
+}
+export default class ServerSideRenderer extends RendererType {
+    async renderDirect(args) {
+        const { renderingProps, ...rest } = args;
+        const config = isStateTreeNode(args.config)
+            ? args.config
+            : this.configSchema.create(args.config || {}, {
+                pluginManager: this.pluginManager,
+            });
+        const results = await this.render({
+            ...rest,
+            config,
+        });
+        if (isRpcResult(results)) {
+            const unwrapped = results.value;
+            return this.deserializeResultsInClient(unwrapped, args);
+        }
+        const { reactElement, ...resultRest } = results;
+        return {
+            ...resultRest,
+            reactElement: args.exportSVG
+                ? createSvgExportElement(resultRest, args, this.ReactComponent, this.supportsSVG)
+                : createNormalElement(resultRest, args, this.ReactComponent, renderingProps),
+        };
+    }
+    serializeArgsInClient(args) {
+        const { renderingProps, ...rest } = args;
+        return {
+            ...rest,
+            config: isStateTreeNode(args.config)
+                ? getSnapshot(args.config)
+                : args.config,
+            filters: args.filters?.toJSON().filters,
+        };
+    }
+    deserializeResultsInClient(res, args) {
+        const { renderingProps } = args;
+        return {
+            ...res,
+            reactElement: args.exportSVG
+                ? createSvgExportElement(res, args, this.ReactComponent, this.supportsSVG)
+                : createNormalElement(res, args, this.ReactComponent, renderingProps),
+        };
+    }
+    deserializeArgsInWorker(args) {
+        return {
+            ...args,
+            config: this.configSchema.create(args.config || {}, {
+                pluginManager: this.pluginManager,
+            }),
+            filters: args.filters
+                ? new SerializableFilterChain({ filters: args.filters })
+                : undefined,
+        };
+    }
+    serializeResultsInWorker(results, _args) {
+        const { reactElement, ...rest } = results;
+        return rest;
+    }
+    async renderInClient(rpcManager, args) {
+        const results = (await rpcManager.call(args.sessionId, 'CoreRender', args));
+        if (isCanvasRecordedSvgExport(results)) {
+            const { reactElement, ...rest } = results;
+            return {
+                ...rest,
+                html: await getSerializedSvg(results),
+            };
+        }
+        else {
+            return results;
+        }
+    }
+    async renderInWorker(args) {
+        const { stopToken, statusCallback = () => { } } = args;
+        const args2 = this.deserializeArgsInWorker(args);
+        const results = await updateStatus('Rendering plot', statusCallback, () => this.render(args2));
+        checkStopToken(stopToken);
+        if (isRpcResult(results)) {
+            return results;
+        }
+        return updateStatus('Serializing results', statusCallback, () => this.serializeResultsInWorker(results, args2));
+    }
+    async freeResourcesInClient(rpcManager, args) {
+        const serializedArgs = this.serializeArgsInClient(args);
+        const { sessionId } = args;
+        await rpcManager.call(sessionId, 'CoreFreeResources', serializedArgs);
+    }
+}
+export {} from "./RendererType.js";

package/esm/pluggableElementTypes/renderers/index.d.ts

@@ -0,0 +1,6 @@
+export { default as BoxRendererType } from './BoxRendererType.ts';
+export { default as CircularChordRendererType } from './CircularChordRendererType.tsx';
+export { default as RendererType } from './RendererType.tsx';
+export { default as FeatureRendererType } from './FeatureRendererType.ts';
+export { default as ServerSideRendererType } from './ServerSideRendererType.tsx';
+export { type RenderProps } from './RendererType.tsx';

package/esm/pluggableElementTypes/renderers/index.js

@@ -0,0 +1,6 @@
+export { default as BoxRendererType } from "./BoxRendererType.js";
+export { default as CircularChordRendererType } from "./CircularChordRendererType.js";
+export { default as RendererType } from "./RendererType.js";
+export { default as FeatureRendererType } from "./FeatureRendererType.js";
+export { default as ServerSideRendererType } from "./ServerSideRendererType.js";
+export {} from "./RendererType.js";

package/esm/pluggableElementTypes/renderers/util/serializableFilterChain.js

@@ -0,0 +1,30 @@
+import { stringToJexlExpression } from "../../../util/jexlStrings.js";
+export default class SerializableFilterChain {
+    filterChain;
+    constructor({ filters }) {
+        this.filterChain = filters
+            .map(f => f.trim())
+            .filter(f => !!f)
+            .map(inputFilter => {
+            if (typeof inputFilter === 'string') {
+                const expr = stringToJexlExpression(inputFilter);
+                return { expr, string: inputFilter };
+            }
+            throw new Error(`invalid inputFilter string "${inputFilter}"`);
+        });
+    }
+    passes(...args) {
+        for (const entry of this.filterChain) {
+            if (!entry.expr.eval({ feature: args[0] })) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toJSON() {
+        return { filters: this.filterChain.map(f => f.string) };
+    }
+    static fromJSON(json) {
+        return new SerializableFilterChain(json);
+    }
+}

package/esm/pluggableElementTypes/renderers/util.d.ts

@@ -0,0 +1,3 @@
+import type { Region } from '../../util/index.ts';
+export declare function normalizeRegion(region: Region): Region;
+export declare function expandRegion(region: Region, bpExpansion: number): Region;

package/esm/pluggableElementTypes/renderers/util.js

@@ -0,0 +1,14 @@
+export function normalizeRegion(region) {
+    return {
+        ...region,
+        start: Math.floor(region.start),
+        end: Math.ceil(region.end),
+    };
+}
+export function expandRegion(region, bpExpansion) {
+    return {
+        ...region,
+        start: Math.floor(Math.max(region.start - bpExpansion, 0)),
+        end: Math.ceil(region.end + bpExpansion),
+    };
+}

package/esm/rpc/BaseRpcDriver.d.ts

@@ -0,0 +1,40 @@
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+export interface WorkerHandle {
+    status?: string;
+    error?: unknown;
+    on?: (channel: string, callback: (message: unknown) => void) => void;
+    off?: (channel: string, callback: (message: unknown) => void) => void;
+    destroy(): void;
+    call(functionName: string, args?: unknown, options?: {
+        statusCallback?(message: string): void;
+        rpcDriverClassName: string;
+    }): Promise<unknown>;
+}
+export interface RpcDriverConstructorArgs {
+    config: AnyConfigurationModel;
+}
+declare class LazyWorker {
+    driver: BaseRpcDriver;
+    workerP?: Promise<WorkerHandle> | undefined;
+    constructor(driver: BaseRpcDriver);
+    getWorker(): Promise<WorkerHandle>;
+}
+export default abstract class BaseRpcDriver {
+    abstract name: string;
+    private lastWorkerAssignment;
+    private workerAssignments;
+    abstract makeWorker(): Promise<WorkerHandle>;
+    private workerPool?;
+    config: AnyConfigurationModel;
+    constructor(args: RpcDriverConstructorArgs);
+    filterArgs<THING_TYPE>(thing: THING_TYPE, sessionId: string): THING_TYPE;
+    remoteAbort(sessionId: string, functionName: string, stopTokenId: number): Promise<void>;
+    createWorkerPool(): LazyWorker[];
+    getWorkerPool(): LazyWorker[];
+    getWorker(sessionId: string): Promise<WorkerHandle>;
+    call(pluginManager: PluginManager, sessionId: string, functionName: string, args: {
+        statusCallback?: (message: unknown) => void;
+    }, options?: {}): Promise<unknown>;
+}
+export {};

package/esm/rpc/BaseRpcDriver.js

@@ -0,0 +1,116 @@
+import { isAlive, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { readConfObject } from "../configuration/index.js";
+import { clamp } from "../util/index.js";
+function isCloneable(thing) {
+    return !(typeof thing === 'function') && !(thing instanceof Error);
+}
+function detectHardwareConcurrency() {
+    const mainThread = typeof window !== 'undefined';
+    const canDetect = mainThread && 'hardwareConcurrency' in window.navigator;
+    return mainThread && canDetect ? window.navigator.hardwareConcurrency : 1;
+}
+class LazyWorker {
+    driver;
+    workerP;
+    constructor(driver) {
+        this.driver = driver;
+    }
+    async getWorker() {
+        if (!this.workerP) {
+            this.workerP = this.driver.makeWorker().catch((e) => {
+                this.workerP = undefined;
+                throw e;
+            });
+        }
+        return this.workerP;
+    }
+}
+export default class BaseRpcDriver {
+    lastWorkerAssignment = -1;
+    workerAssignments = new Map();
+    workerPool;
+    config;
+    constructor(args) {
+        this.config = args.config;
+    }
+    filterArgs(thing, sessionId) {
+        if (thing === null || thing === undefined) {
+            return thing;
+        }
+        const type = typeof thing;
+        if (type === 'string' || type === 'number' || type === 'boolean') {
+            return thing;
+        }
+        if (type !== 'object') {
+            return undefined;
+        }
+        if (Array.isArray(thing)) {
+            return thing
+                .filter(thing => isCloneable(thing))
+                .map(t => this.filterArgs(t, sessionId));
+        }
+        else if (isStateTreeNode(thing) && !isAlive(thing)) {
+            throw new Error('dead state tree node passed to RPC call');
+        }
+        else if (thing instanceof File) {
+            return thing;
+        }
+        else {
+            return Object.fromEntries(Object.entries(thing)
+                .filter(e => isCloneable(e[1]))
+                .map(([k, v]) => [k, this.filterArgs(v, sessionId)]));
+        }
+    }
+    async remoteAbort(sessionId, functionName, stopTokenId) {
+        const worker = await this.getWorker(sessionId);
+        await worker.call(functionName, { stopTokenId }, { rpcDriverClassName: this.name });
+    }
+    createWorkerPool() {
+        const hardwareConcurrency = detectHardwareConcurrency();
+        const workerCount = readConfObject(this.config, 'workerCount') ||
+            clamp(1, Math.max(1, hardwareConcurrency - 1), 5);
+        const workers = [];
+        for (let i = 0; i < workerCount; i++) {
+            workers.push(new LazyWorker(this));
+        }
+        return workers;
+    }
+    getWorkerPool() {
+        if (!this.workerPool) {
+            const res = this.createWorkerPool();
+            this.workerPool = res;
+            return res;
+        }
+        return this.workerPool;
+    }
+    async getWorker(sessionId) {
+        const workers = this.getWorkerPool();
+        let workerNumber = this.workerAssignments.get(sessionId);
+        if (workerNumber === undefined) {
+            const workerAssignment = (this.lastWorkerAssignment + 1) % workers.length;
+            this.workerAssignments.set(sessionId, workerAssignment);
+            this.lastWorkerAssignment = workerAssignment;
+            workerNumber = workerAssignment;
+        }
+        return workers[workerNumber].getWorker();
+    }
+    async call(pluginManager, sessionId, functionName, args, options = {}) {
+        if (!sessionId) {
+            throw new TypeError('sessionId is required');
+        }
+        const unextendedWorker = await this.getWorker(sessionId);
+        const worker = pluginManager.evaluateExtensionPoint('Core-extendWorker', unextendedWorker);
+        const rpcMethod = pluginManager.getRpcMethodType(functionName);
+        if (!rpcMethod) {
+            throw new Error(`unknown RPC method ${functionName}`);
+        }
+        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
+        const filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId);
+        const call = await worker.call(functionName, filteredAndSerializedArgs, {
+            statusCallback: args.statusCallback,
+            rpcDriverClassName: this.name,
+            ...options,
+        });
+        return rpcMethod.deserializeReturn(call, args, this.name);
+    }
+}

package/esm/rpc/MainThreadRpcDriver.d.ts

@@ -0,0 +1,14 @@
+import BaseRpcDriver from './BaseRpcDriver.ts';
+import type { RpcDriverConstructorArgs } from './BaseRpcDriver.ts';
+import type PluginManager from '../PluginManager.ts';
+declare class DummyHandle {
+    destroy(): void;
+    call(_functionName: string, _filteredArgs?: Record<string, unknown>, _options?: {}): Promise<unknown>;
+}
+export default class MainThreadRpcDriver extends BaseRpcDriver {
+    name: string;
+    makeWorker: () => Promise<DummyHandle>;
+    constructor(args: RpcDriverConstructorArgs);
+    call(pm: PluginManager, sessionId: string, funcName: string, args: Record<string, unknown>): Promise<unknown>;
+}
+export {};

package/esm/rpc/MainThreadRpcDriver.js

@@ -0,0 +1,33 @@
+import BaseRpcDriver from "./BaseRpcDriver.js";
+class DummyHandle {
+    destroy() { }
+    async call(_functionName, _filteredArgs, _options = {}) {
+        return undefined;
+    }
+}
+export default class MainThreadRpcDriver extends BaseRpcDriver {
+    name = 'MainThreadRpcDriver';
+    makeWorker;
+    constructor(args) {
+        super(args);
+        this.makeWorker = async () => new DummyHandle();
+    }
+    async call(pm, sessionId, funcName, args) {
+        if (!sessionId) {
+            throw new TypeError('sessionId is required');
+        }
+        const rpcMethod = pm.getRpcMethodType(funcName);
+        if (!rpcMethod) {
+            throw new Error(`unknown RPC method ${funcName}`);
+        }
+        if (rpcMethod.supportsDirectExecution()) {
+            const result = await rpcMethod.executeDirect(args);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
+        const result = await rpcMethod.execute(serializedArgs, this.name);
+        return rpcMethod.deserializeReturn(result, args, this.name);
+    }
+}