@jbrowse/product-core 5.0.0-beta.1 → 5.0.0-beta.3

package/esm/ui/DisplayDefaultsSection.d.ts

@@ -1,33 +1,20 @@
+import type { DisplayDefaultsSession } from './displayDefaultChanges.ts';
 import type PluginManager from '@jbrowse/core/PluginManager';
-export interface DisplayDefaultsSession {
-    getDisplayTypeDefaults: () => {
-        displayType: string;
-        slot: string;
-        value: unknown;
-    }[];
-    setDisplayTypeDefault: (displayType: string, slot: string, value: unknown) => void;
-}
+export type { DisplayDefaultsSession } from './displayDefaultChanges.ts';
 /**
  * The inventory of session-wide display-type defaults: every value the user has
  * pinned from a track menu, what it overrides, and a button to clear one.
  *
  * The pin is easy to set and, until this, hard to find again. A pinned default
  * shows on the track-selector badge of any **open** track it moves — but one
- * affecting nothing currently open, one promoted to a value equal to the slot's
- * base, and one that no longer resolves at all (a stale value the cascade
- * refuses, or a display type whose plugin is gone) appear nowhere. The only
- * place that listed them was the "Reset preferences to defaults" confirmation,
- * which is a destructive dialog to have to open in order to read something.
+ * affecting nothing currently open, and one that no longer resolves at all (a
+ * stale value the cascade refuses, or a display type whose plugin is gone)
+ * appear nowhere. The only place that listed them was the "Reset preferences to
+ * defaults" confirmation, which is a destructive dialog to have to open in
+ * order to read something.
  *
  * The empty state is deliberate rather than rendering nothing: it is the one
  * place the app says the capability exists to someone who has never used it.
- *
- * **The slot keeps its schema name**, while the display type gets its authored
- * one. A slot has no menu label to borrow — which row a setting is offered on is
- * a menu fact and declaring the slot promotable is a schema fact, and nothing
- * joins them (that split is why `promotableSlotsWithoutPin` has to walk a built
- * menu at all). A raw slot name is also what the config editor labels its fields
- * with, so the two surfaces agree.
  */
 declare const DisplayDefaultsSection: ({ session, pluginManager, }: {
     session: DisplayDefaultsSession;

package/esm/ui/DisplayDefaultsSection.js

@@ -1,65 +1,27 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getConfigurationSchemaDefinition, isSlotDefinitionEntry, } from '@jbrowse/core/configuration';
 import { SettingsChangesTable } from '@jbrowse/core/ui';
 import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
-// The registered display types, by name.
-//
-// **Built rather than reached through `getDisplayType`, which THROWS** on a name
-// no plugin registers — an optional chain over it guards nothing. A default left
-// behind by a plugin that has since been uninstalled is exactly a row this
-// section has to render, so reaching for that getter would crash the whole
-// Preferences dialog for the one user whose pins most need clearing.
-function displayTypesByName(pluginManager) {
-    return new Map(pluginManager.getDisplayElements().map(d => [d.name, d]));
-}
-// What a track sitting at the bottom of the cascade shows for this slot — the
-// value clearing the pin would restore. Read off the display type's schema
-// rather than off the session, which holds only what was promoted. Undefined
-// for a display type that is gone, whose row then reads "(default)" like any
-// other unknown.
-function promotedBaseOf(configSchema, slot) {
-    const def = configSchema
-        ? getConfigurationSchemaDefinition(configSchema)?.[slot]
-        : undefined;
-    return isSlotDefinitionEntry(def) ? def.promotedBase : undefined;
-}
+import { displayDefaultChanges, resetDisplayDefault, } from './displayDefaultChanges.js';
 /**
  * The inventory of session-wide display-type defaults: every value the user has
  * pinned from a track menu, what it overrides, and a button to clear one.
  *
  * The pin is easy to set and, until this, hard to find again. A pinned default
  * shows on the track-selector badge of any **open** track it moves — but one
- * affecting nothing currently open, one promoted to a value equal to the slot's
- * base, and one that no longer resolves at all (a stale value the cascade
- * refuses, or a display type whose plugin is gone) appear nowhere. The only
- * place that listed them was the "Reset preferences to defaults" confirmation,
- * which is a destructive dialog to have to open in order to read something.
+ * affecting nothing currently open, and one that no longer resolves at all (a
+ * stale value the cascade refuses, or a display type whose plugin is gone)
+ * appear nowhere. The only place that listed them was the "Reset preferences to
+ * defaults" confirmation, which is a destructive dialog to have to open in
+ * order to read something.
  *
  * The empty state is deliberate rather than rendering nothing: it is the one
  * place the app says the capability exists to someone who has never used it.
- *
- * **The slot keeps its schema name**, while the display type gets its authored
- * one. A slot has no menu label to borrow — which row a setting is offered on is
- * a menu fact and declaring the slot promotable is a schema fact, and nothing
- * joins them (that split is why `promotableSlotsWithoutPin` has to walk a built
- * menu at all). A raw slot name is also what the config editor labels its fields
- * with, so the two surfaces agree.
  */
 const DisplayDefaultsSection = observer(function DisplayDefaultsSection({ session, pluginManager, }) {
-    const byName = displayTypesByName(pluginManager);
-    const changes = session
-        .getDisplayTypeDefaults()
-        .map(({ displayType, slot, value }) => ({
-        // the address this section's own reset uses, so it depends on nothing the
-        // session's preference-key layout does
-        path: [displayType, slot],
-        label: `${byName.get(displayType)?.displayName ?? displayType} › ${slot}`,
-        from: promotedBaseOf(byName.get(displayType)?.configSchema, slot),
-        to: value,
-    }));
+    const changes = displayDefaultChanges(session, pluginManager);
     return changes.length ? (_jsxs(_Fragment, { children: [_jsx(Typography, { children: "These apply to every track of a display type that hasn't set its own value. Clear one to put those tracks back on the setting's default." }), _jsx(SettingsChangesTable, { changes: changes, onResetRow: change => {
-                    session.setDisplayTypeDefault(change.path[0], change.path[1], undefined);
-                } })] })) : (_jsx(Typography, { children: "None set. The pin beside a setting in a track menu makes that value the default for every track of the same display type." }));
+                    resetDisplayDefault(session, change);
+                } })] })) : (_jsx(Typography, { children: "None set. The pin beside a setting in a track menu applies that value to every open track of the same display type, and then offers to keep it as the default for the ones you open later." }));
 });
 export default DisplayDefaultsSection;

