@jbrowse/core 4.3.0 → 5.0.0-beta.2

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

@@ -1,58 +0,0 @@
-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 { LastStopTokenCheck } from '../../util/stopToken.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;
-    stopTokenCheck?: LastStopTokenCheck;
-}
-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 {
-    private createReactElement;
-    renderDirect(args: RenderArgs): Promise<RenderResults | {
-        reactElement: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
-        html?: string;
-    }>;
-    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, type RenderReturn } from './RendererType.tsx';

package/esm/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -1,108 +0,0 @@
-import { createElement } from 'react';
-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 { checkStopToken2, createStopTokenChecker, } from "../../util/stopToken.js";
-function isCanvasRecordedSvgExport(e) {
-    return 'canvasRecordedData' in e;
-}
-export default class ServerSideRenderer extends RendererType {
-    createReactElement(res, args) {
-        if (args.exportSVG) {
-            if (res.html) {
-                return undefined;
-            }
-            if (this.supportsSVG) {
-                return createElement(this.ReactComponent, { ...args, ...res });
-            }
-            return createElement('text', { y: '12', fill: 'black' }, 'SVG export not supported for this track');
-        }
-        return createElement(this.ReactComponent, {
-            ...args,
-            ...res,
-            ...args.renderingProps,
-        });
-    }
-    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)) {
-            return this.deserializeResultsInClient(results.value, args);
-        }
-        const { reactElement, ...resultRest } = results;
-        return {
-            ...resultRest,
-            reactElement: this.createReactElement(resultRest, args),
-        };
-    }
-    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) {
-        return {
-            ...res,
-            reactElement: this.createReactElement(res, args),
-        };
-    }
-    deserializeArgsInWorker(args) {
-        return {
-            ...args,
-            config: this.configSchema.create(args.config || {}, {
-                pluginManager: this.pluginManager,
-            }),
-            filters: args.filters
-                ? new SerializableFilterChain({
-                    filters: args.filters,
-                    jexl: this.pluginManager.jexl,
-                })
-                : 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) };
-        }
-        return results;
-    }
-    async renderInWorker(args) {
-        const { stopToken, statusCallback = () => { } } = args;
-        const stopTokenCheck = createStopTokenChecker(stopToken);
-        const deserializedArgs = {
-            ...this.deserializeArgsInWorker(args),
-            stopTokenCheck,
-        };
-        const results = await updateStatus('Rendering plot', statusCallback, () => this.render(deserializedArgs));
-        checkStopToken2(stopTokenCheck);
-        if (isRpcResult(results)) {
-            return results;
-        }
-        return updateStatus('Serializing results', statusCallback, () => this.serializeResultsInWorker(results, deserializedArgs));
-    }
-    async freeResourcesInClient(rpcManager, args) {
-        await rpcManager.call(args.sessionId, 'CoreFreeResources', this.serializeArgsInClient(args));
-    }
-}
-export {} from "./RendererType.js";

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

@@ -1,6 +0,0 @@
-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.ts';
-export { type RenderProps } from './RendererType.tsx';

package/esm/pluggableElementTypes/renderers/index.js

@@ -1,6 +0,0 @@
-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.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/baseRpcConfig.d.ts

@@ -1,8 +0,0 @@
-declare const BaseRpcDriverConfigSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    workerCount: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-export default BaseRpcDriverConfigSchema;

package/esm/rpc/baseRpcConfig.js

@@ -1,10 +0,0 @@
-import { ConfigurationSchema } from "../configuration/index.js";
-function x() { }
-const BaseRpcDriverConfigSchema = ConfigurationSchema('BaseRpcDriver', {
-    workerCount: {
-        type: 'number',
-        description: 'The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.',
-        defaultValue: 0,
-    },
-}, { explicitlyTyped: true });
-export default BaseRpcDriverConfigSchema;

package/esm/rpc/mainThreadRpcConfig.d.ts

@@ -1,8 +0,0 @@
-declare const MainThreadRpcDriverConfigSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    workerCount: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>, undefined>>;
-export default MainThreadRpcDriverConfigSchema;

package/esm/rpc/mainThreadRpcConfig.js

@@ -1,8 +0,0 @@
-import BaseRpcDriverConfigSchema from "./baseRpcConfig.js";
-import { ConfigurationSchema } from "../configuration/index.js";
-function x() { }
-const MainThreadRpcDriverConfigSchema = ConfigurationSchema('MainThreadRpcDriver', {}, {
-    baseConfiguration: BaseRpcDriverConfigSchema,
-    explicitlyTyped: true,
-});
-export default MainThreadRpcDriverConfigSchema;

package/esm/rpc/methods/CoreGetFeatureDensityStats.d.ts

