@jbrowse/core 3.6.5 → 4.0.0

package/esm/pluggableElementTypes/models/BaseConnectionModelFactory.d.ts

@@ -0,0 +1,29 @@
+import type PluginManager from '../../PluginManager.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+type TrackConf = AnyConfigurationModel | Record<string, unknown>;
+declare function stateModelFactory(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
+    name: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    tracks: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyModelType>;
+    configuration: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        name: {
+            type: string;
+            defaultValue: string;
+            description: string;
+        };
+        assemblyNames: {
+            type: string;
+            defaultValue: never[];
+            description: string;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId">>;
+}, {
+    connect(_arg: AnyConfigurationModel): void;
+} & {
+    afterAttach(): void;
+    addTrackConf(trackConf: TrackConf): any;
+    addTrackConfs(trackConfs: TrackConf[]): void;
+    setTrackConfs(trackConfs: AnyConfigurationModel[]): void;
+    clear(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export type BaseConnectionModel = ReturnType<typeof stateModelFactory>;
+export default stateModelFactory;

package/esm/pluggableElementTypes/models/BaseConnectionModelFactory.js

@@ -0,0 +1,35 @@
+import { cast, types } from '@jbrowse/mobx-state-tree';
+import configSchema from "./baseConnectionConfig.js";
+import { ConfigurationReference } from "../../configuration/index.js";
+function stateModelFactory(pluginManager) {
+    return types
+        .model('Connection', {
+        name: types.identifier,
+        tracks: types.array(pluginManager.pluggableConfigSchemaType('track')),
+        configuration: ConfigurationReference(configSchema),
+    })
+        .actions(() => ({
+        connect(_arg) { },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            if (self.tracks.length === 0) {
+                self.connect(self.configuration);
+            }
+        },
+        addTrackConf(trackConf) {
+            const length = self.tracks.push(trackConf);
+            return self.tracks[length - 1];
+        },
+        addTrackConfs(trackConfs) {
+            for (const trackConf of trackConfs) {
+                self.tracks.push(trackConf);
+            }
+        },
+        setTrackConfs(trackConfs) {
+            self.tracks = cast(trackConfs);
+        },
+        clear() { },
+    }));
+}
+export default stateModelFactory;

package/esm/pluggableElementTypes/models/BaseDisplayModel.d.ts

@@ -0,0 +1,180 @@
+import type React from 'react';
+import type { MenuItem } from '../../ui/index.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+}, {
+    rendererTypeName: string;
+    error: unknown;
+    statusMessage: string | undefined;
+} & {
+    readonly RenderingComponent: React.FC<{
+        model: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+        onHorizontalScroll?: () => void;
+        blockState?: Record<string, any>;
+    }>;
+    readonly DisplayBlurb: React.FC<{
+        model: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+    }> | null;
+    readonly adapterConfig: any;
+    readonly parentTrack: import("../../util/index.ts").AbstractTrackModel;
+    readonly parentDisplay: any;
+    readonly effectiveRpcDriverName: any;
+} & {
+    renderProps(): any;
+    renderingProps(): {
+        displayModel: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("../../util/index.ts").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("../../util/index.ts").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+    };
+    readonly rendererType: import("../index.ts").RendererType;
+    readonly DisplayMessageComponent: undefined | React.FC<any>;
+    trackMenuItems(): MenuItem[];
+    readonly viewMenuActions: MenuItem[];
+    regionCannotBeRendered(): null;
+} & {
+    setStatusMessage(arg?: string): void;
+    setError(error?: unknown): void;
+    setRpcDriverName(rpcDriverName: string): void;
+    reload(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export type BaseDisplayStateModel = typeof BaseDisplay;
+export type BaseDisplayModel = Instance<BaseDisplayStateModel>;

package/esm/pluggableElementTypes/models/BaseDisplayModel.js

@@ -0,0 +1,104 @@
+import { getParent, types } from '@jbrowse/mobx-state-tree';
+import { getConf } from "../../configuration/index.js";
+import { getContainingTrack, getContainingView, getEnv, } from "../../util/index.js";
+import { getParentRenderProps } from "../../util/tracks.js";
+import { ElementId } from "../../util/types/mst.js";
+function stateModelFactory() {
+    return types
+        .model('BaseDisplay', {
+        id: ElementId,
+        type: types.string,
+        rpcDriverName: types.maybe(types.string),
+    })
+        .volatile(() => ({
+        rendererTypeName: '',
+        error: undefined,
+        statusMessage: undefined,
+    }))
+        .views(self => ({
+        get RenderingComponent() {
+            const { pluginManager } = getEnv(self);
+            return pluginManager.getDisplayType(self.type)
+                .ReactComponent;
+        },
+        get DisplayBlurb() {
+            return null;
+        },
+        get adapterConfig() {
+            return getConf(this.parentTrack, 'adapter');
+        },
+        get parentTrack() {
+            return getContainingTrack(self);
+        },
+        get parentDisplay() {
+            try {
+                const parent = getParent(self);
+                const parentType = parent?.type;
+                if (typeof parentType === 'string' &&
+                    parentType.endsWith('Display')) {
+                    return parent;
+                }
+            }
+            catch {
+            }
+            return undefined;
+        },
+        get effectiveRpcDriverName() {
+            if (self.rpcDriverName) {
+                return self.rpcDriverName;
+            }
+            if (this.parentDisplay?.effectiveRpcDriverName) {
+                return this.parentDisplay.effectiveRpcDriverName;
+            }
+            try {
+                return getConf(this.parentTrack, 'rpcDriverName') || undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    }))
+        .views(self => ({
+        renderProps() {
+            return {
+                ...getParentRenderProps(self),
+                notReady: getContainingView(self).minimized,
+                rpcDriverName: self.effectiveRpcDriverName,
+            };
+        },
+        renderingProps() {
+            return {
+                displayModel: self,
+            };
+        },
+        get rendererType() {
+            const { pluginManager } = getEnv(self);
+            return pluginManager.getRendererType(self.rendererTypeName);
+        },
+        get DisplayMessageComponent() {
+            return undefined;
+        },
+        trackMenuItems() {
+            return [];
+        },
+        get viewMenuActions() {
+            return [];
+        },
+        regionCannotBeRendered() {
+            return null;
+        },
+    }))
+        .actions(self => ({
+        setStatusMessage(arg) {
+            self.statusMessage = arg;
+        },
+        setError(error) {
+            self.error = error;
+        },
+        setRpcDriverName(rpcDriverName) {
+            self.rpcDriverName = rpcDriverName;
+        },
+        reload() { },
+    }));
+}
+export const BaseDisplay = stateModelFactory();

package/esm/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -0,0 +1,74 @@
+import { stringifyBED } from './saveTrackFileTypes/bed.ts';
+import { stringifyGBK } from './saveTrackFileTypes/genbank.ts';
+import { stringifyGFF3 } from './saveTrackFileTypes/gff3.ts';
+import type PluginManager from '../../PluginManager.ts';
+import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
+import type { MenuItem } from '../../ui/index.ts';
+import type { IAnyStateTreeNode, Instance } from '@jbrowse/mobx-state-tree';
+export declare function getCompatibleDisplays(self: IAnyStateTreeNode): ({
+    [x: string]: any;
+} & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+    setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
+} & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>)[];
+export declare function createBaseTrackModel(pm: PluginManager, trackType: string, baseTrackConfig: AnyConfigurationSchemaType): import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    configuration: AnyConfigurationSchemaType;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    pinned: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
+}, {
+    readonly trackId: string;
+    readonly rpcSessionId: string;
+    readonly name: any;
+    readonly textSearchAdapter: any;
+    readonly adapterConfig: any;
+    readonly viewMenuActions: MenuItem[];
+    readonly canConfigure: boolean | ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+            [x: string]: any;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>) | undefined;
+} & {
+    readonly adapterType: import("../AdapterType.ts").default;
+} & {
+    setPinned(flag: boolean): void;
+    setMinimized(flag: boolean): void;
+    showDisplay(displayId: string, initialSnapshot?: {}): void;
+    hideDisplay(displayId: string): number;
+    replaceDisplay(oldDisplayId: string, newDisplayId: string, initialSnapshot?: {}): void;
+} & {
+    saveTrackFileFormatOptions(): {
+        gff3: {
+            name: string;
+            extension: string;
+            callback: typeof stringifyGFF3;
+        };
+        genbank: {
+            name: string;
+            extension: string;
+            callback: typeof stringifyGBK;
+            helpText: string;
+        };
+        bed: {
+            name: string;
+            extension: string;
+            callback: typeof stringifyBED;
+        };
+    };
+} & {
+    trackMenuItems(): MenuItem[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree").ModelSnapshotType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    configuration: AnyConfigurationSchemaType;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    pinned: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
+}>>;
+export type BaseTrackStateModel = ReturnType<typeof createBaseTrackModel>;
+export type BaseTrackModel = Instance<BaseTrackStateModel>;

package/esm/pluggableElementTypes/models/BaseTrackModel.js

@@ -0,0 +1,203 @@
+import { lazy } from 'react';
+import { types } from '@jbrowse/mobx-state-tree';
+import Save from '@mui/icons-material/Save';
+import { stringifyBED } from "./saveTrackFileTypes/bed.js";
+import { stringifyGBK } from "./saveTrackFileTypes/genbank.js";
+import { stringifyGFF3 } from "./saveTrackFileTypes/gff3.js";
+import { ConfigurationReference, getConf } from "../../configuration/index.js";
+import { adapterConfigCacheKey } from "../../data_adapters/util.js";
+import { getContainingView, getEnv, getSession } from "../../util/index.js";
+import { isSessionModelWithConfigEditing } from "../../util/types/index.js";
+import { ElementId } from "../../util/types/mst.js";
+const SaveTrackDataDlg = lazy(() => import("./components/SaveTrackData.js"));
+export function getCompatibleDisplays(self) {
+    const { pluginManager } = getEnv(self);
+    const view = getContainingView(self);
+    const viewType = pluginManager.getViewType(view.type);
+    const compatTypes = new Set(viewType.displayTypes.map(d => d.name));
+    const displays = self.configuration.displays;
+    return displays.filter(d => compatTypes.has(d.type));
+}
+function getDisplayConf(displays, displayId) {
+    const displayConf = displays.find(d => d.displayId === displayId);
+    if (!displayConf) {
+        throw new Error(`could not find display config ${displayId}`);
+    }
+    return displayConf;
+}
+export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
+    return types
+        .model(trackType, {
+        id: ElementId,
+        type: types.literal(trackType),
+        configuration: ConfigurationReference(baseTrackConfig),
+        minimized: false,
+        pinned: false,
+        displays: types.array(pm.pluggableMstType('display', 'stateModel')),
+    })
+        .views(self => ({
+        get trackId() {
+            return self.configuration.trackId;
+        },
+        get rpcSessionId() {
+            const adapter = getConf(self, 'adapter');
+            return adapter ? adapterConfigCacheKey(adapter) : this.trackId;
+        },
+        get name() {
+            return getConf(self, 'name');
+        },
+        get textSearchAdapter() {
+            return getConf(self, 'textSearchAdapter');
+        },
+        get adapterConfig() {
+            return getConf(self, 'adapter');
+        },
+        get viewMenuActions() {
+            return self.displays.flatMap(d => d.viewMenuActions);
+        },
+        get canConfigure() {
+            const session = getSession(self);
+            const { sessionTracks, adminMode } = session;
+            return (isSessionModelWithConfigEditing(session) &&
+                (adminMode || sessionTracks?.find(t => t.trackId === this.trackId)));
+        },
+    }))
+        .views(self => ({
+        get adapterType() {
+            const { adapterConfig } = self;
+            if (!adapterConfig) {
+                throw new Error(`no adapter configuration provided for ${self.type}`);
+            }
+            const adapterType = pm.getAdapterType(adapterConfig.type);
+            if (!adapterType) {
+                throw new Error(`unknown adapter type ${adapterConfig.type}`);
+            }
+            return adapterType;
+        },
+    }))
+        .actions(self => ({
+        setPinned(flag) {
+            self.pinned = flag;
+        },
+        setMinimized(flag) {
+            self.minimized = flag;
+        },
+        showDisplay(displayId, initialSnapshot = {}) {
+            const displays = self.configuration.displays;
+            const displayConf = getDisplayConf(displays, displayId);
+            const displayType = pm.getDisplayType(displayConf.type);
+            if (!displayType) {
+                throw new Error(`unknown display type ${displayConf.type}`);
+            }
+            self.displays.push(displayType.stateModel.create({
+                ...initialSnapshot,
+                type: displayConf.type,
+                configuration: displayId,
+            }));
+        },
+        hideDisplay(displayId) {
+            const displaysToRemove = self.displays.filter(d => d.configuration.displayId === displayId);
+            for (const display of displaysToRemove) {
+                self.displays.remove(display);
+            }
+            return displaysToRemove.length;
+        },
+        replaceDisplay(oldDisplayId, newDisplayId, initialSnapshot = {}) {
+            const idx = self.displays.findIndex(d => d.configuration.displayId === oldDisplayId);
+            if (idx === -1) {
+                throw new Error(`could not find display id ${oldDisplayId} to replace`);
+            }
+            const displays = self.configuration.displays;
+            const displayConf = getDisplayConf(displays, newDisplayId);
+            const displayType = pm.getDisplayType(displayConf.type);
+            if (!displayType) {
+                throw new Error(`unknown display type ${displayConf.type}`);
+            }
+            self.displays.splice(idx, 1, {
+                ...initialSnapshot,
+                type: displayConf.type,
+                configuration: newDisplayId,
+            });
+        },
+    }))
+        .views(() => ({
+        saveTrackFileFormatOptions() {
+            return {
+                gff3: {
+                    name: 'GFF3',
+                    extension: 'gff3',
+                    callback: stringifyGFF3,
+                },
+                genbank: {
+                    name: 'GenBank',
+                    extension: 'gbk',
+                    callback: stringifyGBK,
+                    helpText: 'Note: GenBank format export is experimental. The generated output may not fully conform to the GenBank specification and should be validated before use in production workflows.',
+                },
+                bed: {
+                    name: 'BED',
+                    extension: 'bed',
+                    callback: stringifyBED,
+                },
+            };
+        },
+    }))
+        .views(self => ({
+        trackMenuItems() {
+            const menuItems = self.displays.flatMap(d => d.trackMenuItems());
+            const shownId = self.displays[0].configuration.displayId;
+            const compatDisp = getCompatibleDisplays(self);
+            return [
+                ...menuItems,
+                {
+                    label: 'Save track data',
+                    icon: Save,
+                    priority: 998,
+                    onClick: () => {
+                        getSession(self).queueDialog(handleClose => [
+                            SaveTrackDataDlg,
+                            {
+                                model: self,
+                                handleClose,
+                            },
+                        ]);
+                    },
+                },
+                ...(compatDisp.length > 1
+                    ? [
+                        {
+                            type: 'subMenu',
+                            label: 'Display types',
+                            priority: -1000,
+                            subMenu: compatDisp.map(d => {
+                                const displayType = pm.getDisplayType(d.type);
+                                return {
+                                    type: 'radio',
+                                    label: displayType.displayName,
+                                    helpText: displayType.helpText,
+                                    checked: d.displayId === shownId,
+                                    onClick: () => {
+                                        if (d.displayId !== shownId) {
+                                            self.replaceDisplay(shownId, d.displayId, self.displays[0].getPortableSettings?.() ?? {});
+                                        }
+                                    },
+                                };
+                            }),
+                        },
+                    ]
+                    : []),
+            ];
+        },
+    }))
+        .postProcessSnapshot(snap => {
+        if (!snap) {
+            return snap;
+        }
+        const { minimized, pinned, ...rest } = snap;
+        return {
+            ...rest,
+            ...(minimized ? { minimized } : {}),
+            ...(pinned ? { pinned } : {}),
+        };
+    });
+}