package/esm/ui/GeneralPreferencesTab.d.ts

@@ -0,0 +1,14 @@
+import type { ThemeMap } from '@jbrowse/core/ui';
+import type { AnimationMode } from '@jbrowse/core/util';
+export interface GeneralPreferencesSession {
+    allThemes: () => ThemeMap;
+    themeName?: string;
+    setThemeName: (arg: string) => void;
+    animationMode: AnimationMode;
+    numberGrouping: boolean;
+    setPreferenceOverride: (key: string, value: unknown) => void;
+}
+declare const GeneralPreferencesTab: ({ session, }: {
+    session: GeneralPreferencesSession;
+}) => import("react").JSX.Element;
+export default GeneralPreferencesTab;

package/esm/ui/GeneralPreferencesTab.js

@@ -0,0 +1,27 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { makeStyles } from '@jbrowse/core/util/tss-react';
+import { FormGroup, MenuItem, TextField } from '@mui/material';
+import { observer } from 'mobx-react';
+import PreferenceCheckbox from './PreferenceCheckbox.js';
+const useStyles = makeStyles()({
+    field: {
+        marginTop: 16,
+        display: 'block',
+    },
+});
+const ANIMATION_MODES = [
+    { value: 'system', label: 'Follow system (reduced motion)' },
+    { value: 'enabled', label: 'Always on' },
+    { value: 'disabled', label: 'Off' },
+];
+const GeneralPreferencesTab = observer(function GeneralPreferencesTab({ session, }) {
+    const { classes } = useStyles();
+    return (_jsxs(_Fragment, { children: [_jsx(TextField, { select: true, variant: "outlined", className: classes.field, label: "Theme", value: session.themeName, onChange: event => {
+                    session.setThemeName(event.target.value);
+                }, children: Object.entries(session.allThemes()).map(([key, val]) => (_jsx(MenuItem, { value: key, children: val.name || '(Unknown name)' }, key))) }), _jsx(TextField, { select: true, variant: "outlined", className: classes.field, label: "Animations", value: session.animationMode, onChange: event => {
+                    session.setPreferenceOverride('animationMode', event.target.value);
+                }, children: ANIMATION_MODES.map(opt => (_jsx(MenuItem, { value: opt.value, children: opt.label }, opt.value))) }), _jsx(FormGroup, { children: _jsx(PreferenceCheckbox, { checked: session.numberGrouping, label: "Thousand separators in numbers", help: "Shows chr1:1,234,567 rather than chr1:1234567. Takes effect after reloading the page.", onChange: checked => {
+                        session.setPreferenceOverride('numberGrouping', checked);
+                    } }) })] }));
+});
+export default GeneralPreferencesTab;