@@ -1,17 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RenderArgs } from './util.ts';
-import type { Region } from '../../util/index.ts';
-export default class CoreGetFeatureDensityStats extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs & {
-        stopToken?: string;
-        statusCallback?: (arg: string) => void;
-    }, rpcDriver: string): Promise<Record<string, unknown>>;
-    execute(args: {
-        adapterConfig: Record<string, unknown>;
-        regions: Region[];
-        stopToken?: string;
-        headers?: Record<string, string>;
-        sessionId: string;
-    }, rpcDriver: string): Promise<import("../../data_adapters/BaseAdapter/types.ts").FeatureDensityStats>;
-}

package/esm/rpc/methods/CoreGetFeatureDensityStats.js

@@ -1,25 +0,0 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-export default class CoreGetFeatureDensityStats extends RpcMethodType {
-    name = 'CoreGetFeatureDensityStats';
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, {
-            ...args,
-            filters: args.filters?.toJSON().filters,
-        });
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { adapterConfig, sessionId, regions } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
-        if (!isFeatureAdapter(dataAdapter)) {
-            throw new Error('Adapter does not support retrieving features');
-        }
-        return dataAdapter.getMultiRegionFeatureDensityStats(regions, deserializedArgs);
-    }
-}

package/esm/rpc/methods/CoreGetFeatureDetails.d.ts

@@ -1,11 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RenderArgs, RenderArgsSerialized } from './util.ts';
-export default class CoreGetFeatureDetails extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<any>;
-    execute(args: RenderArgsSerialized & {
-        stopToken?: string;
-    }, rpcDriver: string): Promise<{
-        feature: any;
-    }>;
-}

package/esm/rpc/methods/CoreGetFeatureDetails.js

@@ -1,24 +0,0 @@
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-export default class CoreGetFeatureDetails extends RpcMethodType {
-    name = 'CoreGetFeatureDetails';
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
-        const { rendererType } = args;
-        const RendererType = this.pluginManager.getRendererType(rendererType);
-        return RendererType.serializeArgsInClient(superArgs);
-    }
-    async execute(args, rpcDriver) {
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { rendererType, featureId } = deserializedArgs;
-        const RendererType = this.pluginManager.getRendererType(rendererType);
-        return {
-            feature: RendererType.getLayoutSession(args)
-                ?.cachedLayout.layout.getDataByID(featureId)
-                ?.toJSON(),
-        };
-    }
-}

package/esm/rpc/methods/CoreGetFileInfo.d.ts

@@ -1,9 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetFileInfo extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        stopToken?: string;
-        adapterConfig: Record<string, unknown>;
-    }, rpcDriver: string): Promise<unknown>;
-}

package/esm/rpc/methods/CoreGetFileInfo.js

@@ -1,15 +0,0 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-export default class CoreGetFileInfo extends RpcMethodType {
-    name = 'CoreGetInfo';
-    async execute(args, rpcDriver) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        return isFeatureAdapter(dataAdapter)
-            ? dataAdapter.getHeader(deserializedArgs)
-            : null;
-    }
-}

package/esm/rpc/methods/CoreRender.d.ts

@@ -1,14 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RenderArgs, RenderArgsSerialized, RenderResults, ResultsSerialized } from './util.ts';
-export default class CoreRender extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("../../pluggableElementTypes/renderers/ServerSideRendererType.ts").RenderArgsSerialized>;
-    executeDirect(args: RenderArgs): Promise<RenderResults | {
-        reactElement: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
-        html?: string;
-    }>;
-    execute(args: RenderArgsSerialized & {
-        stopToken?: string;
-    }, rpcDriver: string): Promise<ResultsSerialized>;
-    deserializeReturn(serializedReturn: RenderResults | ResultsSerialized, args: RenderArgs, rpcDriver: string): Promise<unknown>;
-}

package/esm/rpc/methods/CoreRender.js

@@ -1,40 +0,0 @@
-import { validateRendererType } from "./util.js";
-import RpcMethodType, { convertFileHandleLocations, } from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-import { getBlobMap, setBlobMap } from "../../util/tracks.js";
-export default class CoreRender extends RpcMethodType {
-    name = 'CoreRender';
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
-        return validateRendererType(args.rendererType, this.pluginManager.getRendererType(args.rendererType)).serializeArgsInClient(superArgs);
-    }
-    async executeDirect(args) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        const { sessionId, rendererType } = renamedArgs;
-        if (!sessionId) {
-            throw new Error('must pass a unique session id');
-        }
-        const { renderingProps, ...rest } = renamedArgs;
-        const blobMap = getBlobMap();
-        convertFileHandleLocations(rest, blobMap);
-        setBlobMap(blobMap);
-        return validateRendererType(rendererType, this.pluginManager.getRendererType(rendererType)).renderDirect({ ...rest, renderingProps });
-    }
-    async execute(args, rpcDriver) {
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, rendererType } = deserializedArgs;
-        if (!sessionId) {
-            throw new Error('must pass a unique session id');
-        }
-        return validateRendererType(rendererType, this.pluginManager.getRendererType(rendererType)).renderInWorker(deserializedArgs);
-    }
-    async deserializeReturn(serializedReturn, args, rpcDriver) {
-        const des = await super.deserializeReturn(serializedReturn, args, rpcDriver);
-        return validateRendererType(args.rendererType, this.pluginManager.getRendererType(args.rendererType)).deserializeResultsInClient(des, args);
-    }
-}

