@jbrowse/core 3.6.5 → 4.0.0

package/pluggableElementTypes/renderers/FeatureRendererType.js

@@ -1,85 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererType"));
-const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
-const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
-const util_1 = require("../../util");
-const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
-const stopToken_1 = require("../../util/stopToken");
-class FeatureRendererType extends ServerSideRendererType_1.default {
-    serializeArgsInClient(args) {
-        return super.serializeArgsInClient({
-            ...args,
-            displayModel: undefined,
-            regions: structuredClone(args.regions),
-        });
-    }
-    deserializeResultsInClient(result, args) {
-        const deserializedFeatures = new Map(result.features.map(f => simpleFeature_1.default.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: (0, util_1.iterMap)(features.values(), f => f.toJSON(), features.size),
-        };
-    }
-    getExpandedRegion(region, _renderArgs) {
-        return region;
-    }
-    async getFeatures(renderArgs) {
-        const pm = this.pluginManager;
-        const { stopToken, regions, sessionId, adapterConfig } = renderArgs;
-        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
-        if (!(0, BaseAdapter_1.isFeatureAdapter)(dataAdapter)) {
-            throw new Error('Adapter does not support retrieving features');
-        }
-        (0, stopToken_1.checkStopToken)(stopToken);
-        const requestRegions = regions.map(r => ({
-            ...r,
-            start: Math.floor(r.start),
-            end: Math.ceil(r.end),
-        }));
-        const region = requestRegions[0];
-        const featureObservable = requestRegions.length === 1
-            ? dataAdapter.getFeatures(this.getExpandedRegion(region, renderArgs), renderArgs)
-            : dataAdapter.getFeaturesInMultipleRegions(requestRegions, renderArgs);
-        const feats = await (0, rxjs_1.firstValueFrom)(featureObservable.pipe((0, operators_1.toArray)()));
-        (0, stopToken_1.checkStopToken)(stopToken);
-        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(props) {
-        const features = props.features || (await this.getFeatures(props));
-        const result = await super.render({
-            ...props,
-            features,
-        });
-        return {
-            ...result,
-            features,
-        };
-    }
-}
-exports.default = FeatureRendererType;

package/pluggableElementTypes/renderers/LayoutSession.d.ts

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

package/pluggableElementTypes/renderers/LayoutSession.js

@@ -1,42 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutSession = void 0;
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const configuration_1 = require("../../configuration");
-const GranularRectLayout_1 = __importDefault(require("../../util/layouts/GranularRectLayout"));
-const MultiLayout_1 = __importDefault(require("../../util/layouts/MultiLayout"));
-class LayoutSession {
-    constructor(props) {
-        this.props = props;
-    }
-    update(props) {
-        this.props = props;
-        return this;
-    }
-    makeLayout() {
-        return new MultiLayout_1.default(GranularRectLayout_1.default, {
-            maxHeight: (0, configuration_1.readConfObject)(this.props.config, 'maxHeight'),
-            displayMode: (0, configuration_1.readConfObject)(this.props.config, 'displayMode'),
-            pitchX: this.props.bpPerPx,
-            pitchY: (0, configuration_1.readConfObject)(this.props.config, 'noSpacing') ? 1 : 3,
-        });
-    }
-    cachedLayoutIsValid(cachedLayout) {
-        return (cachedLayout.props.bpPerPx === this.props.bpPerPx &&
-            (0, fast_deep_equal_1.default)((0, configuration_1.readConfObject)(this.props.config), (0, configuration_1.readConfObject)(cachedLayout.props.config)) &&
-            (0, fast_deep_equal_1.default)(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;
-    }
-}
-exports.LayoutSession = LayoutSession;

package/pluggableElementTypes/renderers/RendererType.d.ts

@@ -1,25 +0,0 @@
-import type React from 'react';
-import PluggableElementBase from '../PluggableElementBase';
-import type PluginManager from '../../PluginManager';
-import type { AnyConfigurationSchemaType } from '../../configuration';
-import type { AnyReactComponentType } from '../../util';
-export type RenderProps = Record<string, unknown>;
-export interface RenderResults {
-    reactElement?: React.ReactElement;
-    html?: string;
-}
-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<RenderResults>;
-    freeResources(_args: any): void;
-}

package/pluggableElementTypes/renderers/RendererType.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const PluggableElementBase_1 = __importDefault(require("../PluggableElementBase"));
-class RendererType extends PluggableElementBase_1.default {
-    constructor(stuff) {
-        super(stuff);
-        this.supportsSVG = true;
-        this.ReactComponent = stuff.ReactComponent;
-        this.configSchema = stuff.configSchema;
-        this.pluginManager = stuff.pluginManager;
-    }
-    async render(props) {
-        return {
-            reactElement: (0, jsx_runtime_1.jsx)(this.ReactComponent, { ...props }),
-        };
-    }
-    freeResources(_args) { }
-}
-exports.default = RendererType;

package/pluggableElementTypes/renderers/RpcRenderedSvgGroup.d.ts

@@ -1,9 +0,0 @@
-import type { AnyReactComponentType, Feature } from '../../util';
-import type { ThemeOptions } from '@mui/material';
-declare const RpcRenderedSvgGroup: (props: {
-    html: string;
-    features: Map<string, Feature>;
-    theme: ThemeOptions;
-    RenderingComponent: AnyReactComponentType;
-}) => import("react/jsx-runtime").JSX.Element;
-export default RpcRenderedSvgGroup;

package/pluggableElementTypes/renderers/RpcRenderedSvgGroup.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const mobx_react_1 = require("mobx-react");
-const RpcRenderedSvgGroup = (0, mobx_react_1.observer)(function RpcRenderedSvgGroup(props) {
-    const { html, RenderingComponent, ...rest } = props;
-    return (0, jsx_runtime_1.jsx)(RenderingComponent, { ...rest });
-});
-exports.default = RpcRenderedSvgGroup;

package/pluggableElementTypes/renderers/ServerSideRenderedContent.d.ts

@@ -1,6 +0,0 @@
-import type { RenderArgs, ResultsSerialized } from './ServerSideRendererType';
-interface Props extends ResultsSerialized, RenderArgs {
-    RenderingComponent: React.ComponentType<any>;
-}
-declare const ServerSideRenderedContent: ({ html, RenderingComponent, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
-export default ServerSideRenderedContent;

package/pluggableElementTypes/renderers/ServerSideRenderedContent.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const mobx_react_1 = require("mobx-react");
-const ServerSideRenderedContent = (0, mobx_react_1.observer)(function ServerSideRenderedContent({ html, RenderingComponent, ...props }) {
-    return (0, jsx_runtime_1.jsx)(RenderingComponent, { ...props });
-});
-exports.default = ServerSideRenderedContent;

package/pluggableElementTypes/renderers/ServerSideRendererType.d.ts

@@ -1,49 +0,0 @@
-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;
-    stopToken?: string;
-    theme: ThemeOptions;
-    exportSVG?: {
-        rasterizeLayers?: boolean;
-    };
-}
-export interface RenderArgs extends BaseRenderArgs {
-    config: SnapshotOrInstance<AnyConfigurationModel>;
-    filters?: SerializableFilterChain;
-}
-export interface RenderArgsSerialized extends BaseRenderArgs {
-    statusCallback?: (arg: string) => void;
-    config: SnapshotIn<AnyConfigurationModel>;
-    filters?: SerializedFilterChain;
-}
-export interface RenderArgsDeserialized extends BaseRenderArgs {
-    config: AnyConfigurationModel;
-    filters?: SerializableFilterChain;
-}
-export interface ResultsSerialized extends Omit<RenderResults, 'reactElement'> {
-    html: string;
-}
-export interface ResultsSerializedSvgExport extends ResultsSerialized {
-    canvasRecordedData: unknown;
-    width: number;
-    height: number;
-    reactElement: unknown;
-}
-export type ResultsDeserialized = RenderResults;
-export default class ServerSideRenderer extends RendererType {
-    serializeArgsInClient(args: RenderArgs): RenderArgsSerialized;
-    deserializeResultsInClient(res: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    deserializeArgsInWorker(args: RenderArgsSerialized): RenderArgsDeserialized;
-    serializeResultsInWorker(results: RenderResults, 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 } from './RendererType';

package/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const styles_1 = require("@mui/material/styles");
-const mobx_state_tree_1 = require("mobx-state-tree");
-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 {
-    serializeArgsInClient(args) {
-        var _a;
-        return {
-            ...args,
-            config: (0, mobx_state_tree_1.isStateTreeNode)(args.config)
-                ? (0, mobx_state_tree_1.getSnapshot)(args.config)
-                : args.config,
-            filters: (_a = args.filters) === null || _a === void 0 ? void 0 : _a.toJSON().filters,
-        };
-    }
-    deserializeResultsInClient(res, args) {
-        return args.exportSVG
-            ? {
-                ...res,
-                html: this.supportsSVG
-                    ? res.html
-                    : '<text y="12" fill="black">SVG export not supported for this track</text>',
-            }
-            : {
-                ...res,
-                reactElement: ((0, jsx_runtime_1.jsx)(ServerSideRenderedContent_1.default, { ...args, ...res, RenderingComponent: this.ReactComponent })),
-            };
-    }
-    deserializeArgsInWorker(args) {
-        const deserialized = { ...args };
-        deserialized.config = this.configSchema.create(args.config || {}, {
-            pluginManager: this.pluginManager,
-        });
-        deserialized.filters = args.filters
-            ? new serializableFilterChain_1.default({
-                filters: args.filters,
-            })
-            : undefined;
-        return deserialized;
-    }
-    serializeResultsInWorker(results, args) {
-        const html = (0, server_1.renderToString)((0, jsx_runtime_1.jsx)(styles_1.ThemeProvider, { theme: (0, ui_1.createJBrowseTheme)(args.theme), children: results.reactElement }));
-        results.reactElement = undefined;
-        return { ...results, html };
-    }
-    async renderInClient(rpcManager, args) {
-        const results = (await rpcManager.call(args.sessionId, 'CoreRender', args));
-        if (isSvgExport(results)) {
-            results.html = await (0, util_1.getSerializedSvg)(results);
-            results.reactElement = undefined;
-        }
-        return results;
-    }
-    async renderInWorker(args) {
-        const { stopToken, statusCallback = () => { } } = args;
-        const deserializedArgs = this.deserializeArgsInWorker(args);
-        const results = await (0, util_1.updateStatus)('Rendering plot', statusCallback, () => this.render(deserializedArgs));
-        (0, stopToken_1.checkStopToken)(stopToken);
-        return (0, util_1.updateStatus)('Serializing results', statusCallback, () => this.serializeResultsInWorker(results, deserializedArgs));
-    }
-    async freeResourcesInClient(rpcManager, args) {
-        const serializedArgs = this.serializeArgsInClient(args);
-        const { sessionId } = args;
-        await rpcManager.call(sessionId, 'CoreFreeResources', serializedArgs);
-    }
-}
-exports.default = ServerSideRenderer;

package/pluggableElementTypes/renderers/index.d.ts

@@ -1,7 +0,0 @@
-export { default as BoxRendererType } from './BoxRendererType';
-export { default as ComparativeServerSideRendererType } from './ComparativeServerSideRendererType';
-export { default as CircularChordRendererType } from './CircularChordRendererType';
-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/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerSideRendererType = exports.ServerSideRenderedContent = exports.FeatureRendererType = exports.RendererType = exports.CircularChordRendererType = exports.ComparativeServerSideRendererType = exports.BoxRendererType = void 0;
-var BoxRendererType_1 = require("./BoxRendererType");
-Object.defineProperty(exports, "BoxRendererType", { enumerable: true, get: function () { return __importDefault(BoxRendererType_1).default; } });
-var ComparativeServerSideRendererType_1 = require("./ComparativeServerSideRendererType");
-Object.defineProperty(exports, "ComparativeServerSideRendererType", { enumerable: true, get: function () { return __importDefault(ComparativeServerSideRendererType_1).default; } });
-var CircularChordRendererType_1 = require("./CircularChordRendererType");
-Object.defineProperty(exports, "CircularChordRendererType", { enumerable: true, get: function () { return __importDefault(CircularChordRendererType_1).default; } });
-var RendererType_1 = require("./RendererType");
-Object.defineProperty(exports, "RendererType", { enumerable: true, get: function () { return __importDefault(RendererType_1).default; } });
-var FeatureRendererType_1 = require("./FeatureRendererType");
-Object.defineProperty(exports, "FeatureRendererType", { enumerable: true, get: function () { return __importDefault(FeatureRendererType_1).default; } });
-var ServerSideRenderedContent_1 = require("./ServerSideRenderedContent");
-Object.defineProperty(exports, "ServerSideRenderedContent", { enumerable: true, get: function () { return __importDefault(ServerSideRenderedContent_1).default; } });
-var ServerSideRendererType_1 = require("./ServerSideRendererType");
-Object.defineProperty(exports, "ServerSideRendererType", { enumerable: true, get: function () { return __importDefault(ServerSideRendererType_1).default; } });

package/pluggableElementTypes/renderers/util/serializableFilterChain.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jexlStrings_1 = require("../../../util/jexlStrings");
-class SerializableFilterChain {
-    constructor({ filters = [] }) {
-        this.filterChain = filters
-            .map(f => f.trim())
-            .filter(f => !!f)
-            .map(inputFilter => {
-            if (typeof inputFilter === 'string') {
-                const expr = (0, jexlStrings_1.stringToJexlExpression)(inputFilter);
-                return { expr, string: inputFilter };
-            }
-            throw new Error(`invalid inputFilter string "${inputFilter}"`);
-        });
-    }
-    passes(...args) {
-        for (const entry of this.filterChain) {
-            if (!entry.expr.evalSync({ feature: args[0] })) {
-                return false;
-            }
-        }
-        return true;
-    }
-    toJSON() {
-        return { filters: this.filterChain.map(f => f.string) };
-    }
-    static fromJSON(json) {
-        return new SerializableFilterChain(json);
-    }
-}
-exports.default = SerializableFilterChain;

package/rpc/BaseRpcDriver.d.ts

@@ -1,43 +0,0 @@
-import type PluginManager from '../PluginManager';
-import type { AnyConfigurationModel } from '../configuration';
-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;
-        timeout?: number;
-        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?;
-    maxPingTime: number;
-    workerCheckFrequency: number;
-    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/rpc/BaseRpcDriver.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("../configuration");
-const util_1 = require("../util");
-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 {
-    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;
-    }
-}
-class BaseRpcDriver {
-    constructor(args) {
-        this.lastWorkerAssignment = -1;
-        this.workerAssignments = new Map();
-        this.maxPingTime = 30000;
-        this.workerCheckFrequency = 5000;
-        this.config = args.config;
-    }
-    filterArgs(thing, sessionId) {
-        if (Array.isArray(thing)) {
-            return thing
-                .filter(thing => isCloneable(thing))
-                .map(t => this.filterArgs(t, 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');
-            }
-            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)]));
-            }
-        }
-        else {
-            return thing;
-        }
-    }
-    async remoteAbort(sessionId, functionName, stopTokenId) {
-        const worker = await this.getWorker(sessionId);
-        await worker.call(functionName, { stopTokenId }, { timeout: 1000000, rpcDriverClassName: this.name });
-    }
-    createWorkerPool() {
-        const hardwareConcurrency = detectHardwareConcurrency();
-        const workerCount = (0, configuration_1.readConfObject)(this.config, 'workerCount') ||
-            (0, util_1.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, {
-            timeout: 5 * 60 * 1000,
-            statusCallback: args.statusCallback,
-            rpcDriverClassName: this.name,
-            ...options,
-        });
-        return rpcMethod.deserializeReturn(call, args, this.name);
-    }
-}
-exports.default = BaseRpcDriver;

package/rpc/MainThreadRpcDriver.d.ts

@@ -1,14 +0,0 @@
-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>;
-}
-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/rpc/MainThreadRpcDriver.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseRpcDriver_1 = __importDefault(require("./BaseRpcDriver"));
-class DummyHandle {
-    destroy() { }
-    async call(_functionName, _filteredArgs, _options = {}) {
-        return undefined;
-    }
-}
-class MainThreadRpcDriver extends BaseRpcDriver_1.default {
-    constructor(args) {
-        super(args);
-        this.name = 'MainThreadRpcDriver';
-        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}`);
-        }
-        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
-        const result = await rpcMethod.execute(serializedArgs, this.name);
-        return rpcMethod.deserializeReturn(result, args, this.name);
-    }
-}
-exports.default = MainThreadRpcDriver;