package/esm/ui/PreferenceCheckbox.d.ts

@@ -0,0 +1,6 @@
+export default function PreferenceCheckbox({ checked, label, help, onChange, }: {
+    checked: boolean;
+    label: string;
+    help?: string;
+    onChange: (checked: boolean) => void;
+}): import("react").JSX.Element;

package/esm/ui/PreferenceCheckbox.js

@@ -0,0 +1,16 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LabeledCheckbox } from '@jbrowse/core/ui';
+import { makeStyles } from '@jbrowse/core/util/tss-react';
+import { Typography } from '@mui/material';
+const useStyles = makeStyles()({
+    row: {
+        alignItems: 'flex-start',
+        marginTop: 8,
+    },
+});
+export default function PreferenceCheckbox({ checked, label, help, onChange, }) {
+    const { classes } = useStyles();
+    return (_jsx(LabeledCheckbox, { className: classes.row, checked: checked, onChange: checked => {
+            onChange(checked);
+        }, label: _jsxs(_Fragment, { children: [_jsx(Typography, { children: label }), help ? (_jsx(Typography, { variant: "body2", color: "text.secondary", children: help })) : null] }) }));
+}

package/esm/ui/PreferencesDialog.d.ts

@@ -1,35 +1,14 @@
+import type { DisplayDefaultsSession } from './DisplayDefaultsSection.tsx';
+import type { GeneralPreferencesSession } from './GeneralPreferencesTab.tsx';
+import type { ViewPreferencesSession } from './ViewPreferencesTab.tsx';
+import type { ResettablePreferencesSession } from './preferencesReset.ts';
 import type PluginManager from '@jbrowse/core/PluginManager';
-import type { ThemeMap } from '@jbrowse/core/ui';
-import type { AnimationMode, TrackConfigChange } from '@jbrowse/core/util';
 import type React from 'react';