package/esm/rpc/methods/CoreSaveFeatureData.d.ts

@@ -1,16 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import SimpleFeature from '../../util/simpleFeature.ts';
-import type { RenderArgs } from './util.ts';
-import type { Region } from '../../util/index.ts';
-import type { SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
-export default class CoreGetFeatures extends RpcMethodType {
-    name: string;
-    deserializeReturn(feats: SimpleFeatureSerialized[], args: unknown, rpcDriver: string): Promise<SimpleFeature[]>;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
-    execute(args: {
-        sessionId: string;
-        regions: Region[];
-        adapterConfig: Record<string, unknown>;
-        opts?: any;
-    }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;
-}

package/esm/rpc/methods/CoreSaveFeatureData.js

@@ -1,32 +0,0 @@
-import { firstValueFrom } from 'rxjs';
-import { toArray } from 'rxjs/operators';
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-import SimpleFeature from "../../util/simpleFeature.js";
-export default class CoreGetFeatures extends RpcMethodType {
-    name = 'CoreGetFeatures';
-    async deserializeReturn(feats, args, rpcDriver) {
-        const superDeserialized = (await super.deserializeReturn(feats, args, rpcDriver));
-        return superDeserialized.map(feat => new SimpleFeature(feat));
-    }
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig, regions, opts } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        if (!isFeatureAdapter(dataAdapter)) {
-            throw new Error('Adapter does not support retrieving features');
-        }
-        const ret = dataAdapter.getFeaturesInMultipleRegions(regions, opts);
-        const r = await firstValueFrom(ret.pipe(toArray()));
-        return r.map(f => f.toJSON());
-    }
-}

package/esm/rpc/methods/util.d.ts

@@ -1,15 +0,0 @@
-import type { ServerSideRendererType } from '../../pluggableElementTypes/index.ts';
-import type { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized } from '../../pluggableElementTypes/renderers/ServerSideRendererType.ts';
-import type { Region } from '../../util/index.ts';
-export interface RenderArgs extends ServerSideRenderArgs {
-    adapterConfig: Record<string, unknown>;
-    rendererType: string;
-}
-export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
-    assemblyName: string;
-    regions: Region[];
-    adapterConfig: Record<string, unknown>;
-    rendererType: string;
-}
-export declare function validateRendererType<T>(rendererType: string, RendererType: T): ServerSideRendererType;
-export { type RenderResults, type ResultsSerialized, } from '../../pluggableElementTypes/renderers/ServerSideRendererType.ts';

package/esm/rpc/methods/util.js

@@ -1,7 +0,0 @@
-export function validateRendererType(rendererType, RendererType) {
-    if (!RendererType.ReactComponent) {
-        throw new Error(`renderer ${rendererType} has no ReactComponent, it may not be completely implemented yet`);
-    }
-    return RendererType;
-}
-export {} from "../../pluggableElementTypes/renderers/ServerSideRendererType.js";

package/esm/rpc/webWorkerRpcConfig.d.ts

@@ -1,8 +0,0 @@
-declare const WebWorkerRpcDriverConfigSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    workerCount: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>, undefined>>;
-export default WebWorkerRpcDriverConfigSchema;

package/esm/rpc/webWorkerRpcConfig.js

@@ -1,8 +0,0 @@
-import BaseRpcDriverConfigSchema from "./baseRpcConfig.js";
-import { ConfigurationSchema } from "../configuration/index.js";
-function x() { }
-const WebWorkerRpcDriverConfigSchema = ConfigurationSchema('WebWorkerRpcDriver', {}, {
-    baseConfiguration: BaseRpcDriverConfigSchema,
-    explicitlyTyped: true,
-});
-export default WebWorkerRpcDriverConfigSchema;

package/esm/ui/MenuButton.d.ts

@@ -1 +0,0 @@
-export { default } from './CascadingMenuButton.tsx';

package/esm/ui/MenuButton.js

@@ -1 +0,0 @@
-export { default } from "./CascadingMenuButton.js";

package/esm/ui/MenuItems.d.ts

