@jbrowse/product-core 4.3.0 → 5.0.0-beta.2

package/esm/Session/Themes.d.ts

@@ -1,18 +1,103 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
+import type { SerializableThemeArgs, ThemeMap } from '@jbrowse/core/ui';
 import type { IAnyStateTreeNode, Instance } from '@jbrowse/mobx-state-tree';
 import type { ThemeOptions } from '@mui/material';
-type ThemeMap = Record<string, ThemeOptions>;
+/**
+ * #stateModel ThemeManagerSessionMixin
+ */
 export declare function ThemeManagerSessionMixin(_pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{}, {
     sessionThemeName: string;
 } & {
+    /**
+     * #method
+     */
     allThemes(): ThemeMap;
+    /**
+     * #getter
+     */
     readonly themeName: string;
+    /**
+     * #getter
+     */
+    readonly themeOptions: SerializableThemeArgs;
+    /**
+     * #getter
+     * Every color JBrowse renders, resolved to plain strings. This is what
+     * rendering reads: it needs no React context, it crosses the RPC worker
+     * boundary as itself, and it costs no UI toolkit. Prefer it over
+     * `theme` anywhere the answer wanted is a color rather than a Material
+     * UI component style.
+     */
+    readonly palette: import("@jbrowse/core/ui/palette").JBrowsePalette;
+    /**
+     * #getter
+     * The palette plus the sizing tokens `makeStyles` reads — spacing,
+     * corner radius, type scale. This is what a product mounts on
+     * `StyleThemeProvider`; it costs no UI toolkit, and it is derived from
+     * the same `themeOptions` as `theme`, so a config `theme` that sets
+     * `spacing` moves JBrowse's own styles and its Material components
+     * together.
+     */
+    readonly styleTheme: import("@jbrowse/core/ui/styleTheme").JBrowseStyleTheme;
+    /**
+     * #getter
+     * The Material UI theme, for the components that are Material UI. Its
+     * palette is spliced from the same `resolvePalette` call as `palette`
+     * above, so the two cannot disagree.
+     */
     readonly theme: import("@mui/material").Theme;
+    /**
+     * #method
+     * Raw `ThemeOptions` for the active theme, or a named override (used by
+     * the SVG-export theme picker). Unlike `theme` (a built,
+     * non-serializable MUI theme), this is the plain options object every
+     * view's SVG export threads into each display's `renderSvg`, which
+     * rebuilds the theme via `createJBrowseTheme` outside React context.
+     *
+     * The `default` entry is spliced with the config `theme` slot, because
+     * the preset is only half of what that entry means — the picker calls it
+     * "Default (from config)" and `resolvePalette` merges the two for every
+     * other consumer. Returning the bare preset made `view.exportSvg()`
+     * silently drop a host's configured palette: a config setting
+     * `primary.main` drew `#123456` on screen and exported the stock
+     * `#0D233F`, with the export dialog reporting the theme it had not used.
+     * Every other named theme is a fixed preset that ignores config, which is
+     * the distinction this ternary keeps.
+     */
+    getActiveThemeOptions(name?: string): (ThemeOptions & {
+        name?: string;
+    }) | undefined;
 } & {
+    /**
+     * #action
+     */
     setThemeName(name: string): void;
+    /**
+     * #action
+     * Point the session at light or dark, for a host that follows its own
+     * dark-mode state rather than offering JBrowse's theme menu. Satisfies
+     * `ThemeModeSession`, so `useSessionPalette` works against an app
+     * session and an embedded one alike.
+     *
+     * Expressed as a write to the config `theme` slot plus a return to the
+     * `default` theme, not as `setThemeName('darkStock')`. Only the
+     * `default` theme merges `configTheme.palette` (see `resolvePalette`),
+     * so selecting a stock theme would discard whatever the host passed as
+     * `configuration.theme` — their brand `primary`, say — the first time
+     * their toggle fired. Merging at both levels for the same reason:
+     * `theme` is a frozen slot, and `mode` and `primary` are siblings under
+     * `palette`.
+     *
+     * One write, not two: `themeOptions` is derived from the same slot and
+     * is what ships to the RPC worker, so the labels baked into a rendered
+     * image follow the mode along with what React draws.
+     */
+    setThemeMode(mode: 'light' | 'dark'): void;
     afterAttach(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for a session that supports theming */
 export type SessionWithThemesType = ReturnType<typeof ThemeManagerSessionMixin>;
+/** Instance of a session that has theming support */
 export type SessionWithThemes = Instance<SessionWithThemesType>;
+/** Type guard for SessionWithThemes */
 export declare function isSessionWithThemes(session: IAnyStateTreeNode): session is SessionWithThemes;
-export {};

package/esm/Session/Themes.js

@@ -1,43 +1,176 @@
-import { getConf } from '@jbrowse/core/configuration';
-import { createJBrowseTheme, defaultThemes } from '@jbrowse/core/ui';
+import { getConf, setConf } from '@jbrowse/core/configuration';
+import { createJBrowseThemeFromArgs, defaultThemes } from '@jbrowse/core/ui';
+import { resolvePalette } from '@jbrowse/core/ui/palette';
+import { resolveStyleTheme } from '@jbrowse/core/ui/styleTheme';
 import { localStorageGetItem, localStorageSetItem } from '@jbrowse/core/util';
 import { addDisposer, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
+import { asSession } from '../siblingCast.js';
+import { isBaseSession } from './BaseSession.js';
+/**
+ * What `name` actually resolves to — `default` for one `themes` no longer
+ * holds. Every theme name is either stored or handed in from outside, and both
+ * go stale the same way: `sessionThemeName` outlives an `extraThemes` entry an
+ * admin drops, and so does a name an export dialog persisted or a saved figure
+ * spec carries.
+ */
+function resolveThemeName(themes, name) {
+    return themes[name] ? name : 'default';
+}
+/**
+ * #stateModel ThemeManagerSessionMixin
+ */
 export function ThemeManagerSessionMixin(_pluginManager) {
     return types
         .model({})
         .volatile(() => ({
-        sessionThemeName: localStorageGetItem('themeName') || 'default',
-    }))
-        .views(s => ({
-        allThemes() {
-            const self = s;
-            const extraThemes = getConf(self.jbrowse, 'extraThemes');
-            return { ...defaultThemes, ...extraThemes };
-        },
-        get themeName() {
-            const { sessionThemeName } = s;
-            const all = this.allThemes();
-            return all[sessionThemeName] ? sessionThemeName : 'default';
-        },
-        get theme() {
-            const self = s;
-            const configTheme = getConf(self.jbrowse, 'theme');
-            const all = this.allThemes();
-            return createJBrowseTheme(configTheme, all, this.themeName);
-        },
+        sessionThemeName: localStorageGetItem('themeName') ?? 'default',
     }))
+        .views(s => {
+        const self = asSession(s);
+        return {
+            /**
+             * #method
+             */
+            allThemes() {
+                const extraThemes = getConf(self.jbrowse, 'extraThemes');
+                return { ...defaultThemes, ...extraThemes };
+            },
+            /**
+             * #getter
+             */
+            get themeName() {
+                return resolveThemeName(this.allThemes(), self.sessionThemeName);
+            },
+            /**
+             * #getter
+             */
+            // Structurally-serializable description of the active theme, safe to
+            // send across the RPC worker boundary (the created `theme` carries
+            // functions and cannot be cloned). The worker rebuilds via
+            // createJBrowseThemeFromArgs.
+            get themeOptions() {
+                return {
+                    configTheme: getConf(self.jbrowse, 'theme'),
+                    extraThemes: getConf(self.jbrowse, 'extraThemes'),
+                    themeName: this.themeName,
+                };
+            },
+            /**
+             * #getter
+             * Every color JBrowse renders, resolved to plain strings. This is what
+             * rendering reads: it needs no React context, it crosses the RPC worker
+             * boundary as itself, and it costs no UI toolkit. Prefer it over
+             * `theme` anywhere the answer wanted is a color rather than a Material
+             * UI component style.
+             */
+            get palette() {
+                return resolvePalette(this.themeOptions);
+            },
+            /**
+             * #getter
+             * The palette plus the sizing tokens `makeStyles` reads — spacing,
+             * corner radius, type scale. This is what a product mounts on
+             * `StyleThemeProvider`; it costs no UI toolkit, and it is derived from
+             * the same `themeOptions` as `theme`, so a config `theme` that sets
+             * `spacing` moves JBrowse's own styles and its Material components
+             * together.
+             */
+            get styleTheme() {
+                return resolveStyleTheme(this.themeOptions);
+            },
+            /**
+             * #getter
+             * The Material UI theme, for the components that are Material UI. Its
+             * palette is spliced from the same `resolvePalette` call as `palette`
+             * above, so the two cannot disagree.
+             */
+            get theme() {
+                return createJBrowseThemeFromArgs(this.themeOptions);
+            },
+            /**
+             * #method
+             * Raw `ThemeOptions` for the active theme, or a named override (used by
+             * the SVG-export theme picker). Unlike `theme` (a built,
+             * non-serializable MUI theme), this is the plain options object every
+             * view's SVG export threads into each display's `renderSvg`, which
+             * rebuilds the theme via `createJBrowseTheme` outside React context.
+             *
+             * The `default` entry is spliced with the config `theme` slot, because
+             * the preset is only half of what that entry means — the picker calls it
+             * "Default (from config)" and `resolvePalette` merges the two for every
+             * other consumer. Returning the bare preset made `view.exportSvg()`
+             * silently drop a host's configured palette: a config setting
+             * `primary.main` drew `#123456` on screen and exported the stock
+             * `#0D233F`, with the export dialog reporting the theme it had not used.
+             * Every other named theme is a fixed preset that ignores config, which is
+             * the distinction this ternary keeps.
+             */
+            getActiveThemeOptions(name) {
+                const all = this.allThemes();
+                const themeName = resolveThemeName(all, name ?? this.themeName);
+                const theme = all[themeName];
+                if (themeName !== 'default') {
+                    return theme;
+                }
+                // shallow over the palette, which is how `resolvePalette` spreads the
+                // same two — `mode` and `primary` are siblings there, so both levels
+                // have to survive
+                const configTheme = getConf(self.jbrowse, 'theme');
+                return {
+                    ...theme,
+                    ...configTheme,
+                    palette: { ...theme?.palette, ...configTheme.palette },
+                };
+            },
+        };
+    })
         .actions(self => ({
+        /**
+         * #action
+         */
         setThemeName(name) {
             self.sessionThemeName = name;
         },
+        /**
+         * #action
+         * Point the session at light or dark, for a host that follows its own
+         * dark-mode state rather than offering JBrowse's theme menu. Satisfies
+         * `ThemeModeSession`, so `useSessionPalette` works against an app
+         * session and an embedded one alike.
+         *
+         * Expressed as a write to the config `theme` slot plus a return to the
+         * `default` theme, not as `setThemeName('darkStock')`. Only the
+         * `default` theme merges `configTheme.palette` (see `resolvePalette`),
+         * so selecting a stock theme would discard whatever the host passed as
+         * `configuration.theme` — their brand `primary`, say — the first time
+         * their toggle fired. Merging at both levels for the same reason:
+         * `theme` is a frozen slot, and `mode` and `primary` are siblings under
+         * `palette`.
+         *
+         * One write, not two: `themeOptions` is derived from the same slot and
+         * is what ships to the RPC worker, so the labels baked into a rendered
+         * image follow the mode along with what React draws.
+         */
+        setThemeMode(mode) {
+            const { jbrowse } = asSession(self);
+            const theme = getConf(jbrowse, 'theme') ?? {};
+            setConf(jbrowse, 'theme', {
+                ...theme,
+                palette: { ...theme.palette, mode },
+            });
+            self.sessionThemeName = 'default';
+        },
         afterAttach() {
             addDisposer(self, autorun(function themeNameAutorun() {
-                localStorageSetItem('themeName', self.themeName);
+                // persist the raw selection, not the coerced themeName, so a
+                // theme registered later isn't clobbered with 'default'
+                localStorageSetItem('themeName', self.sessionThemeName);
             }, { name: 'ThemeName' }));
         },
     }));
 }
+/** Type guard for SessionWithThemes */
 export function isSessionWithThemes(session) {
-    return 'theme' in session;
+    return isBaseSession(session) && 'theme' in session;
 }

package/esm/Session/TrackMenu.d.ts

@@ -0,0 +1,112 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { DialogComponentType } from '@jbrowse/core/util';
+import type { TrackActionView } from '@jbrowse/core/util/types';
+type TrackCopySnapshot = {
+    trackId: string;
+    name: string;
+    category?: unknown;
+    displays?: {
+        type: string;
+        displayId: string;
+    }[];
+} & Record<string, unknown>;
+/**
+ * Clone a track config for "Copy track": snapshots the config, appends a unique
+ * timestamp suffix to trackId (so it doesn't collide with the original), tags
+ * " (copy)" on the name, and regenerates each displayId to the canonical
+ * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
+ * (displayId is a types.identifier, so a collision would crash MST).
+ */
+export declare function copyTrackSnapshot(config: BaseTrackConfig, opts: {
+    clearCategory: boolean;
+}): TrackCopySnapshot;
+interface TrackActionSession<C> {
+    editConfiguration: (config: AnyConfigurationModel | {
+        trackId: string;
+    }, opts?: {
+        expandedDisplayId?: string;
+    }) => void;
+    publishTrackConf: (conf: C) => unknown;
+    deleteTrackConf: (conf: AnyConfigurationModel) => void;
+    resetTrackConfiguration?: (trackId: string) => void;
+    /**
+     * Declared here, though only the copy guard below reads it, so a session that
+     * loses the list loses the guard *loudly*. `namesTemporaryAssembly` takes an
+     * `unknown` session and answers false for one that holds no such list, which
+     * is right for a caller that genuinely has none and wrong for one that let it
+     * drop — and that second case is a copy action silently offered again.
+     *
+     * `unknown[]`, the spelling `AbstractSessionModel` already uses, and not the
+     * `{ name?: string }[]` the guard narrows to: that one is a weak type, so a
+     * real MST array of assembly configs — whose element type is an index
+     * signature that declares no `name` — shares no property with it and TS
+     * rejects the assignment. The shape belongs in the guard, which is the only
+     * thing that reads it.
+     */
+    temporaryAssemblies?: unknown[];
+}
+/**
+ * The shared Settings / Copy / Copy-and-open / Delete track actions. Each
+ * product supplies `makeCopy` (its own session-track/category rules) and
+ * `canEdit`; reference sequence tracks can't be copied or deleted. When
+ * `isSessionOverride` is set the track is a session edit shadowing an
+ * admin-owned config track, so the final action resets it instead of deleting.
+ */
+export declare function trackActionItems<C extends {
+    trackId: string;
+}>({ session, config, view, canEdit, isSessionOverride, makeCopy, }: {
+    session: TrackActionSession<C>;
+    config: BaseTrackConfig;
+    view?: TrackActionView;
+    canEdit: boolean;
+    isSessionOverride?: boolean;
+    makeCopy: () => C;
+}): MenuItem[];
+interface SessionWithDialog {
+    queueDialog: (cb: (done: () => void) => [DialogComponentType, Record<string, unknown>]) => void;
+}
+type TrackConfig = AnyConfigurationModel | Record<string, unknown>;
+/** "About track" menu item, shared by every product's track menu */
+export declare function aboutTrackMenuItem(session: SessionWithDialog, config: TrackConfig): MenuItem;
+/**
+ * plugin-contributed per-track items (`Core-extraTrackMenuItems`), surfaced in
+ * both the hierarchical selector and the in-view label menu so plugins reach
+ * every track menu consistently
+ */
+export declare function pluginExtraTrackItems(pluginManager: PluginManager, session: SessionWithDialog, config: AnyConfigurationModel, view?: TrackActionView): MenuItem[];
+/**
+ * flattened track menu (About + raw actions) for the hierarchical track selector
+ */
+export declare function trackListMenuItems(session: SessionWithDialog, config: TrackConfig, actions: MenuItem[]): MenuItem[];
+/**
+ * track menu with an "About track" item and a "Track actions" submenu, for the
+ * in-view track label menu
+ */
+export declare function trackActionMenuItems(session: SessionWithDialog, config: TrackConfig, actions: MenuItem[]): MenuItem[];
+/**
+ * #stateModel TrackMenuItemsSessionMixin
+ *
+ * The two track-menu wrappers (`getTrackListMenuItems` for the hierarchical
+ * selector, `getTrackActionMenuItems` for the in-view label menu) shared by the
+ * full web and desktop sessions. Both are pure functions of `getTrackActions`,
+ * which each session supplies (web gates on edit rights; desktop adds indexing).
+ */
+export declare function TrackMenuItemsSessionMixin(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    /**
+     * #method
+     * flattened menu items for use in hierarchical track selector
+     */
+    getTrackListMenuItems(config: BaseTrackConfig, view?: TrackActionView): MenuItem[];
+    /**
+     * #method
+     * track menu with About + "Track actions" submenu for the in-view label
+     */
+    getTrackActionMenuItems({ config, view, }: {
+        config: BaseTrackConfig;
+        view?: TrackActionView;
+    }): MenuItem[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export {};

package/esm/Session/TrackMenu.js

@@ -0,0 +1,200 @@
+import { lazy } from 'react';
+import { InfoIcon } from '@jbrowse/core/ui/Icons';
+import { buildExtraTrackMenuItems } from '@jbrowse/core/ui/buildExtraTrackMenuItems';
+import { namesTemporaryAssembly } from '@jbrowse/core/util';
+import { getSnapshot, isStateTreeNode, types } from '@jbrowse/mobx-state-tree';
+import DeleteIcon from '@mui/icons-material/Delete';
+import CopyIcon from '@mui/icons-material/FileCopy';
+import OpenInNewIcon from '@mui/icons-material/OpenInNew';
+import SettingsIcon from '@mui/icons-material/Settings';
+import SettingsBackupRestoreIcon from '@mui/icons-material/SettingsBackupRestore';
+const AboutDialog = lazy(() => import('../ui/AboutDialog.js'));
+/**
+ * Clone a track config for "Copy track": snapshots the config, appends a unique
+ * timestamp suffix to trackId (so it doesn't collide with the original), tags
+ * " (copy)" on the name, and regenerates each displayId to the canonical
+ * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
+ * (displayId is a types.identifier, so a collision would crash MST).
+ */
+export function copyTrackSnapshot(config, opts) {
+    const snap = structuredClone(isStateTreeNode(config) ? getSnapshot(config) : config);
+    snap.trackId += `-${Date.now()}`;
+    snap.name += ' (copy)';
+    if (opts.clearCategory) {
+        snap.category = undefined;
+    }
+    for (const d of snap.displays ?? []) {
+        d.displayId = `${snap.trackId}-${d.type}`;
+    }
+    return snap;
+}
+/**
+ * The shared Settings / Copy / Copy-and-open / Delete track actions. Each
+ * product supplies `makeCopy` (its own session-track/category rules) and
+ * `canEdit`; reference sequence tracks can't be copied or deleted. When
+ * `isSessionOverride` is set the track is a session edit shadowing an
+ * admin-owned config track, so the final action resets it instead of deleting.
+ */
+export function trackActionItems({ session, config, view, canEdit, isSessionOverride, makeCopy, }) {
+    const isRefSeq = config.type === 'ReferenceSequenceTrack';
+    // A copy of a track drawn on an assembly this view synthesized is dead on
+    // arrival: the assembly goes back when the view closes, and the copy is left
+    // naming one that never existed anywhere else. Both destinations were wrong
+    // for it — `publishTrackConf` writes an admin's into the config.json every
+    // visitor is served, one per click since the copy's stamped trackId defeats
+    // the dedupe, and a non-admin's lands as the dead `sessionTracks` entry
+    // ADR-084 removed the sweep for. Neither is worth offering, so the item says
+    // so instead of producing garbage; the contract check on the adders
+    // is what found this.
+    //
+    // Greying a row tells nobody anything, and this reason is one nobody guesses:
+    // a refseq track explains its own greyed Copy, a synteny band that looks like
+    // every other track does not. `disabledHelpText` is what says it.
+    const isTemporary = namesTemporaryAssembly(session, config);
+    const copyRefusal = isRefSeq
+        ? 'A reference sequence track cannot be copied.'
+        : isTemporary
+            ? 'This track is drawn on an assembly this view synthesized, which goes away with the view — a copy of it would name an assembly nothing can resolve.'
+            : undefined;
+    // the display active in this view expands in the config editor, so the
+    // track's other (incompatible/inactive) displays start collapsed
+    const expandedDisplayId = view?.getActiveDisplayId?.(config.trackId);
+    return [
+        {
+            // always available: editing a non-session (admin-owned) track applies
+            // in-memory for the current session even when the user can't persist it
+            label: 'Settings',
+            icon: SettingsIcon,
+            onClick: () => {
+                session.editConfiguration(config, { expandedDisplayId });
+            },
+        },
+        {
+            label: 'Copy track',
+            icon: CopyIcon,
+            disabled: isRefSeq || isTemporary,
+            disabledHelpText: copyRefusal,
+            onClick: () => {
+                session.publishTrackConf(makeCopy());
+            },
+        },
+        {
+            label: 'Copy and open track',
+            icon: OpenInNewIcon,
+            disabled: isRefSeq || isTemporary || !view,
+            disabledHelpText: copyRefusal ?? (view ? undefined : 'No view to open the copy in.'),
+            onClick: () => {
+                const snap = makeCopy();
+                if (session.publishTrackConf(snap)) {
+                    void view.launchTrack(snap.trackId);
+                }
+            },
+        },
+        isSessionOverride
+            ? {
+                // a session edit of an admin-owned track: the underlying config track
+                // can't be deleted, so offer to discard the edits instead
+                label: 'Reset track settings',
+                icon: SettingsBackupRestoreIcon,
+                onClick: () => {
+                    session.resetTrackConfiguration?.(config.trackId);
+                },
+            }
+            : {
+                label: 'Delete track',
+                icon: DeleteIcon,
+                disabled: !canEdit || isRefSeq,
+                onClick: () => {
+                    session.deleteTrackConf(config);
+                },
+            },
+    ];
+}
+/** "About track" menu item, shared by every product's track menu */
+export function aboutTrackMenuItem(session, config) {
+    return {
+        label: 'About track',
+        icon: InfoIcon,
+        onClick: () => {
+            session.queueDialog(handleClose => [
+                AboutDialog,
+                { config, session, handleClose },
+            ]);
+        },
+    };
+}
+/**
+ * plugin-contributed per-track items (`Core-extraTrackMenuItems`), surfaced in
+ * both the hierarchical selector and the in-view label menu so plugins reach
+ * every track menu consistently
+ */
+export function pluginExtraTrackItems(pluginManager, session, config, view) {
+    return buildExtraTrackMenuItems(pluginManager, {
+        session: session,
+        config,
+        view,
+    });
+}
+/**
+ * flattened track menu (About + raw actions) for the hierarchical track selector
+ */
+export function trackListMenuItems(session, config, actions) {
+    return [aboutTrackMenuItem(session, config), ...actions];
+}
+/**
+ * track menu with an "About track" item and a "Track actions" submenu, for the
+ * in-view track label menu
+ */
+export function trackActionMenuItems(session, config, actions) {
+    return [
+        {
+            ...aboutTrackMenuItem(session, config),
+            priority: 1002,
+        },
+        {
+            type: 'subMenu',
+            label: 'Track actions',
+            priority: 1001,
+            subMenu: actions,
+        },
+        { type: 'divider' },
+    ];
+}
+// (TrackMenuSessionMixin — the minimal embedded-view variant — lives in its own
+// file so each documented state model is the sole one in its file, which the
+// autogen docs generator requires.)
+/**
+ * #stateModel TrackMenuItemsSessionMixin
+ *
+ * The two track-menu wrappers (`getTrackListMenuItems` for the hierarchical
+ * selector, `getTrackActionMenuItems` for the in-view label menu) shared by the
+ * full web and desktop sessions. Both are pure functions of `getTrackActions`,
+ * which each session supplies (web gates on edit rights; desktop adds indexing).
+ */
+export function TrackMenuItemsSessionMixin(pluginManager) {
+    return types.model('TrackMenuItemsSessionMixin', {}).views(s => {
+        const self = s;
+        return {
+            /**
+             * #method
+             * flattened menu items for use in hierarchical track selector
+             */
+            getTrackListMenuItems(config, view) {
+                return [
+                    ...trackListMenuItems(self, config, self.getTrackActions(config, view)),
+                    ...pluginExtraTrackItems(pluginManager, self, config, view),
+                ];
+            },
+            /**
+             * #method
+             * track menu with About + "Track actions" submenu for the in-view label
+             */
+            getTrackActionMenuItems({ config, view, }) {
+                return trackActionMenuItems(self, config, [
+                    ...self.getTrackActions(config, view),
+                    ...pluginExtraTrackItems(pluginManager, self, config, view),
+                ]);
+            },
+        };
+    });
+}

package/esm/Session/TrackMenuSessionMixin.d.ts

@@ -0,0 +1,27 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { TrackActionView } from '@jbrowse/core/util/types';
+/**
+ * #stateModel TrackMenuSessionMixin
+ *
+ * The minimal track menus used by the embedded react views, which have no
+ * track-editing actions to offer: just "About track" plus any plugin-contributed
+ * items (`Core-extraTrackMenuItems`). Mirrors the shape of the full
+ * `TrackMenuItemsSessionMixin` so both menu surfaces stay consistent across
+ * products, minus the Settings/Copy/Delete actions.
+ */
+export declare function TrackMenuSessionMixin(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    /**
+     * #method
+     * flattened menu items for use in hierarchical track selector
+     */
+    getTrackListMenuItems(config: AnyConfigurationModel, view?: TrackActionView): MenuItem[];
+    /**
+     * #method
+     */
+    getTrackActionMenuItems({ config, view, }: {
+        config: AnyConfigurationModel;
+        view?: TrackActionView;
+    }): MenuItem[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;