@jbrowse/core 4.1.3 → 4.1.4

package/esm/BaseFeatureWidget/SequenceFeatureDetails/SequenceFeatureDetails.js

@@ -4,13 +4,19 @@ import { Button, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import SequenceFeatureMenu from "./dialogs/SequenceFeatureMenu.js";
 import SequenceTypeSelector from "./dialogs/SequenceTypeSelector.js";
+import { createSequenceFeatureDetailsModel, destroySequenceFeatureDetailsModel, } from "./model.js";
 import { ErrorMessage, LoadingEllipses } from "../../ui/index.js";
 import { SimpleFeature, getSession } from "../../util/index.js";
 import { useFeatureSequence } from "../../util/useFeatureSequence.js";
 const SequencePanel = lazy(() => import("./SequencePanel.js"));
 const SequenceDialog = lazy(() => import("./dialogs/SequenceDialog.js"));
 const SequenceFeatureDetails = observer(function SequenceFeatureDetails({ model, feature, }) {
-    const { sequenceFeatureDetails } = model;
+    const [sequenceFeatureDetails] = useState(() => createSequenceFeatureDetailsModel());
+    useEffect(() => {
+        return () => {
+            destroySequenceFeatureDetailsModel(sequenceFeatureDetails);
+        };
+    }, [sequenceFeatureDetails]);
     const { upDownBp } = sequenceFeatureDetails;
     const seqPanelRef = useRef(null);
     const [openInDialog, setOpenInDialog] = useState(false);
@@ -35,7 +41,7 @@ const SequenceFeatureDetails = observer(function SequenceFeatureDetails({ model,
                                     setOpenInDialog(true);
                                 },
                             },
-                        ] })] }), openInDialog ? (_jsxs("div", { children: ["Open in dialog...", _jsx(Suspense, { fallback: _jsx(LoadingEllipses, {}), children: _jsx(SequenceDialog, { model: model, feature: feature, handleClose: () => {
+                        ] })] }), openInDialog ? (_jsxs("div", { children: ["Open in dialog...", _jsx(Suspense, { fallback: _jsx(LoadingEllipses, {}), children: _jsx(SequenceDialog, { model: model, sequenceFeatureDetails: sequenceFeatureDetails, feature: feature, handleClose: () => {
                                 setOpenInDialog(false);
                             } }) })] })) : (_jsxs("div", { children: [feature.type === 'gene' ? (_jsx(Typography, { children: "Note: inspect subfeature sequences for protein/CDS computations" })) : null, error ? (_jsx(ErrorMessage, { error: error })) : !sequence ? (_jsx(LoadingEllipses, {})) : 'error' in sequence ? (_jsxs(_Fragment, { children: [_jsx(Typography, { color: "error", children: sequence.error }), _jsx(Button, { variant: "contained", color: "inherit", onClick: () => {
                                     setForceLoad(true);

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SequenceDialog.d.ts

@@ -1,8 +1,10 @@
 import { type SimpleFeatureSerialized } from '../../../util/index.ts';
 import type { BaseFeatureWidgetModel } from '../../stateModelFactory.ts';
-declare const SequenceDialog: ({ handleClose, model, feature, }: {
+import type { SequenceFeatureDetailsModel } from '../model.ts';
+declare const SequenceDialog: ({ handleClose, model, sequenceFeatureDetails, feature, }: {
     handleClose: () => void;
     feature: SimpleFeatureSerialized;
     model: BaseFeatureWidgetModel;
+    sequenceFeatureDetails: SequenceFeatureDetailsModel;
 }) => import("react/jsx-runtime").JSX.Element;
 export default SequenceDialog;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/dialogs/SequenceDialog.js

@@ -14,8 +14,7 @@ const useStyles = makeStyles()({
         width: '80em',
     },
 });
-const SequenceDialog = observer(function SequenceDialog({ handleClose, model, feature, }) {
-    const { sequenceFeatureDetails } = model;
+const SequenceDialog = observer(function SequenceDialog({ handleClose, model, sequenceFeatureDetails, feature, }) {
     const { upDownBp } = sequenceFeatureDetails;
     const { classes } = useStyles();
     const seqPanelRef = useRef(null);

package/esm/BaseFeatureWidget/SequenceFeatureDetails/model.d.ts

@@ -24,8 +24,56 @@ export declare function SequenceFeatureDetailsF(): import("@jbrowse/mobx-state-t
     readonly hasExon: boolean | undefined;
     readonly hasExonOrCDS: boolean | undefined;
 } & {
-    afterAttach(): void;
+    afterCreate(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export declare function createSequenceFeatureDetailsModel(): {} & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+    showCoordinatesSetting: string;
+    intronBp: number;
+    upDownBp: number;
+    upperCaseCDS: boolean;
+    charactersPerRow: number;
+    feature: SimpleFeatureSerialized | undefined;
+    mode: SequenceDisplayMode;
+} & {
+    setFeature(f: SimpleFeatureSerialized): void;
+    setUpDownBp(f: number): void;
+    setIntronBp(f: number): void;
+    setUpperCaseCDS(f: boolean): void;
+    setShowCoordinates(f: ShowCoordinatesMode): void;
+    setMode(mode: SequenceDisplayMode): void;
+} & {
+    readonly showCoordinates: boolean;
+    readonly showGenomicCoordsOption: boolean;
+    readonly hasCDS: boolean | undefined;
+    readonly hasExon: boolean | undefined;
+    readonly hasExonOrCDS: boolean | undefined;
+} & {
+    afterCreate(): void;
+} & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    showCoordinatesSetting: string;
+    intronBp: number;
+    upDownBp: number;
+    upperCaseCDS: boolean;
+    charactersPerRow: number;
+    feature: SimpleFeatureSerialized | undefined;
+    mode: SequenceDisplayMode;
+} & {
+    setFeature(f: SimpleFeatureSerialized): void;
+    setUpDownBp(f: number): void;
+    setIntronBp(f: number): void;
+    setUpperCaseCDS(f: boolean): void;
+    setShowCoordinates(f: ShowCoordinatesMode): void;
+    setMode(mode: SequenceDisplayMode): void;
+} & {
+    readonly showCoordinates: boolean;
+    readonly showGenomicCoordsOption: boolean;
+    readonly hasCDS: boolean | undefined;
+    readonly hasExon: boolean | undefined;
+    readonly hasExonOrCDS: boolean | undefined;
+} & {
+    afterCreate(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+export declare function destroySequenceFeatureDetailsModel(model: SequenceFeatureDetailsModel): void;
 export type SequenceFeatureDetailsStateModel = ReturnType<typeof SequenceFeatureDetailsF>;
 export type SequenceFeatureDetailsModel = Instance<SequenceFeatureDetailsStateModel>;
 export {};

package/esm/BaseFeatureWidget/SequenceFeatureDetails/model.js

@@ -1,4 +1,4 @@
-import { addDisposer, types } from '@jbrowse/mobx-state-tree';
+import { addDisposer, destroy, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
 import { localStorageGetBoolean, localStorageGetItem, localStorageGetNumber, localStorageSetItem, } from "../../util/index.js";
 function localStorageSetNumber(key, value) {
@@ -68,7 +68,7 @@ export function SequenceFeatureDetailsF() {
         },
     }))
         .actions(self => ({
-        afterAttach() {
+        afterCreate() {
             addDisposer(self, autorun(function sequenceFeatureLocalStorageAutorun() {
                 localStorageSetNumber(`${p}-upDownBp`, self.upDownBp);
                 localStorageSetNumber(`${p}-intronBp`, self.intronBp);
@@ -81,3 +81,9 @@ export function SequenceFeatureDetailsF() {
         },
     }));
 }
+export function createSequenceFeatureDetailsModel() {
+    return SequenceFeatureDetailsF().create({});
+}
+export function destroySequenceFeatureDetailsModel(model) {
+    destroy(model);
+}

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -35,7 +35,7 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
         readonly hasExon: boolean | undefined;
         readonly hasExonOrCDS: boolean | undefined;
     } & {
-        afterAttach(): void;
+        afterCreate(): void;
     }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
     descriptions: import("@jbrowse/mobx-state-tree").IType<Record<string, unknown> | undefined, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
 }, {
@@ -81,7 +81,7 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
         readonly hasExon: boolean | undefined;
         readonly hasExonOrCDS: boolean | undefined;
     } & {
-        afterAttach(): void;
+        afterCreate(): void;
     }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
     descriptions: import("@jbrowse/mobx-state-tree").IType<Record<string, unknown> | undefined, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
 }>>, {

package/esm/data_adapters/BaseAdapter/stats.js

@@ -6,6 +6,8 @@ const DENSITY_SAMPLE_INITIAL_INTERVAL = 1000;
 const DENSITY_SAMPLE_MIN_FEATURES = 70;
 const DENSITY_SAMPLE_TIMEOUT_MS = 5000;
 export function aggregateQuantitativeStats(stats) {
+    const meanMins = stats.map(s => s.scoreMeanMin).filter(s => s !== undefined);
+    const meanMaxs = stats.map(s => s.scoreMeanMax).filter(s => s !== undefined);
     return rectifyStats({
         scoreMax: max(stats.map(s => s.scoreMax)),
         scoreMin: min(stats.map(s => s.scoreMin)),
@@ -13,6 +15,8 @@ export function aggregateQuantitativeStats(stats) {
         scoreSumSquares: sum(stats.map(s => s.scoreSumSquares)),
         featureCount: sum(stats.map(s => s.featureCount)),
         basesCovered: sum(stats.map(s => s.basesCovered)),
+        ...(meanMins.length > 0 ? { scoreMeanMin: min(meanMins) } : {}),
+        ...(meanMaxs.length > 0 ? { scoreMeanMax: max(meanMaxs) } : {}),
     });
 }
 export function sampleFeaturesForInterval(region, interval, getFeatures, opts) {

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

@@ -1,5 +1,5 @@
-import ServerSideRendererType from './ServerSideRendererType.tsx';
-import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults as ServerSideRenderResults, RenderReturn, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType.tsx';
+import ServerSideRendererType from './ServerSideRendererType.ts';
+import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults as ServerSideRenderResults, RenderReturn, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType.ts';
 import type { AnyConfigurationModel } from '../../configuration/index.ts';
 import type { Feature, SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
 import type { AugmentedRegion as Region } from '../../util/types/index.ts';
@@ -45,7 +45,17 @@ export default class FeatureRendererType extends ServerSideRendererType {
         html?: string;
     } | {
         blockKey: string;
-        reactElement: import("react/jsx-runtime").JSX.Element | undefined;
+        reactElement: import("react").FunctionComponentElement<{
+            res: ServerSideResultsSerialized;
+            args: ServerSideRenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            supportsSVG: boolean;
+        }> | import("react").FunctionComponentElement<{
+            res: ServerSideResultsSerialized;
+            args: ServerSideRenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            renderingProps?: Record<string, unknown>;
+        }>;
         html?: string;
     }>;
     serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;

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

@@ -0,0 +1,8 @@
+import type { ComponentType } from 'react';
+import type { RenderArgs, ResultsSerialized } from './ServerSideRendererTypes.ts';
+export default function RenderResult({ res, args, ReactComponent, renderingProps, }: {
+    res: ResultsSerialized;
+    args: RenderArgs;
+    ReactComponent: ComponentType<any>;
+    renderingProps?: Record<string, unknown>;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/pluggableElementTypes/renderers/RenderResult.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function RenderResult({ res, args, ReactComponent, renderingProps, }) {
+    return _jsx(ReactComponent, { ...args, ...res, ...renderingProps });
+}

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

@@ -1,57 +1,28 @@
 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 { RenderResults } from './RendererType.tsx';
+import type { RenderArgs, RenderArgsDeserialized, RenderArgsSerialized, ResultsDeserialized, ResultsSerialized } from './ServerSideRendererTypes.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 type { RenderArgs, RenderArgsDeserialized, RenderArgsSerialized, ResultsDeserialized, ResultsSerialized, ResultsSerializedSvgExport, } from './ServerSideRendererTypes.ts';
 export default class ServerSideRenderer extends RendererType {
+    private createReactElement;
     renderDirect(args: RenderArgs): Promise<RenderResults | {
-        reactElement: import("react/jsx-runtime").JSX.Element | undefined;
+        reactElement: import("react").FunctionComponentElement<{
+            res: ResultsSerialized;
+            args: RenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            supportsSVG: boolean;
+        }> | import("react").FunctionComponentElement<{
+            res: ResultsSerialized;
+            args: RenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            renderingProps?: Record<string, unknown>;
+        }>;
         html?: string;
     }>;
     serializeArgsInClient(args: RenderArgs): RenderArgsSerialized;
     deserializeResultsInClient(res: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
     deserializeArgsInWorker(args: RenderArgsSerialized): RenderArgsDeserialized;
-    serializeResultsInWorker(results: RenderResults & {
-        imageData?: ImageBitmap;
-    }, _args: RenderArgsDeserialized): ResultsSerialized;
+    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>;

package/esm/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -1,6 +1,8 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement } from 'react';
 import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import RenderResult from "./RenderResult.js";
 import RendererType from "./RendererType.js";
+import SvgRenderResult from "./SvgRenderResult.js";
 import SerializableFilterChain from "./util/serializableFilterChain.js";
 import { getSerializedSvg, updateStatus } from "../../util/index.js";
 import { isRpcResult } from "../../util/rpc.js";
@@ -8,22 +10,22 @@ import { checkStopToken2, createStopTokenChecker, } from "../../util/stopToken.j
 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 {
+    createReactElement(res, args) {
+        return args.exportSVG
+            ? createElement(SvgRenderResult, {
+                res,
+                args,
+                ReactComponent: this.ReactComponent,
+                supportsSVG: this.supportsSVG,
+            })
+            : createElement(RenderResult, {
+                res,
+                args,
+                ReactComponent: this.ReactComponent,
+                renderingProps: args.renderingProps,
+            });
+    }
     async renderDirect(args) {
         const { renderingProps, ...rest } = args;
         const config = isStateTreeNode(args.config)
@@ -36,15 +38,12 @@ export default class ServerSideRenderer extends RendererType {
             config,
         });
         if (isRpcResult(results)) {
-            const unwrapped = results.value;
-            return this.deserializeResultsInClient(unwrapped, args);
+            return this.deserializeResultsInClient(results.value, args);
         }
         const { reactElement, ...resultRest } = results;
         return {
             ...resultRest,
-            reactElement: args.exportSVG
-                ? createSvgExportElement(resultRest, args, this.ReactComponent, this.supportsSVG)
-                : createNormalElement(resultRest, args, this.ReactComponent, renderingProps),
+            reactElement: this.createReactElement(resultRest, args),
         };
     }
     serializeArgsInClient(args) {
@@ -58,12 +57,9 @@ export default class ServerSideRenderer extends RendererType {
         };
     }
     deserializeResultsInClient(res, args) {
-        const { renderingProps } = args;
         return {
             ...res,
-            reactElement: args.exportSVG
-                ? createSvgExportElement(res, args, this.ReactComponent, this.supportsSVG)
-                : createNormalElement(res, args, this.ReactComponent, renderingProps),
+            reactElement: this.createReactElement(res, args),
         };
     }
     deserializeArgsInWorker(args) {
@@ -88,30 +84,26 @@ export default class ServerSideRenderer extends RendererType {
         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;
+            return { ...rest, html: await getSerializedSvg(results) };
         }
+        return results;
     }
     async renderInWorker(args) {
         const { stopToken, statusCallback = () => { } } = args;
         const stopTokenCheck = createStopTokenChecker(stopToken);
-        const args2 = this.deserializeArgsInWorker(args);
-        const results = await updateStatus('Rendering plot', statusCallback, () => this.render({ ...args2, stopTokenCheck }));
+        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, { ...args2, stopTokenCheck }));
+        return 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);
+        await rpcManager.call(args.sessionId, 'CoreFreeResources', this.serializeArgsInClient(args));
     }
 }
 export {} from "./RendererType.js";

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

@@ -0,0 +1,42 @@
+import type { RenderProps, RenderResults } from './RendererType.tsx';
+import type SerializableFilterChain from './util/serializableFilterChain.ts';
+import type { SerializedFilterChain } from './util/serializableFilterChain.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.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 {};

package/esm/pluggableElementTypes/renderers/ServerSideRendererTypes.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { ComponentType } from 'react';
+import type { RenderArgs, ResultsSerialized } from './ServerSideRendererTypes.ts';
+export default function SvgRenderResult({ res, args, ReactComponent, supportsSVG, }: {
+    res: ResultsSerialized;
+    args: RenderArgs;
+    ReactComponent: ComponentType<any>;
+    supportsSVG: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/esm/pluggableElementTypes/renderers/SvgRenderResult.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function SvgRenderResult({ res, args, ReactComponent, supportsSVG, }) {
+    if (res.html) {
+        return null;
+    }
+    if (supportsSVG) {
+        return _jsx(ReactComponent, { ...args, ...res });
+    }
+    return (_jsx("text", { y: "12", fill: "black", children: "SVG export not supported for this track" }));
+}

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

@@ -2,5 +2,5 @@ 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 { default as ServerSideRendererType } from './ServerSideRendererType.ts';
 export { type RenderProps } from './RendererType.tsx';

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

@@ -2,9 +2,19 @@ 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.tsx").RenderArgsSerialized>;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("../../pluggableElementTypes/renderers/ServerSideRendererTypes.ts").RenderArgsSerialized>;
     executeDirect(args: RenderArgs): Promise<RenderResults | {
-        reactElement: import("react/jsx-runtime").JSX.Element | undefined;
+        reactElement: import("react").FunctionComponentElement<{
+            res: ResultsSerialized;
+            args: import("../../pluggableElementTypes/renderers/ServerSideRendererTypes.ts").RenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            supportsSVG: boolean;
+        }> | import("react").FunctionComponentElement<{
+            res: ResultsSerialized;
+            args: import("../../pluggableElementTypes/renderers/ServerSideRendererTypes.ts").RenderArgs;
+            ReactComponent: import("react").ComponentType<any>;
+            renderingProps?: Record<string, unknown>;
+        }>;
         html?: string;
     }>;
     execute(args: RenderArgsSerialized & {

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

@@ -1,5 +1,5 @@
 import type { ServerSideRendererType } from '../../pluggableElementTypes/index.ts';
-import type { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized } from '../../pluggableElementTypes/renderers/ServerSideRendererType.tsx';
+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>;
@@ -12,4 +12,4 @@ export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
     rendererType: string;
 }
 export declare function validateRendererType<T>(rendererType: string, RendererType: T): ServerSideRendererType;
-export { type RenderResults, type ResultsSerialized, } from '../../pluggableElementTypes/renderers/ServerSideRendererType.tsx';
+export { type RenderResults, type ResultsSerialized, } from '../../pluggableElementTypes/renderers/ServerSideRendererType.ts';

package/esm/util/stats.d.ts

@@ -8,6 +8,8 @@ export interface UnrectifiedQuantitativeStats {
     scoreSumSquares: number;
     featureCount: number;
     basesCovered: number;
+    scoreMeanMin?: number;
+    scoreMeanMax?: number;
 }
 export interface RectifiedQuantitativeStats extends UnrectifiedQuantitativeStats {
     featureDensity: number;

package/esm/util/stats.js

@@ -29,17 +29,21 @@ export async function scoresToStats(region, feats) {
     const seed = {
         scoreMin: Number.MAX_VALUE,
         scoreMax: Number.MIN_VALUE,
+        scoreMeanMin: Number.MAX_VALUE,
+        scoreMeanMax: Number.MIN_VALUE,
         scoreSum: 0,
         scoreSumSquares: 0,
         featureCount: 0,
     };
     let found = false;
-    const { scoreMin, scoreMax, scoreSum, scoreSumSquares, featureCount } = await firstValueFrom(feats.pipe(reduce((acc, f) => {
+    const { scoreMin, scoreMax, scoreMeanMin, scoreMeanMax, scoreSum, scoreSumSquares, featureCount, } = await firstValueFrom(feats.pipe(reduce((acc, f) => {
         const s = f.get('score');
         const summary = f.get('summary');
         const { scoreMax, scoreMin } = acc;
         acc.scoreMax = Math.max(scoreMax, summary ? f.get('maxScore') : s);
         acc.scoreMin = Math.min(scoreMin, summary ? f.get('minScore') : s);
+        acc.scoreMeanMin = Math.min(acc.scoreMeanMin, s);
+        acc.scoreMeanMax = Math.max(acc.scoreMeanMax, s);
         acc.scoreSum += s;
         acc.scoreSumSquares += s * s;
         acc.featureCount += 1;
@@ -50,6 +54,8 @@ export async function scoresToStats(region, feats) {
         ? rectifyStats({
             scoreMax,
             scoreMin,
+            scoreMeanMin,
+            scoreMeanMax,
             scoreSum,
             scoreSumSquares,
             featureCount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "type": "module",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
@@ -459,6 +459,14 @@
     "./util/fileHandleStore": {
       "types": "./esm/util/fileHandleStore.d.ts",
       "import": "./esm/util/fileHandleStore.js"
+    },
+    "./util/tss-react/types": {
+      "types": "./esm/util/tss-react/types.d.ts",
+      "import": "./esm/util/tss-react/types.js"
+    },
+    "./configuration/configurationSchema": {
+      "types": "./esm/configuration/configurationSchema.d.ts",
+      "import": "./esm/configuration/configurationSchema.js"
     }
   },
   "files": [
@@ -468,7 +476,7 @@
     "@emotion/react": "^11.14.0",
     "@emotion/serialize": "^1.3.3",
     "@emotion/utils": "^1.4.2",
-    "@floating-ui/react": "^0.27.16",
+    "@floating-ui/react": "^0.27.17",
     "@gmod/abortable-promise-cache": "^3.0.4",
     "@gmod/bgzf-filehandle": "^6.0.12",
     "@gmod/http-range-fetcher": "^5.0.7",
@@ -476,11 +484,11 @@
     "@jbrowse/mobx-state-tree": "^5.5.0",
     "@jbrowse/quick-lru": "^7.3.5",
     "@leeoniya/ufuzzy": "^1.0.19",
-    "@mui/icons-material": "^7.3.7",
-    "@mui/material": "^7.3.7",
-    "@mui/system": "^7.3.7",
-    "@mui/types": "^7.4.10",
-    "@mui/x-data-grid": "^8.26.0",
+    "@mui/icons-material": "^7.3.8",
+    "@mui/material": "^7.3.8",
+    "@mui/system": "^7.3.8",
+    "@mui/types": "^7.4.11",
+    "@mui/x-data-grid": "^8.27.1",
     "@types/file-saver-es": "^2.0.3",
     "canvas-sequencer-ts": "^3.1.3",
     "canvas2svg": "^1.0.16",
@@ -850,6 +858,12 @@
       ],
       "util/fileHandleStore": [
         "esm/util/fileHandleStore.d.ts"
+      ],
+      "util/tss-react/types": [
+        "esm/util/tss-react/types.d.ts"
+      ],
+      "configuration/configurationSchema": [
+        "esm/configuration/configurationSchema.d.ts"
       ]
     }
   }