@@ -1,15 +0,0 @@
-interface MenuItemEndDecorationSubMenuProps {
-    type: 'subMenu';
-}
-interface MenuItemEndDecorationSelectorProps {
-    type: 'checkbox' | 'radio';
-    checked: boolean;
-    disabled?: boolean;
-}
-type MenuItemEndDecorationProps = MenuItemEndDecorationSubMenuProps | MenuItemEndDecorationSelectorProps;
-export declare function MenuItemEndDecoration(props: MenuItemEndDecorationProps): import("react/jsx-runtime").JSX.Element;
-export declare function LoadingMenuItem(): import("react/jsx-runtime").JSX.Element;
-export declare function ErrorMenuItem({ error }: {
-    error: unknown;
-}): import("react/jsx-runtime").JSX.Element;
-export {};

package/esm/ui/MenuItems.js

@@ -1,59 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import ArrowRightIcon from '@mui/icons-material/ArrowRight';
-import CheckBoxIcon from '@mui/icons-material/CheckBox';
-import CheckBoxOutlineBlankIcon from '@mui/icons-material/CheckBoxOutlineBlank';
-import RadioButtonCheckedIcon from '@mui/icons-material/RadioButtonChecked';
-import RadioButtonUncheckedIcon from '@mui/icons-material/RadioButtonUnchecked';
-import { CircularProgress, ListItemIcon, ListItemText, MenuItem, } from '@mui/material';
-import { makeStyles } from "../util/tss-react/index.js";
-const useStyles = makeStyles()({
-    menuItemEndDecoration: {
-        padding: 0,
-        margin: 0,
-        height: 16,
-    },
-});
-export function MenuItemEndDecoration(props) {
-    const { classes } = useStyles();
-    const { type } = props;
-    let checked;
-    let disabled;
-    if ('checked' in props) {
-        ;
-        ({ checked, disabled } = props);
-    }
-    let icon;
-    switch (type) {
-        case 'subMenu': {
-            icon = _jsx(ArrowRightIcon, { color: "action" });
-            break;
-        }
-        case 'checkbox': {
-            if (checked) {
-                const color = disabled ? 'inherit' : undefined;
-                icon = _jsx(CheckBoxIcon, { color: color });
-            }
-            else {
-                icon = _jsx(CheckBoxOutlineBlankIcon, { color: "action" });
-            }
-            break;
-        }
-        case 'radio': {
-            if (checked) {
-                const color = disabled ? 'inherit' : undefined;
-                icon = _jsx(RadioButtonCheckedIcon, { color: color });
-            }
-            else {
-                icon = _jsx(RadioButtonUncheckedIcon, { color: "action" });
-            }
-            break;
-        }
-    }
-    return _jsx("div", { className: classes.menuItemEndDecoration, children: icon });
-}
-export function LoadingMenuItem() {
-    return (_jsxs(MenuItem, { disabled: true, children: [_jsx(ListItemIcon, { children: _jsx(CircularProgress, { size: 20 }) }), _jsx(ListItemText, { primary: "Loading..." })] }));
-}
-export function ErrorMenuItem({ error }) {
-    return (_jsx(MenuItem, { disabled: true, children: _jsx(ListItemText, { primary: "Error loading menu", secondary: error instanceof Error ? error.message : String(error) }) }));
-}

package/esm/ui/useEvent.d.ts

@@ -1 +0,0 @@
-export declare function useEvent<Fn extends (...args: any[]) => any>(handler: Fn): Fn;

package/esm/ui/useEvent.js

@@ -1,10 +0,0 @@
-import * as React from 'react';
-export function useEvent(handler) {
-    const handlerRef = React.useRef(null);
-    React.useLayoutEffect(() => {
-        handlerRef.current = handler;
-    });
-    return React.useCallback((...args) => {
-        handlerRef.current?.(...args);
-    }, []);
-}

package/esm/util/blobToDataURL.d.ts

@@ -1 +0,0 @@
-export declare function blobToDataURL(blob: Blob): Promise<string>;

package/esm/util/blobToDataURL.js

@@ -1,14 +0,0 @@
-export function blobToDataURL(blob) {
-    const a = new FileReader();
-    return new Promise((resolve, reject) => {
-        a.onload = e => {
-            if (e.target) {
-                resolve(e.target.result);
-            }
-            else {
-                reject(new Error('unknown result reading blob from canvas'));
-            }
-        };
-        a.readAsDataURL(blob);
-    });
-}

package/esm/util/compositeMap.d.ts

@@ -1,11 +0,0 @@
-export default class CompositeMap<T, U> {
-    private submaps;
-    constructor(submaps: Map<T, U>[]);
-    has(id: T): boolean;
-    get(id: T): U | undefined;
-    values(): Generator<U, void, unknown>;
-    keys(): Generator<T, void, unknown>;
-    find<V>(f: (arg0: U) => V): U | undefined;
-    [Symbol.iterator](): Generator<readonly [T, U | undefined], void, unknown>;
-    entries(): Generator<readonly [T, U | undefined], void, unknown>;
-}