-export interface PreferencesDialogSession {
-    allThemes: () => ThemeMap;
-    themeName?: string;
-    setThemeName: (arg: string) => void;
-    stickyViewHeaders: boolean;
-    setStickyViewHeaders: (sticky: boolean) => void;
-    effectiveUseWorkspaces: boolean;
-    defaultUseWorkspaces: boolean;
-    setUseWorkspacesPreference: (useWorkspaces: boolean) => void;
-    resetUseWorkspaces: () => void;
-    animationMode: AnimationMode;
-    numberGrouping: boolean;
-    scrollZoom: boolean;
-    setScrollZoom: (flag: boolean) => void;
-    setPreferenceOverride: (key: string, value: unknown) => void;
-    clearPreferenceOverrides: () => void;
-    getPreferenceChanges: () => TrackConfigChange[];
-    resetPreferenceChange: (path: string[]) => void;
-    getDisplayTypeDefaults: () => {
-        displayType: string;
-        slot: string;
-        value: unknown;
-    }[];
-    setDisplayTypeDefault: (displayType: string, slot: string, value: unknown) => void;
+export interface PreferencesDialogSession extends GeneralPreferencesSession, ViewPreferencesSession, DisplayDefaultsSession, ResettablePreferencesSession {
 }
 /**
  * Descriptor returned from the `Core-preferencesDialogPanels` extension point.
- * Each panel renders as its own labeled section in the dialog.
+ * Each panel renders as its own tab in the dialog, labeled by `name`.
  */
 export interface PreferencesPanelDescriptor {
     name: string;

package/esm/ui/PreferencesDialog.js

@@ -1,140 +1,59 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Suspense, useState } from 'react';
-import { Dialog, LabeledCheckbox } from '@jbrowse/core/ui';
-import { SCROLL_ZOOM_HELP, SCROLL_ZOOM_LABEL, } from '@jbrowse/core/ui/scrollZoomLabels';
+import { Dialog } from '@jbrowse/core/ui';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { Button, DialogActions, DialogContent, Divider, FormGroup, MenuItem, TextField, Typography, } from '@mui/material';
+import { Button, DialogActions, DialogContent, Tab, Tabs } from '@mui/material';
 import { observer } from 'mobx-react';
 import DisplayDefaultsSection from './DisplayDefaultsSection.js';
+import GeneralPreferencesTab from './GeneralPreferencesTab.js';
 import PreferencesResetDialog from './PreferencesResetDialog.js';
+import ViewPreferencesTab from './ViewPreferencesTab.js';
+import { collectPreferenceChanges, resetAllPreferences, resetPreferenceChange, } from './preferencesReset.js';
 const useStyles = makeStyles()({
     container: {
         width: 800,
-    },
-    panelHeading: {
-        marginTop: 16,
-    },
-    field: {
-        marginTop: 16,
-        display: 'block',
+        minHeight: 300,
     },
 });
-const PREFERENCE_SUBSYSTEMS = [
-    {
-        head: 'theme',
-        change: s => s.themeName && s.themeName !== 'default'
-            ? { path: ['theme'], from: 'default', to: s.themeName }
-            : undefined,
-        reset: s => {
-            s.setThemeName('default');
-        },
-    },
-    {
-        head: 'stickyViewHeaders',
-        change: s => s.stickyViewHeaders
-            ? undefined
-            : { path: ['stickyViewHeaders'], from: true, to: false },
-        reset: s => {
-            s.setStickyViewHeaders(true);
-        },
-    },
-    {
-        head: 'useWorkspaces',
-        // the resolved flag against the admin default, not the override map's view
-        // of it: a session-scoped value (a spec `layout`, "move view to a tab")
-        // writes no override, so the map reported nothing to reset while
-        // `resetUseWorkspaces` would plainly have turned workspaces back off —
-        // leaving the confirmation empty and its Reset button disabled
-        change: s => s.effectiveUseWorkspaces === s.defaultUseWorkspaces
-            ? undefined
-            : {
-                path: ['useWorkspaces'],
-                from: s.defaultUseWorkspaces,
-                to: s.effectiveUseWorkspaces,
-            },
-        reset: s => {
-            s.resetUseWorkspaces();
-        },
-    },
-];
-// heads the subsystems above own outright: their row states the resolved value,
-// so the session's override-map row for the same key would double-report it
-// (and disagree with it whenever the two layers differ)
-const SUBSYSTEM_HEADS = new Set(PREFERENCE_SUBSYSTEMS.map(p => p.head));
-// every preference that currently differs from its default, so the confirmation
-// dialog shows the full effect of a reset: the session override map plus each
-// non-map subsystem above.
-function collectPreferenceChanges(session) {
-    return [
-        ...session
-            .getPreferenceChanges()
-            .filter(c => !SUBSYSTEM_HEADS.has(c.path[0])),
-        ...PREFERENCE_SUBSYSTEMS.map(p => p.change(session)).filter(c => c !== undefined),
-    ];
-}
-// Reset every preference this dialog exposes back to its default: clear the
-// whole override map (scrollZoom, animationMode, all promoted display-type
-// defaults) at once, then reset each non-map subsystem through its own setter.
-function resetAllPreferences(session) {
-    session.clearPreferenceOverrides();
-    for (const p of PREFERENCE_SUBSYSTEMS) {
-        p.reset(session);
-    }
-}
-// Revert a single change row (see `collectPreferenceChanges`) to its default:
-// a non-map subsystem by matching `head`, everything else back through the
-// session that produced the row. The override map's own path shapes are the
-// session's business — it owns the composite-key layout a promoted
-// display-type default is stored under, so it also owns undoing one.
-function resetPreferenceChange(session, change) {
-    const subsystem = PREFERENCE_SUBSYSTEMS.find(p => p.head === change.path[0]);
-    if (subsystem) {
-        subsystem.reset(session);
-    }
-    else {
-        session.resetPreferenceChange(change.path);
-    }
-}
-// declarative user-preference rows backed by the session preferences-override
-// system (BaseSession getPreference/setPreferenceOverride). Add a row here to
-// surface a new preference; resolution + persistence are already handled.
-const PREFERENCE_SELECTS = [
-    {
-        key: 'animationMode',
-        label: 'Animations',
-        options: [
-            { value: 'system', label: 'Follow system (reduced motion)' },
-            { value: 'enabled', label: 'Always on' },
-            { value: 'disabled', label: 'Off' },
-        ],
-        get: session => session.animationMode,
-    },
-];
 const PreferencesDialog = observer(function PreferencesDialog({ handleClose, session, pluginManager, }) {
     const { classes } = useStyles();
-    // a confirmation dialog (showing the exact diff) guards the destructive reset,
-    // instead of an accidental single click wiping every preference
+    const [tab, setTab] = useState('general');
     const [resetDialogOpen, setResetDialogOpen] = useState(false);
-    const extraPanels = pluginManager.evaluateExtensionPoint(
-    /** #extensionPoint Core-preferencesDialogPanels | sync | Add panels to the preferences dialog */
+    const pluginPanels = pluginManager.evaluateExtensionPoint(
+    /** #extensionPoint Core-preferencesDialogPanels | sync | Add tabs to the preferences dialog */
     'Core-preferencesDialogPanels', [], { session });
-    return (_jsxs(Dialog, { title: "Preferences", open: true, onClose: handleClose, maxWidth: "xl", children: [_jsxs(DialogContent, { className: classes.container, children: [_jsx(TextField, { select: true, variant: "outlined", label: "Theme", value: session.themeName, onChange: event => {
-                            session.setThemeName(event.target.value);
-                        }, children: Object.entries(session.allThemes()).map(([key, val]) => (_jsx(MenuItem, { value: key, children: val.name || '(Unknown name)' }, key))) }), PREFERENCE_SELECTS.map(row => (_jsx(TextField, { select: true, variant: "outlined", className: classes.field, label: row.label, value: row.get(session), onChange: event => {
-                            session.setPreferenceOverride(row.key, event.target.value);
-                        }, children: row.options.map(opt => (_jsx(MenuItem, { value: opt.value, children: opt.label }, opt.value))) }, row.key))), _jsxs(FormGroup, { children: [_jsx(LabeledCheckbox, { checked: session.scrollZoom, label: `${SCROLL_ZOOM_LABEL}: ${SCROLL_ZOOM_HELP}`, onChange: checked => {
-                                    session.setScrollZoom(checked);
-                                } }), _jsx(LabeledCheckbox, { checked: session.stickyViewHeaders, label: "Keep view header visible", onChange: checked => {
-                                    session.setStickyViewHeaders(checked);
-                                } }), _jsx(LabeledCheckbox, { checked: session.effectiveUseWorkspaces, label: "Use workspaces (tabbed/tiled view layout)", onChange: checked => {
-                                    session.setUseWorkspacesPreference(checked);
-                                } }), _jsx(LabeledCheckbox, { checked: session.numberGrouping, label: "Show thousand separators in numbers, e.g. chr1:1,234,567 vs chr1:1234567 (reload app/refresh browser page to apply)", onChange: checked => {
-                                    session.setPreferenceOverride('numberGrouping', checked);
-                                } })] }), _jsx(Divider, {}), _jsx(Typography, { variant: "subtitle1", className: classes.panelHeading, children: "Display defaults" }), _jsx(DisplayDefaultsSection, { session: session, pluginManager: pluginManager }), extraPanels.map(({ name, Component }) => (_jsxs("div", { children: [_jsx(Divider, {}), _jsx(Typography, { variant: "subtitle1", className: classes.panelHeading, children: name }), _jsx(Suspense, { fallback: null, children: _jsx(Component, { session: session }) })] }, name)))] }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
+    const displayDefaultCount = session.getDisplayTypeDefaults().length;
+    const tabs = [
+        {
+            value: 'general',
+            label: 'General',
+            content: _jsx(GeneralPreferencesTab, { session: session }),
+        },
+        {
+            value: 'views',
+            label: 'Views',
+            content: _jsx(ViewPreferencesTab, { session: session }),
+        },
+        {
+            value: 'displayDefaults',
+            label: displayDefaultCount
+                ? `Display defaults (${displayDefaultCount})`
+                : 'Display defaults',
+            content: (_jsx(DisplayDefaultsSection, { session: session, pluginManager: pluginManager })),
+        },
+        ...pluginPanels.map(({ name, Component }) => ({
+            value: `plugin:${name}`,
+            label: name,
+            content: (_jsx(Suspense, { fallback: null, children: _jsx(Component, { session: session }) })),
+        })),
+    ];
+    return (_jsxs(Dialog, { title: "Preferences", open: true, onClose: handleClose, maxWidth: "xl", children: [_jsx(Tabs, { value: tab, variant: "scrollable", scrollButtons: "auto", onChange: (_, value) => {
+                    setTab(value);
+                }, children: tabs.map(t => (_jsx(Tab, { value: t.value, label: t.label }, t.value))) }), _jsx(DialogContent, { className: classes.container, children: tabs.find(t => t.value === tab)?.content }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
                             setResetDialogOpen(true);
                         }, children: "Reset to defaults\u2026" }), _jsx(Button, { variant: "contained", onClick: () => {
                             handleClose();
-                        }, children: "Close" })] }), resetDialogOpen ? (_jsx(PreferencesResetDialog, { changes: collectPreferenceChanges(session), onReset: () => {
+                        }, children: "Close" })] }), resetDialogOpen ? (_jsx(PreferencesResetDialog, { changes: collectPreferenceChanges(session, pluginManager), onReset: () => {
                     resetAllPreferences(session);
                 }, onResetRow: change => {
                     resetPreferenceChange(session, change);

package/esm/ui/ViewPreferencesTab.d.ts

@@ -0,0 +1,12 @@
+export interface ViewPreferencesSession {
+    scrollZoom: boolean;
+    setScrollZoom: (flag: boolean) => void;
+    stickyViewHeaders: boolean;
+    setStickyViewHeaders: (sticky: boolean) => void;
+    effectiveUseWorkspaces: boolean;
+    setUseWorkspacesPreference: (useWorkspaces: boolean) => void;
+}
+declare const ViewPreferencesTab: ({ session, }: {
+    session: ViewPreferencesSession;
+}) => import("react").JSX.Element;
+export default ViewPreferencesTab;

package/esm/ui/ViewPreferencesTab.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { SCROLL_ZOOM_HELP, SCROLL_ZOOM_LABEL, } from '@jbrowse/core/ui/scrollZoomLabels';
+import { FormGroup } from '@mui/material';
+import { observer } from 'mobx-react';
+import PreferenceCheckbox from './PreferenceCheckbox.js';
+const ViewPreferencesTab = observer(function ViewPreferencesTab({ session, }) {
+    return (_jsxs(FormGroup, { children: [_jsx(PreferenceCheckbox, { checked: session.scrollZoom, label: SCROLL_ZOOM_LABEL, help: SCROLL_ZOOM_HELP, onChange: checked => {
+                    session.setScrollZoom(checked);
+                } }), _jsx(PreferenceCheckbox, { checked: session.stickyViewHeaders, label: "Keep view header visible", help: "The view header stays at the top of the page while its tracks scroll under it.", onChange: checked => {
+                    session.setStickyViewHeaders(checked);
+                } }), _jsx(PreferenceCheckbox, { checked: session.effectiveUseWorkspaces, label: "Use workspaces", help: "Views open as tabs and tiles instead of stacking down the page.", onChange: checked => {
+                    session.setUseWorkspacesPreference(checked);
+                } })] }));
+});
+export default ViewPreferencesTab;

package/esm/ui/descriptionHtml.d.ts

@@ -0,0 +1,26 @@
+import type { AboutConfig } from './util.ts';
+/**
+ * The URL of a track's prose description page, as a UCSC track hub supplies it,
+ * and undefined for anything that is not an http(s) url — the value reaches
+ * `openLocation` and an anchor's href, so a `javascript:` or `file://` one does
+ * not become one here.
+ *
+ * Four spellings: `UCSCTrackHubConnection` spreads the trackDb stanza across
+ * `metadata`, the bulk converter behind genomes.jbrowse.org nests it under
+ * `metadata.ucsc` (~50,700 configs at permanent URLs), and the stanza key is
+ * `html` for a track and `htmlPath` for an assembly. Both producers write an
+ * escaped anchor rather than a bare url, so the href comes back through a parse
+ * rather than a regex.
+ */
+export declare function getDescriptionHtmlUrl(config: AboutConfig): string | undefined;
+/**
+ * A fetched description page as markup for `SanitizedHTML`: links and images
+ * resolved against the page they came from rather than the JBrowse origin, and
+ * `<form>` dropped, which the sanitizer keeps and which in a document off a
+ * third-party origin is a credential prompt wearing the app's own chrome.
+ *
+ * Parsing rather than string-rewriting is what makes taking `body` handle the
+ * pages that are whole documents in the same pass. The parse is inert — no
+ * scripts run, no images load — and the sanitizer still sees everything after.
+ */
+export declare function rebaseDescriptionHtml(html: string, baseUrl: string): string;

package/esm/ui/descriptionHtml.js

@@ -0,0 +1,66 @@
+import { readConfSlot } from '@jbrowse/core/configuration';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function descriptionUrl(value) {
+    const href = new DOMParser()
+        .parseFromString(value, 'text/html')
+        .querySelector('a[href]')
+        ?.getAttribute('href');
+    const candidate = typeof href === 'string' ? href : value.trim();
+    return /^https?:\/\//i.test(candidate) ? candidate : undefined;
+}
+/**
+ * The URL of a track's prose description page, as a UCSC track hub supplies it,
+ * and undefined for anything that is not an http(s) url — the value reaches
+ * `openLocation` and an anchor's href, so a `javascript:` or `file://` one does
+ * not become one here.
+ *
+ * Four spellings: `UCSCTrackHubConnection` spreads the trackDb stanza across
+ * `metadata`, the bulk converter behind genomes.jbrowse.org nests it under
+ * `metadata.ucsc` (~50,700 configs at permanent URLs), and the stanza key is
+ * `html` for a track and `htmlPath` for an assembly. Both producers write an
+ * escaped anchor rather than a bare url, so the href comes back through a parse
+ * rather than a regex.
+ */
+export function getDescriptionHtmlUrl(config) {
+    const metadata = readConfSlot(config, 'metadata');
+    return [metadata, isRecord(metadata) ? metadata.ucsc : undefined]
+        .flatMap(record => (isRecord(record) ? [record.html, record.htmlPath] : []))
+        .filter(candidate => typeof candidate === 'string')
+        .map(candidate => descriptionUrl(candidate))
+        .find(url => url !== undefined);
+}
+function absolute(value, baseUrl) {
+    try {
+        return new URL(value, baseUrl).href;
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * A fetched description page as markup for `SanitizedHTML`: links and images
+ * resolved against the page they came from rather than the JBrowse origin, and
+ * `<form>` dropped, which the sanitizer keeps and which in a document off a
+ * third-party origin is a credential prompt wearing the app's own chrome.
+ *
+ * Parsing rather than string-rewriting is what makes taking `body` handle the
+ * pages that are whole documents in the same pass. The parse is inert — no
+ * scripts run, no images load — and the sanitizer still sees everything after.
+ */
+export function rebaseDescriptionHtml(html, baseUrl) {
+    const doc = new DOMParser().parseFromString(html, 'text/html');
+    for (const form of doc.querySelectorAll('form')) {
+        form.remove();
+    }
+    for (const el of doc.querySelectorAll('[href], [src]')) {
+        for (const attribute of ['href', 'src']) {
+            const value = el.getAttribute(attribute);
+            if (value) {
+                el.setAttribute(attribute, absolute(value, baseUrl));
+            }
+        }
+    }
+    return doc.body.innerHTML;
+}

package/esm/ui/displayDefaultChanges.d.ts

@@ -0,0 +1,31 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { TrackConfigChange } from '@jbrowse/core/util';
+export interface DisplayDefaultsSession {
+    getDisplayTypeDefaults: () => {
+        displayType: string;
+        slot: string;
+        value: unknown;
+    }[];
+    setDisplayTypeDefault: (displayType: string, slot: string, value: unknown) => void;
+}
+/**
+ * Every promoted display-type default as a settings row: what it overrides
+ * (the slot's `promotedBase`), the value, and a label naming the display type
+ * the way the user knows it. One builder for the two surfaces that list them,
+ * the Display defaults section and the "Reset to defaults" confirmation, which
+ * used to render the same default two ways.
+ *
+ * **The slot keeps its schema name**, while the display type gets its authored
+ * one. A slot has no menu label to borrow — which row a setting is offered on is
+ * a menu fact and declaring the slot promotable is a schema fact, and nothing
+ * joins them (that split is why `promotableSlotsWithoutPin` has to walk a built
+ * menu at all). A raw slot name is also what the config editor labels its fields
+ * with, so the two surfaces agree.
+ */
+export declare function displayDefaultChanges(session: DisplayDefaultsSession, pluginManager: PluginManager): TrackConfigChange[];
+/**
+ * Clear the promoted default a row built by {@link displayDefaultChanges}
+ * stands for. Returns false for any other row, so a table mixing both kinds
+ * can hand every reset here first.
+ */
+export declare function resetDisplayDefault(session: DisplayDefaultsSession, change: TrackConfigChange): boolean;

package/esm/ui/displayDefaultChanges.js

@@ -0,0 +1,66 @@
+import { getConfigurationSchemaDefinition, isSlotDefinitionEntry, } from '@jbrowse/core/configuration';
+// Head of the path a promoted default's row carries, so `resetDisplayDefault`
+// can tell it from a scalar preference row in the same table. Module-private:
+// the one producer and the one consumer of the shape are both here, which is
+// what lets the session know nothing about how the Preferences dialog
+// addresses a row.
+const DISPLAY_DEFAULT_PATH_HEAD = 'displayTypeDefaults';
+// The registered display types, by name.
+//
+// **Built rather than reached through `getDisplayType`, which THROWS** on a name
+// no plugin registers — an optional chain over it guards nothing. A default left
+// behind by a plugin that has since been uninstalled is exactly a row this
+// section has to render, so reaching for that getter would crash the whole
+// Preferences dialog for the one user whose pins most need clearing.
+function displayTypesByName(pluginManager) {
+    return new Map(pluginManager.getDisplayElements().map(d => [d.name, d]));
+}
+// What a track sitting at the bottom of the cascade shows for this slot — the
+// value clearing the pin would restore. Read off the display type's schema
+// rather than off the session, which holds only what was promoted. Undefined
+// for a display type that is gone, whose row then reads "(default)" like any
+// other unknown.
+function promotedBaseOf(configSchema, slot) {
+    const def = configSchema
+        ? getConfigurationSchemaDefinition(configSchema)?.[slot]
+        : undefined;
+    return isSlotDefinitionEntry(def) ? def.promotedBase : undefined;
+}
+/**
+ * Every promoted display-type default as a settings row: what it overrides
+ * (the slot's `promotedBase`), the value, and a label naming the display type
+ * the way the user knows it. One builder for the two surfaces that list them,
+ * the Display defaults section and the "Reset to defaults" confirmation, which
+ * used to render the same default two ways.
+ *
+ * **The slot keeps its schema name**, while the display type gets its authored
+ * one. A slot has no menu label to borrow — which row a setting is offered on is
+ * a menu fact and declaring the slot promotable is a schema fact, and nothing
+ * joins them (that split is why `promotableSlotsWithoutPin` has to walk a built
+ * menu at all). A raw slot name is also what the config editor labels its fields
+ * with, so the two surfaces agree.
+ */
+export function displayDefaultChanges(session, pluginManager) {
+    const byName = displayTypesByName(pluginManager);
+    return session
+        .getDisplayTypeDefaults()
+        .map(({ displayType, slot, value }) => ({
+        path: [DISPLAY_DEFAULT_PATH_HEAD, displayType, slot],
+        label: `${byName.get(displayType)?.displayName ?? displayType} › ${slot}`,
+        from: promotedBaseOf(byName.get(displayType)?.configSchema, slot),
+        to: value,
+    }));
+}
+/**
+ * Clear the promoted default a row built by {@link displayDefaultChanges}
+ * stands for. Returns false for any other row, so a table mixing both kinds
+ * can hand every reset here first.
+ */
+export function resetDisplayDefault(session, change) {
+    const [head, displayType, slot] = change.path;
+    const isDisplayDefault = head === DISPLAY_DEFAULT_PATH_HEAD && !!displayType && !!slot;
+    if (isDisplayDefault) {
+        session.setDisplayTypeDefault(displayType, slot, undefined);
+    }
+    return isDisplayDefault;
+}