@jbrowse/plugin-config 5.0.0-beta.1 → 5.0.0-beta.10

package/esm/ConfigurationEditorWidget/components/AddNewField.d.ts

@@ -1,4 +1,6 @@
-export default function AddNewField({ onAdd, testid, }: {
+import type { ReactNode } from 'react';
+export default function AddNewField({ onAdd, testid, startAdornment, }: {
     onAdd: (value: string) => void;
     testid?: string;
+    startAdornment?: ReactNode;
 }): import("react").JSX.Element;

package/esm/ConfigurationEditorWidget/components/AddNewField.js

@@ -4,7 +4,7 @@ import AddIcon from '@mui/icons-material/Add';
 import { IconButton, InputAdornment, TextField } from '@mui/material';
 // shared "add new" entry field used by the string-array and map slot editors:
 // a text box that commits its contents via onAdd and clears itself
-export default function AddNewField({ onAdd, testid, }) {
+export default function AddNewField({ onAdd, testid, startAdornment, }) {
     const [value, setValue] = useState('');
     function commit() {
         if (value !== '') {
@@ -20,6 +20,7 @@ export default function AddNewField({ onAdd, testid, }) {
             }
         }, slotProps: {
             input: {
+                startAdornment,
                 endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { "data-testid": testid, disabled: value === '', onClick: () => {
                             commit();
                         }, children: _jsx(AddIcon, {}) }) })),

package/esm/ConfigurationEditorWidget/components/BooleanEditor.d.ts

@@ -3,7 +3,6 @@ declare const BooleanEditor: ({ slot, }: {
     slot: {
         name: string;
         value: boolean | undefined;
-        promotedBase?: unknown;
         set: (arg: boolean) => void;
         description: string;
     };

package/esm/ConfigurationEditorWidget/components/BooleanEditor.js

@@ -4,20 +4,7 @@ import { FormControl, FormHelperText } from '@mui/material';
 import { observer } from 'mobx-react';
 /** #slotEditor checkbox */
 const BooleanEditor = observer(function BooleanEditor({ slot, }) {
-    return (_jsxs(FormControl, { children: [_jsx(LabeledCheckbox, { label: slot.name, 
-                // An unset promotable slot renders its `promotedBase`, not `false`.
-                // Coercing every unset slot to unchecked mis-stated the three whose
-                // base is `true` (displayDirectionalChevrons, showSashimiArcs,
-                // readConnectionsDown): the box read unchecked on a track that was
-                // drawing chevrons, and ticking it wrote the value the track already
-                // had — no visible change, but the slot silently left the cascade and
-                // stopped following later session-wide defaults. The reset button
-                // (SlotEditor's `modified`) is what still separates inherited from
-                // customized; this only fixes which state is *shown*. The session tier
-                // is out of reach here, so a value promoted this session isn't
-                // reflected — see agent-docs/ideas/promotable-slot-ui.md, which is
-                // where that raw-vs-resolved gap is worked out.
-                checked: slot.value ?? !!slot.promotedBase, onChange: val => {
+    return (_jsxs(FormControl, { children: [_jsx(LabeledCheckbox, { label: slot.name, checked: !!slot.value, onChange: val => {
                     slot.set(val);
                 } }), _jsx(FormHelperText, { children: slot.description })] }));
 });

package/esm/ConfigurationEditorWidget/components/ColorEditor.d.ts

@@ -1,9 +1,10 @@
 /** #slotEditor text field beside a swatch that opens a color picker */
-declare const ColorEditor: (props: {
+declare const ColorEditor: ({ slot, }: {
     slot: {
         name: string;
         value: string | undefined;
         description: string;
+        contextVariable?: string[];
         set: (arg: string) => void;
     };
 }) => import("react").JSX.Element;

package/esm/ConfigurationEditorWidget/components/ColorEditor.js

@@ -1,5 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Suspense, lazy } from 'react';
+import { Suspense, lazy, useState } from 'react';
+import { isCssColor } from '@jbrowse/core/util/colorBits';
+import { isJexl } from '@jbrowse/core/util/jexlStrings';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { observer } from 'mobx-react';
 import ConfigurationTextField from './ConfigurationTextField.js';
@@ -17,18 +19,33 @@ const useStyles = makeStyles()({
 });
 // Also drives `maybeColor`, whose value is `undefined` while unset. An empty
 // string keeps the field controlled and the picker fed, the same way
-// NumberEditor renders an unset `maybeNumber` as an empty field. Clearing the
-// field writes `''` rather than restoring `undefined` — "unset" is reachable
-// through the slot's reset button, which is where every other slot type puts it.
+// NumberEditor renders an unset `maybeNumber` as an empty field. The slot
+// refuses what is not a color, so text that does not parse yet stays a draft
+// in the field and reaches the slot once it does; leaving the field drops an
+// unparsed draft. "Unset" is reachable through the slot's reset button, which
+// is where every other slot type puts it. Only a slot declaring a
+// `contextVariable` takes a `jexl:` callback, which an entry of a colour list
+// never does.
 /** #slotEditor text field beside a swatch that opens a color picker */
-const ColorEditor = observer(function ColorEditor(props) {
-    const { slot } = props;
+const ColorEditor = observer(function ColorEditor({ slot, }) {
+    const admitsJexl = !!slot.contextVariable?.length;
     const { classes } = useStyles();
+    const [draft, setDraft] = useState();
     const value = slot.value ?? '';
-    return (_jsxs("div", { className: classes.root, children: [_jsx(ConfigurationTextField, { value: value, label: slot.name, helperText: slot.description, className: classes.field, onChange: event => {
-                    slot.set(event.target.value);
+    return (_jsxs("div", { className: classes.root, children: [_jsx(ConfigurationTextField, { value: draft ?? value, label: slot.name, error: draft !== undefined, helperText: draft === undefined ? slot.description : `"${draft}" is not a color`, className: classes.field, onChange: event => {
+                    const text = event.target.value;
+                    if (isCssColor(text) || (admitsJexl && isJexl(text))) {
+                        slot.set(text);
+                        setDraft(undefined);
+                    }
+                    else {
+                        setDraft(text);
+                    }
+                }, onBlur: () => {
+                    setDraft(undefined);
                 } }), _jsx(Suspense, { fallback: null, children: _jsx(PopoverPicker, { color: value, onChange: color => {
                         slot.set(color);
+                        setDraft(undefined);
                     } }) })] }));
 });
 export default ColorEditor;

package/esm/ConfigurationEditorWidget/components/ConfigurationEditor.js

@@ -1,22 +1,22 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
-import { getSlotDefinition, getTypeNamesFromExplicitlyTypedUnion, isConfigurationModel, isConfigurationSchemaType, isConfigurationSlot, makeSlotFacade, readConfObject, } from '@jbrowse/core/configuration';
+import { arraySlotUnion, getSlotDefinition, getTypeNamesFromExplicitlyTypedUnion, isConfigurationModel, isConfigurationSchemaType, isConfigurationSlot, makeSlotFacade, readConfObject, setConf, } from '@jbrowse/core/configuration';
 import SanitizedHTML from '@jbrowse/core/ui/SanitizedHTML';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { getMembers } from '@jbrowse/mobx-state-tree';
+import { getMembers, getSnapshot } from '@jbrowse/mobx-state-tree';
+import ArrowDownwardIcon from '@mui/icons-material/ArrowDownward';
+import ArrowUpwardIcon from '@mui/icons-material/ArrowUpward';
 import ClearIcon from '@mui/icons-material/Clear';
+import DeleteIcon from '@mui/icons-material/Delete';
 import ExpandLessIcon from '@mui/icons-material/ExpandLess';
 import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
 import SearchIcon from '@mui/icons-material/Search';
-import { Accordion, AccordionDetails, AccordionSummary, Button, IconButton, InputAdornment, TextField, Typography, } from '@mui/material';
+import { Accordion, AccordionDetails, AccordionSummary, Button, IconButton, InputAdornment, MenuItem, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
 import SlotEditor from './SlotEditor.js';
 import TypeSelector from './TypeSelector.js';
 import { singularSlotName } from './singularSlotName.js';
 const useStyles = makeStyles()(theme => ({
-    icon: {
-        color: theme.palette.tertiary.contrastText || '#fff',
-    },
     expansionPanelDetails: {
         display: 'block',
         padding: theme.spacing(1),
@@ -39,7 +39,15 @@ const useStyles = makeStyles()(theme => ({
         margin: theme.spacing(1, 0),
         textTransform: 'none',
     },
+    entryControls: {
+        display: 'flex',
+        justifyContent: 'flex-end',
+    },
 }));
+// The entries of an array of sub-schemas as snapshots, for a whole-list write.
+function listSnapshot(schema, listName) {
+    return [...getSnapshot(schema[listName])];
+}
 // matches a slot or sub-schema against a lowercased filter string, recursing
 // into sub-schemas so a nested slot name keeps its ancestors visible
 function memberMatches(schema, slotName, slotSchema, query) {
@@ -53,7 +61,7 @@ function memberMatches(schema, slotName, slotSchema, query) {
         return (slotName.toLowerCase().includes(query) ||
             (Array.isArray(slot)
                 ? slot.some(subslot => schemaMatches(subslot, query))
-                : schemaMatches(slot, query)));
+                : slot !== undefined && schemaMatches(slot, query)));
     }
     else {
         return false;
@@ -77,9 +85,32 @@ function displayDefaultExpanded(slot, expandedDisplayId) {
         : undefined;
     return !displayId || !expandedDisplayId || displayId === expandedDisplayId;
 }
+// A union list entry's own controls: its type, and its place in the list. Each
+// is one whole-list write, so every state it leaves loads again.
+const EntryControls = observer(function EntryControls({ schema, title, slot, entry: { listName, choices, index, count }, }) {
+    const { classes } = useStyles();
+    const write = (edit) => {
+        setConf(schema, listName, edit(listSnapshot(schema, listName)));
+    };
+    const swap = (at) => {
+        write(list => list.toSpliced(at, 2, list[at + 1], list[at]));
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: classes.entryControls, children: [_jsx(IconButton, { "aria-label": `move ${title} up`, disabled: index === 0, onClick: () => {
+                            swap(index - 1);
+                        }, children: _jsx(ArrowUpwardIcon, { fontSize: "small" }) }), _jsx(IconButton, { "aria-label": `move ${title} down`, disabled: index === count - 1, onClick: () => {
+                            swap(index);
+                        }, children: _jsx(ArrowDownwardIcon, { fontSize: "small" }) }), _jsx(IconButton, { "aria-label": `remove ${title}`, onClick: () => {
+                            write(list => list.toSpliced(index, 1));
+                        }, children: _jsx(DeleteIcon, { fontSize: "small" }) })] }), _jsx(TypeSelector, { typeNameChoices: choices, slotName: title, slot: slot, onChange: evt => {
+                    const type = evt.target.value;
+                    if (type !== slot.type) {
+                        write(list => list.with(index, { type }));
+                    }
+                } })] }));
+});
 const Member = observer(function Member(props) {
     const { classes } = useStyles();
-    const { slotName, slotSchema, schema, slot = schema[slotName], path = [], filter = '', expandedDisplayId, } = props;
+    const { slotName, slotSchema, schema, slot = schema[slotName], path = [], filter = '', expandedDisplayId, entry, } = props;
     // when the sub-schema's own name matches, drop the filter for its children so
     // the whole group stays visible; otherwise keep filtering descendants
     const childFilter = slotName.toLowerCase().includes(filter.toLowerCase())
@@ -91,12 +122,7 @@ const Member = observer(function Member(props) {
         // keyed on Array.isArray, not `.length` truthiness, so an empty array maps
         // to nothing instead of being mis-handled as a single schema
         if (Array.isArray(slot)) {
-            return slot.map((subslot, slotIndex) => {
-                const key = subslot.type
-                    ? `${singularSlotName(slotName)} ${subslot.type}`
-                    : `${singularSlotName(slotName)} ${slotIndex + 1}`;
-                return _jsx(Member, { ...props, slot: subslot, slotName: key }, key);
-            });
+            return _jsx(EntryList, { ...props, entries: slot });
         }
         // if this is an explicitly typed schema, make a type-selecting dropdown
         // that can be used to change its type
@@ -107,13 +133,11 @@ const Member = observer(function Member(props) {
         // visible, not just present in the collapsed DOM. The key flips the
         // accordion between filtered/unfiltered mounts so the new
         // defaultExpanded takes effect (Accordion reads it only on mount).
-        , { defaultExpanded: filter ? true : displayDefaultExpanded(slot, expandedDisplayId), className: classes.accordion, children: [_jsx(AccordionSummary, { expandIcon: _jsx(ExpandMoreIcon, { className: classes.icon }), children: _jsx(Typography, { children: [...path, slotName].join('➔') }) }), _jsxs(AccordionDetails, { className: classes.expansionPanelDetails, children: [typeNameChoices.length ? (_jsx(TypeSelector, { typeNameChoices: typeNameChoices, slotName: slotName, slot: slot, onChange: evt => {
-                                if (evt.target.value !== slot.type) {
-                                    schema.setSubschema(slotName, {
-                                        type: evt.target.value,
-                                    });
+        , { defaultExpanded: filter ? true : displayDefaultExpanded(slot, expandedDisplayId), className: classes.accordion, children: [_jsx(AccordionSummary, { expandIcon: _jsx(ExpandMoreIcon, {}), children: _jsx(Typography, { children: [...path, slotName].join('➔') }) }), _jsxs(AccordionDetails, { className: classes.expansionPanelDetails, children: [entry && slot ? (_jsx(EntryControls, { schema: schema, title: slotName, slot: slot, entry: entry })) : null, typeNameChoices.length ? (_jsx(TypeSelector, { typeNameChoices: typeNameChoices, slotName: slotName, slot: slot, onChange: evt => {
+                                if (evt.target.value !== slot?.type) {
+                                    setConf(schema, slotName, { type: evt.target.value });
                                 }
-                            } })) : null, _jsx("div", { className: classes.noOverflow, children: _jsx(Schema, { schema: slot, path: [...path, slotName], filter: childFilter, expandedDisplayId: expandedDisplayId }) })] })] }, filter ? 'filtered' : 'unfiltered'));
+                            } })) : null, slot ? (_jsx("div", { className: classes.noOverflow, children: _jsx(Schema, { schema: slot, path: [...path, slotName], filter: childFilter, expandedDisplayId: expandedDisplayId }) })) : null] })] }, filter ? 'filtered' : 'unfiltered'));
     }
     else if (isConfigurationSlot(schema, slotName)) {
         return _jsx(SlotEditor, { slot: makeSlotFacade(schema, slotName) }, slotName);
@@ -122,6 +146,30 @@ const Member = observer(function Member(props) {
         return null;
     }
 });
+// An array of sub-schemas, one accordion per entry. A list whose entries are a
+// `ConfigurationSchemaUnion` also offers each entry's type and place, and a new
+// entry of any member type; a pluggable union such as a track's `displays` is
+// not one, since a display is added through the track.
+const EntryList = observer(function EntryList(props) {
+    const { classes } = useStyles();
+    const { slotName, slotSchema, schema, entries } = props;
+    const singular = singularSlotName(slotName);
+    const union = arraySlotUnion(slotSchema);
+    const choices = union ? Object.keys(union.members) : [];
+    return (_jsxs(_Fragment, { children: [entries.map((subslot, index) => {
+                const title = `${singular} ${index + 1}`;
+                return (_jsx(Member
+                // eslint-disable-next-line @eslint-react/no-array-index-key -- a config entry has no identity but its place
+                , { ...props, slot: subslot, slotName: union || !subslot.type ? title : `${title} ${subslot.type}`, entry: union
+                        ? { listName: slotName, choices, index, count: entries.length }
+                        : undefined }, index));
+            }), union ? (_jsx(TextField, { className: classes.filter, select: true, size: "small", label: `Add ${singular}`, value: "", onChange: evt => {
+                    setConf(schema, slotName, [
+                        ...listSnapshot(schema, slotName),
+                        { type: evt.target.value },
+                    ]);
+                }, fullWidth: true, children: choices.map(type => (_jsx(MenuItem, { value: type, children: type }, type))) })) : null] }));
+});
 const Schema = observer(function Schema({ schema, path = [], filter = '', expandedDisplayId, }) {
     const { classes } = useStyles();
     const [showAdvanced, setShowAdvanced] = useState(false);
@@ -147,7 +195,7 @@ const ConfigurationEditor = observer(function ConfigurationEditor({ model, }) {
     }
     const key = readConfObject(target, 'trackId');
     const name = readConfObject(target, 'name');
-    return (_jsxs(Accordion, { defaultExpanded: true, className: classes.accordion, children: [_jsx(AccordionSummary, { expandIcon: _jsx(ExpandMoreIcon, { className: classes.icon }), children: _jsx(Typography, { children: _jsx(SanitizedHTML, { html: name ?? 'Configuration' }) }) }), _jsxs(AccordionDetails, { className: classes.expansionPanelDetails, "data-testid": "configEditor", children: [_jsx(TextField, { className: classes.filter, label: "Filter options", value: filter, onChange: evt => {
+    return (_jsxs(Accordion, { defaultExpanded: true, className: classes.accordion, children: [_jsx(AccordionSummary, { expandIcon: _jsx(ExpandMoreIcon, {}), children: _jsx(Typography, { children: _jsx(SanitizedHTML, { html: name ?? 'Configuration' }) }) }), _jsxs(AccordionDetails, { className: classes.expansionPanelDetails, "data-testid": "configEditor", children: [_jsx(TextField, { className: classes.filter, label: "Filter options", value: filter, onChange: evt => {
                             setFilter(evt.target.value);
                         }, size: "small", fullWidth: true, slotProps: {
                             input: {

package/esm/ConfigurationEditorWidget/components/EntryListEditor.d.ts

@@ -0,0 +1,17 @@
+interface ListSlot {
+    name: string;
+    value: string[];
+    description: string;
+    set: (arg: string[]) => void;
+}
+/** #slotEditor a text field and color picker per entry, with add and delete */
+declare const ColorArrayEditor: ({ slot, }: {
+    slot: ListSlot;
+}) => import("react").JSX.Element;
+/** #slotEditor a dropdown of the `model`'s members per entry, with add and delete */
+declare const StringEnumArrayEditor: ({ slot, }: {
+    slot: ListSlot & {
+        choices?: string[];
+    };
+}) => import("react").JSX.Element;
+export { ColorArrayEditor, StringEnumArrayEditor };

package/esm/ConfigurationEditorWidget/components/EntryListEditor.js

@@ -0,0 +1,35 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import AddIcon from '@mui/icons-material/Add';
+import DeleteIcon from '@mui/icons-material/Delete';
+import { FormHelperText, IconButton, InputLabel, List, ListItem, MenuItem, } from '@mui/material';
+import { observer } from 'mobx-react';
+import ColorEditor from './ColorEditor.js';
+import ConfigurationTextField from './ConfigurationTextField.js';
+// A list slot whose entries each take one control: the list is written whole
+// on every change, and "add" appends an entry the slot already admits, so no
+// write can hold an entry the slot refuses.
+const EntryList = observer(function EntryList({ slot, entry, added, }) {
+    const value = [...slot.value];
+    const addition = added(value);
+    return (_jsxs(_Fragment, { children: [slot.name ? _jsx(InputLabel, { children: slot.name }) : null, _jsxs(List, { disablePadding: true, children: [value.map((v, idx) => (_jsxs(ListItem, { disableGutters: true, children: [entry(v, next => {
+                                slot.set(value.map((old, i) => (i === idx ? next : old)));
+                            }), _jsx(IconButton, { "aria-label": "delete entry", onClick: () => {
+                                    slot.set(value.filter((_, i) => i !== idx));
+                                }, children: _jsx(DeleteIcon, {}) })] }, idx))), _jsx(ListItem, { disableGutters: true, children: _jsx(IconButton, { "data-testid": `entryAdd-${slot.name}`, "aria-label": "add entry", disabled: addition === undefined, onClick: () => {
+                                if (addition !== undefined) {
+                                    slot.set([...value, addition]);
+                                }
+                            }, children: _jsx(AddIcon, {}) }) })] }), _jsx(FormHelperText, { children: slot.description })] }));
+});
+/** #slotEditor a text field and color picker per entry, with add and delete */
+const ColorArrayEditor = observer(function ColorArrayEditor({ slot, }) {
+    return (_jsx(EntryList, { slot: slot, added: value => value.at(-1) ?? 'black', entry: (color, set) => (_jsx(ColorEditor, { slot: { name: '', description: '', value: color, set } })) }));
+});
+/** #slotEditor a dropdown of the `model`'s members per entry, with add and delete */
+const StringEnumArrayEditor = observer(function StringEnumArrayEditor({ slot, }) {
+    const choices = slot.choices ?? [];
+    return (_jsx(EntryList, { slot: slot, added: () => choices[0], entry: (member, set) => (_jsx(ConfigurationTextField, { select: true, value: member, onChange: evt => {
+                set(evt.target.value);
+            }, children: choices.map(choice => (_jsx(MenuItem, { value: choice, children: choice }, choice))) })) }));
+});
+export { ColorArrayEditor, StringEnumArrayEditor };

package/esm/ConfigurationEditorWidget/components/JsonEditor.d.ts

@@ -4,7 +4,6 @@ declare const JsonEditor: ({ slot, }: {
         name: string;
         description: string;
         value: unknown;
-        promotedBase?: unknown;
         set: (arg: unknown) => void;
     };
 }) => import("react").JSX.Element;

package/esm/ConfigurationEditorWidget/components/JsonEditor.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useState } from 'react';
 import { MonospaceTextField } from '@jbrowse/core/ui';
+import { alpha } from '@jbrowse/core/ui/palette';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { observer } from 'mobx-react';
 const useStyles = makeStyles()(theme => ({
@@ -9,22 +10,17 @@ const useStyles = makeStyles()(theme => ({
         background: theme.palette.background.default,
         width: '100%',
         marginTop: '16px',
-        border: '1px solid rgba(0,0,0,0.42)',
+        border: `1px solid ${alpha(theme.palette.text.primary, 0.42)}`,
     },
 }));
 /** #slotEditor monospace textarea holding arbitrary JSON */
 const JsonEditor = observer(function JsonEditor({ slot, }) {
     const { classes } = useStyles();
-    // A `maybeFrozen` slot is `undefined` when unset — the promotable inherit
-    // state (alignments/synteny `colorBy`). `JSON.stringify(undefined)` returns
-    // the *value* `undefined`, not a string, so seeding straight off `slot.value`
-    // handed MonospaceTextField an undefined `value` and made the field
-    // uncontrolled until the first keystroke (React then warns on the switch).
-    // Show what unset resolves to instead, as BooleanEditor does.
-    const [contents, setContents] = useState(() => {
-        const shown = slot.value ?? slot.promotedBase;
-        return shown === undefined ? '' : JSON.stringify(shown, null, 2);
-    });
+    // A `maybeFrozen` slot is `undefined` when unset, and `JSON.stringify(undefined)`
+    // returns the *value* `undefined` rather than a string — which handed
+    // MonospaceTextField an undefined `value` and made the field uncontrolled
+    // until the first keystroke (React then warns on the switch).
+    const [contents, setContents] = useState(() => slot.value === undefined ? '' : JSON.stringify(slot.value, null, 2));
     const [error, setError] = useState();
     return (_jsx(MonospaceTextField, { className: classes.jsonEditor, label: slot.name, value: contents, error: error, helperText: slot.description, onChange: val => {
             setContents(val);

package/esm/ConfigurationEditorWidget/components/NumberEditor.d.ts

@@ -4,7 +4,6 @@ declare const NumberEditor: ({ slot, integer, }: {
         name?: string;
         value: number | undefined;
         description?: string;
-        promotedBase?: unknown;
         set: (val: number) => void;
     };
     integer?: boolean;

package/esm/ConfigurationEditorWidget/components/NumberEditor.js

@@ -5,16 +5,7 @@ import ConfigurationTextField from './ConfigurationTextField.js';
 /** #slotEditor numeric text field */
 const NumberEditor = observer(function NumberEditor({ slot, integer = false, }) {
     const [val, setVal] = useState(slot.value === undefined ? '' : String(slot.value));
-    // An unset `maybeNumber` is a promotable slot's inherit sentinel, and an
-    // empty box is the honest rendering of it — a number field, unlike a
-    // checkbox, has a state for "nothing". What it did not say is what the track
-    // is therefore drawing at, so `featureHeight` read as a blank with no clue
-    // that reads are 7px tall. The placeholder is that, in the affordance meant
-    // for it; the label has to float for MUI to draw one over a labelled field.
-    const placeholder = slot.value === undefined && slot.promotedBase !== undefined
-        ? String(slot.promotedBase)
-        : undefined;
-    return (_jsx(ConfigurationTextField, { label: slot.name, helperText: slot.description, placeholder: placeholder, slotProps: placeholder ? { inputLabel: { shrink: true } } : undefined, value: val, onChange: evt => {
+    return (_jsx(ConfigurationTextField, { label: slot.name, helperText: slot.description, value: val, onChange: evt => {
             const v = evt.target.value;
             setVal(v);
             const num = Number(v);

package/esm/ConfigurationEditorWidget/components/SlotEditor.js

@@ -10,16 +10,21 @@ import BooleanEditor from './BooleanEditor.js';
 import CallbackEditor from './CallbackEditor.js';
 import ColorEditor from './ColorEditor.js';
 import ConfigurationTextField from './ConfigurationTextField.js';
+import { ColorArrayEditor, StringEnumArrayEditor } from './EntryListEditor.js';
 import IntegerEditor from './IntegerEditor.js';
 import JsonEditor from './JsonEditor.js';
 import NumberEditor from './NumberEditor.js';
 import NumberMapEditor from './NumberMapEditor.js';
-import StringArrayEditor from './StringArrayEditor.js';
+import StringArrayEditor, { ExpressionArrayEditor, } from './StringArrayEditor.js';
 import StringArrayMapEditor from './StringArrayMapEditor.js';
+import StringMapEditor from './StringMapEditor.js';
 import { useSlotEditorStyles } from './useSlotEditorStyles.js';
+// Also drives `maybeString`, whose value is `undefined` while unset: clearing
+// the field leaves the empty string, which is a value, and the reset button
+// returns the slot to unset.
 /** #slotEditor single-line text field */
 const StringEditor = observer(function StringEditor({ slot, }) {
-    return (_jsx(ConfigurationTextField, { label: slot.name, helperText: slot.description, value: slot.value, onChange: evt => {
+    return (_jsx(ConfigurationTextField, { label: slot.name, helperText: slot.description, value: slot.value ?? '', onChange: evt => {
             slot.set(evt.target.value);
         } }));
 });
@@ -36,18 +41,10 @@ const UNSET_CHOICE = '';
 /** #slotEditor dropdown of the `model`'s members */
 const StringEnumEditor = observer(function StringEnumEditor({ slot, }) {
     const nullable = slot.type === 'maybeStringEnum';
-    // Naming the member unset resolves to, rather than a bare "default": every
-    // other choice in the list is a value the user can read off the plot, and
-    // this one was the only one that said nothing about what picking it draws.
-    // `promotedBase` is the honest half to show — the editor's target is often a
-    // detached config node, so it cannot see a value promoted this session.
-    const unsetLabel = typeof slot.promotedBase === 'string'
-        ? `default (${slot.promotedBase})`
-        : 'default';
     return (_jsxs(ConfigurationTextField, { value: slot.value ?? UNSET_CHOICE, label: slot.name, select: true, helperText: slot.description, onChange: evt => {
             const { value } = evt.target;
             slot.set(value === UNSET_CHOICE ? undefined : value);
-        }, children: [nullable ? (_jsx(MenuItem, { value: UNSET_CHOICE, children: _jsx("em", { children: unsetLabel }) })) : null, (slot.choices ?? []).map(str => (_jsx(MenuItem, { value: str, children: str }, str)))] }));
+        }, children: [nullable ? (_jsx(MenuItem, { value: UNSET_CHOICE, children: _jsx("em", { children: "default" }) })) : null, (slot.choices ?? []).map(str => (_jsx(MenuItem, { value: str, children: str }, str)))] }));
 });
 /** #slotEditor URL, local file path (desktop) or file blob (browser) */
 const FileSelectorWrapper = observer(function FileSelectorWrapper({ slot, }) {
@@ -62,11 +59,18 @@ const FileSelectorWrapper = observer(function FileSelectorWrapper({ slot, }) {
 // The editors stay fully typed internally; only this lookup is untyped.
 const valueComponents = {
     string: StringEditor,
+    maybeString: StringEditor,
+    featureField: StringEditor,
     text: TextEditor,
     fileLocation: FileSelectorWrapper,
+    maybeFileLocation: FileSelectorWrapper,
     stringArray: StringArrayEditor,
+    expressionArray: ExpressionArrayEditor,
+    colorArray: ColorArrayEditor,
+    stringEnumArray: StringEnumArrayEditor,
     stringArrayMap: StringArrayMapEditor,
     numberMap: NumberMapEditor,
+    stringMap: StringMapEditor,
     number: NumberEditor,
     maybeNumber: NumberEditor,
     integer: IntegerEditor,
@@ -85,8 +89,10 @@ const SlotEditor = observer(function SlotEditor({ slot, }) {
     // editor mode is UI-only state, derived once from whether the stored value is
     // a jexl callback. Toggling rewrites the value; typing a "jexl:" prefix into a
     // value field does not auto-swap the editor, since this state only changes on
-    // the explicit toggle.
-    const [callbackMode, setCallbackMode] = useState(() => isCallbackValue(slot.value));
+    // the explicit toggle. A featureField's `jexl:` expression is a field, typed
+    // in its own text field.
+    const callback = slot.contextVariable.length > 0;
+    const [callbackMode, setCallbackMode] = useState(() => callback && isCallbackValue(slot.value));
     // bumped on reset to remount the value editor: the buffered editors (number,
     // json, callback) seed internal state from slot.value only on mount, so an
     // external set wouldn't otherwise show in the field
@@ -98,14 +104,12 @@ const SlotEditor = observer(function SlotEditor({ slot, }) {
     const ValueComponent = callbackMode
         ? CallbackEditor
         : (TypedComponent ?? StringEditor);
-    // a promotable slot's default is its inherit sentinel, so resetting it here
-    // doubles as "un-pin / follow the session-wide default"
     const { modified } = slot;
     return (_jsxs(Paper, { className: classes.paper, children: [_jsx("div", { className: classes.paperContent, children: _jsx(ValueComponent, { slot: slot }, resetNonce) }), modified ? (_jsx("div", { className: classes.resetButton, children: _jsx(Tooltip, { title: "Reset to default", children: _jsx(IconButton, { "aria-label": "reset to default", onClick: () => {
                             slot.set(slot.defaultValue);
-                            setCallbackMode(isCallbackValue(slot.defaultValue));
+                            setCallbackMode(callback && isCallbackValue(slot.defaultValue));
                             setResetNonce(nonce => nonce + 1);
-                        }, children: _jsx(RestartAltIcon, {}) }) }) })) : null, slot.contextVariable.length ? (_jsx("div", { className: classes.slotModeSwitch, children: _jsx(Tooltip, { title: callbackMode
+                        }, children: _jsx(RestartAltIcon, {}) }) }) })) : null, callback ? (_jsx("div", { className: classes.slotModeSwitch, children: _jsx(Tooltip, { title: callbackMode
                         ? 'Editing as a callback (Jexl expression). Click to use a fixed value.'
                         : 'Editing as a fixed value. Click to use a callback (Jexl expression).', children: _jsx(IconButton, { color: callbackMode ? 'primary' : 'default', onClick: () => {
                             if (callbackMode) {

package/esm/ConfigurationEditorWidget/components/StringArrayEditor.d.ts

@@ -1,10 +1,17 @@
+interface ArraySlot {
+    name: string;
+    value: string[];
+    set: (arg: string[]) => void;
+    description: string;
+}
 /** #slotEditor "todolist" of text fields, one per entry, with add and delete */
-declare const StringArrayEditor: ({ slot, }: {
-    slot: {
-        name: string;
-        value: string[];
-        set: (arg: string[]) => void;
-        description: string;
-    };
+declare const StringArrayEditor: ({ slot, prefix, }: {
+    slot: ArraySlot;
+    prefix?: string;
 }) => import("react").JSX.Element;
+/** #slotEditor "todolist" of text fields, each after a fixed `jexl:` */
+declare const ExpressionArrayEditor: ({ slot, }: {
+    slot: ArraySlot;
+}) => import("react").JSX.Element;
+export { ExpressionArrayEditor };
 export default StringArrayEditor;

package/esm/ConfigurationEditorWidget/components/StringArrayEditor.js

@@ -1,21 +1,31 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { JEXL_PREFIX } from '@jbrowse/core/util/jexlStrings';
 import DeleteIcon from '@mui/icons-material/Delete';
 import { FormHelperText, IconButton, InputAdornment, InputLabel, List, ListItem, TextField, } from '@mui/material';
 import { observer } from 'mobx-react';
 import AddNewField from './AddNewField.js';
 /** #slotEditor "todolist" of text fields, one per entry, with add and delete */
-const StringArrayEditor = observer(function StringArrayEditor({ slot, }) {
+const StringArrayEditor = observer(function StringArrayEditor({ slot, prefix = '', }) {
     const value = [...slot.value];
-    return (_jsxs(_Fragment, { children: [slot.name ? _jsx(InputLabel, { children: slot.name }) : null, _jsxs(List, { disablePadding: true, children: [value.map((val, idx) => (_jsx(ListItem, { disableGutters: true, children: _jsx(TextField, { fullWidth: true, value: val, onChange: evt => {
-                                slot.set(value.map((v, i) => (i === idx ? evt.target.value : v)));
+    const startAdornment = prefix ? (_jsx(InputAdornment, { position: "start", children: prefix })) : undefined;
+    return (_jsxs(_Fragment, { children: [slot.name ? _jsx(InputLabel, { children: slot.name }) : null, _jsxs(List, { disablePadding: true, children: [value.map((val, idx) => (_jsx(ListItem, { disableGutters: true, children: _jsx(TextField, { fullWidth: true, value: val.slice(prefix.length), onChange: evt => {
+                                slot.set(value.map((v, i) => i === idx ? prefix + evt.target.value : v));
                             }, slotProps: {
                                 input: {
+                                    startAdornment,
                                     endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { onClick: () => {
                                                 slot.set(value.filter((_, i) => i !== idx));
                                             }, children: _jsx(DeleteIcon, {}) }) })),
                                 },
-                            } }) }, idx))), _jsx(ListItem, { disableGutters: true, children: _jsx(AddNewField, { testid: `stringArrayAdd-${slot.name}`, onAdd: val => {
-                                slot.set([...value, val]);
+                            } }) }, idx))), _jsx(ListItem, { disableGutters: true, children: _jsx(AddNewField, { testid: `stringArrayAdd-${slot.name}`, startAdornment: startAdornment, onAdd: val => {
+                                slot.set([...value, prefix + val]);
                             } }) })] }), _jsx(FormHelperText, { children: slot.description })] }));
 });
+// `jexl:` sits fixed in front of each entry, so no keystroke writes one the
+// slot refuses
+/** #slotEditor "todolist" of text fields, each after a fixed `jexl:` */
+const ExpressionArrayEditor = observer(function ExpressionArrayEditor({ slot, }) {
+    return _jsx(StringArrayEditor, { slot: slot, prefix: JEXL_PREFIX });
+});
+export { ExpressionArrayEditor };
 export default StringArrayEditor;

package/esm/ConfigurationEditorWidget/components/StringMapEditor.d.ts

@@ -0,0 +1,10 @@
+/** #slotEditor one card per key, each holding that key's text field */
+declare const StringMapEditor: ({ slot, }: {
+    slot: {
+        name: string;
+        value: Map<string, string>;
+        set: (val: Record<string, string>) => void;
+        description: string;
+    };
+}) => import("react").JSX.Element;
+export default StringMapEditor;

package/esm/ConfigurationEditorWidget/components/StringMapEditor.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TextField } from '@mui/material';
+import { observer } from 'mobx-react';
+import MapSlotEditor from './MapSlotEditor.js';
+/** #slotEditor one card per key, each holding that key's text field */
+const StringMapEditor = observer(function StringMapEditor({ slot, }) {
+    return (_jsx(MapSlotEditor, { name: slot.name, description: slot.description, entries: [...slot.value], emptyValue: "", setMap: val => {
+            slot.set(val);
+        }, renderValue: (val, set) => (_jsx(TextField, { fullWidth: true, value: val, onChange: evt => {
+                set(evt.target.value);
+            } })) }));
+});
+export default StringMapEditor;

package/esm/ConfigurationEditorWidget/components/TypeSelector.d.ts

@@ -1,7 +1,7 @@
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 declare const TypeSelector: ({ typeNameChoices, slot, slotName, onChange, }: {
     typeNameChoices: string[];
-    slot: AnyConfigurationModel;
+    slot: AnyConfigurationModel | undefined;
     slotName: string;
     onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
 }) => import("react").JSX.Element;

package/esm/ConfigurationEditorWidget/components/TypeSelector.js

@@ -4,6 +4,6 @@ import { observer } from 'mobx-react';
 import { useSlotEditorStyles } from './useSlotEditorStyles.js';
 const TypeSelector = observer(function TypeSelector({ typeNameChoices, slot, slotName, onChange, }) {
     const { classes } = useSlotEditorStyles();
-    return (_jsx(Paper, { className: classes.paper, children: _jsx("div", { className: classes.paperContent, children: _jsx(TextField, { value: slot.type, label: "Type", select: true, variant: "outlined", helperText: `Type of ${slotName} to use`, fullWidth: true, onChange: onChange, children: typeNameChoices.map(str => (_jsx(MenuItem, { value: str, children: str }, str))) }) }) }));
+    return (_jsx(Paper, { className: classes.paper, children: _jsx("div", { className: classes.paperContent, children: _jsx(TextField, { value: slot?.type ?? '', label: `Type of ${slotName}`, select: true, variant: "outlined", fullWidth: true, onChange: onChange, children: typeNameChoices.map(str => (_jsx(MenuItem, { value: str, children: str }, str))) }) }) }));
 });
 export default TypeSelector;

package/esm/ConfigurationEditorWidget/index.js

@@ -1,10 +1,10 @@
-import { lazy } from 'react';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { WidgetType } from '@jbrowse/core/pluggableElementTypes';
+import { lazyWithPreload } from '@jbrowse/core/util/lazyWithPreload';
 import HeadingComponent from './components/HeadingComponent.js';
 import stateModelFactory from './model.js';
 const configSchema = ConfigurationSchema('ConfigurationEditorWidget', {});
-const LazyConfigurationEditorComponent = lazy(() => import('./components/ConfigurationEditor.js'));
+const LazyConfigurationEditorComponent = lazyWithPreload(() => import('./components/ConfigurationEditor.js'));
 export default function registerConfigurationEditorWidget(pluginManager) {
     pluginManager.addWidgetType(() => {
         return new WidgetType({

package/esm/FromConfigAdapter/configSchema.d.ts

@@ -16,25 +16,20 @@
  * ```
  */
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * stable identifier used as the adapter cache key; avoids hashing the
-     * (potentially large) features array. optional — falls back to hash.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly adapterId: {
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     * the features themselves, as an array of plain objects. Each needs a
-     * `uniqueId`, `refName`, `start` and `end` (0-based half-open); anything
-     * else — `name`, `type`, `score`, `strand`, nested `subfeatures` — is
-     * carried through onto the feature as-is.
-     */
     readonly features: {
-        readonly type: "frozen";
-        readonly defaultValue: readonly [];
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default configSchema;

package/esm/FromConfigRegionsAdapter/configSchema.d.ts

@@ -22,25 +22,20 @@
  * ```
  */
 declare const regionsConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * stable identifier used as the adapter cache key; avoids hashing the
-     * (potentially large) features array. optional — falls back to hash.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly adapterId: {
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     * one entry per reference sequence, each with a `uniqueId`, `refName`,
-     * `start: 0` and `end` set to that sequence's length. This is what defines
-     * the assembly's reference names and sizes; no bases are supplied, so
-     * base-level views are empty.
-     */
     readonly features: {
-        readonly type: "frozen";
-        readonly defaultValue: readonly [];
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default regionsConfigSchema;

package/esm/FromConfigSequenceAdapter/configSchema.d.ts

@@ -21,25 +21,20 @@
  * ```
  */
 declare const sequenceConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * stable identifier used as the adapter cache key; avoids hashing the
-     * (potentially large) features array. optional — falls back to hash.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly adapterId: {
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     * one entry per reference sequence, each with a `uniqueId`, `refName`,
-     * `start`, `end`, and a `seq` string holding the bases for that span. The
-     * bases live in the config, so this is for small sequences — a plasmid, a
-     * test contig — not a genome.
-     */
     readonly features: {
-        readonly type: "frozen";
-        readonly defaultValue: readonly [];
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default sequenceConfigSchema;

package/esm/NcbiSequenceReportAliasAdapter/configSchema.d.ts

@@ -1,6 +1,5 @@
-import { normalizeUriSnapshot } from '../normalizeUriSnapshot.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
-export declare const normalizeSnapshot: typeof normalizeUriSnapshot;
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
 /**
  * #config NcbiSequenceReportAliasAdapter
  * can read "sequence_report.tsv" type files from NCBI
@@ -57,27 +56,19 @@ export declare const normalizeSnapshot: typeof normalizeUriSnapshot;
  * ```
  */
 declare const NcbiSequenceReportAliasAdapterConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * location of the `sequence_report.tsv` NCBI publishes with an assembly. It
-     * carries the RefSeq, GenBank and UCSC-style name of every sequence, so one
-     * file aliases them all without hand-writing a chromAlias table.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly location: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "/path/to/my/sequence_report.tsv";
-            readonly locationType: "UriLocation";
-        };
+        type: "maybeFileLocation";
     };
-    /**
-     * #slot
-     */
     readonly useNameOverride: {
-        readonly type: "boolean";
-        readonly defaultValue: true;
-        readonly description: "forces usage of the UCSC names over the NCBI style names from a FASTA";
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export type NcbiSequenceReportAliasAdapterConfig = Instance<typeof NcbiSequenceReportAliasAdapterConfigSchema>;
 export default NcbiSequenceReportAliasAdapterConfigSchema;

package/esm/NcbiSequenceReportAliasAdapter/configSchema.js

@@ -1,6 +1,7 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { normalizeUriSnapshot } from '../normalizeUriSnapshot.js';
-export const normalizeSnapshot = normalizeUriSnapshot;
+import { ConfigurationSchema, expandUriShorthand, } from '@jbrowse/core/configuration';
+export function normalizeSnapshot(snap) {
+    return expandUriShorthand(snap, 'location');
+}
 /**
  * #config NcbiSequenceReportAliasAdapter
  * can read "sequence_report.tsv" type files from NCBI
@@ -64,11 +65,7 @@ const NcbiSequenceReportAliasAdapterConfigSchema = ConfigurationSchema('NcbiSequ
      * file aliases them all without hand-writing a chromAlias table.
      */
     location: {
-        type: 'fileLocation',
-        defaultValue: {
-            uri: '/path/to/my/sequence_report.tsv',
-            locationType: 'UriLocation',
-        },
+        type: 'maybeFileLocation',
     },
     /**
      * #slot

package/esm/RefNameAliasAdapter/configSchema.d.ts

@@ -1,6 +1,5 @@
-import { normalizeUriSnapshot } from '../normalizeUriSnapshot.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
-export declare const normalizeSnapshot: typeof normalizeUriSnapshot;
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
 /**
  * #config RefNameAliasAdapter
  * can read "chromAliases" type files from UCSC or any tab separated file of
@@ -55,40 +54,24 @@ export declare const normalizeSnapshot: typeof normalizeUriSnapshot;
  * ```
  */
 declare const RefNameAliasAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * location of the alias table: a UCSC `chromAlias.txt`, or any
-     * tab-separated file whose rows each list the alternate names of one
-     * reference sequence (`chr1<TAB>1<TAB>NC_000001.11`). It is what lets a
-     * `1`-named file load against a `chr1`-named assembly.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly location: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "/path/to/my/aliases.txt";
-            readonly locationType: "UriLocation";
-        };
+        type: "maybeFileLocation";
     };
-    /**
-     * #slot
-     * by default, the "ref names that match the fasta" are assumed to be in the
-     * first column (0), change this variable if needed
-     */
     readonly refNameColumn: {
-        readonly type: "number";
-        readonly defaultValue: 0;
-        readonly advanced: true;
+        type: "number";
+    } & {
+        defaultValue: number;
     };
-    /**
-     * #slot
-     * refNameColumnHeaderName
-     */
     readonly refNameColumnHeaderName: {
-        readonly type: "string";
-        readonly description: "alternative to refNameColumn, instead looks at header (starts with # and finds column name)";
-        readonly defaultValue: "";
-        readonly advanced: true;
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export type RefNameAliasAdapterConfig = Instance<typeof RefNameAliasAdapter>;
 export default RefNameAliasAdapter;

package/esm/RefNameAliasAdapter/configSchema.js

@@ -1,6 +1,7 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { normalizeUriSnapshot } from '../normalizeUriSnapshot.js';
-export const normalizeSnapshot = normalizeUriSnapshot;
+import { ConfigurationSchema, expandUriShorthand, } from '@jbrowse/core/configuration';
+export function normalizeSnapshot(snap) {
+    return expandUriShorthand(snap, 'location');
+}
 /**
  * #config RefNameAliasAdapter
  * can read "chromAliases" type files from UCSC or any tab separated file of
@@ -59,15 +60,11 @@ const RefNameAliasAdapter = ConfigurationSchema('RefNameAliasAdapter', {
      * #slot
      * location of the alias table: a UCSC `chromAlias.txt`, or any
      * tab-separated file whose rows each list the alternate names of one
-     * reference sequence (`chr1<TAB>1<TAB>NC_000001.11`). It is what lets a
+     * reference sequence (`chr1<TAB>1<TAB>NC_000001.11`). The table lets a
      * `1`-named file load against a `chr1`-named assembly.
      */
     location: {
-        type: 'fileLocation',
-        defaultValue: {
-            uri: '/path/to/my/aliases.txt',
-            locationType: 'UriLocation',
-        },
+        type: 'maybeFileLocation',
     },
     /**
      * #slot

package/esm/aliasUtils.d.ts

@@ -1,4 +1,4 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { FileLocation } from '@jbrowse/core/util/types';
-export declare function readAliasRows(loc: FileLocation, pluginManager?: PluginManager, opts?: BaseOptions): Promise<string[][]>;
+export declare function readAliasRows(loc: FileLocation | undefined, pluginManager?: PluginManager, opts?: BaseOptions): Promise<string[][]>;

package/esm/aliasUtils.js

@@ -1,16 +1,9 @@
 import { fetchAndMaybeUnzipText } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { isUriLocation } from '@jbrowse/core/util/types';
-// The alias adapters' `location` slots default to a "/path/to/my/..."
-// placeholder; that (and a blank uri) means "no file configured", so the
-// adapter yields no aliases rather than trying to fetch the placeholder path.
-function isUnconfiguredLocation(loc) {
-    return isUriLocation(loc) && (!loc.uri || loc.uri.startsWith('/path/to/my/'));
-}
 // Reads a tab-separated alias file into rows of columns, dropping blank lines.
 // Returns [] when no file is configured.
 export async function readAliasRows(loc, pluginManager, opts) {
-    if (isUnconfiguredLocation(loc)) {
+    if (!loc) {
         return [];
     }
     // fetchAndMaybeUnzipText rather than readFile('utf8') so the read reports byte

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-config",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "type": "module",
   "description": "JBrowse 2 config utilities",
   "keywords": [
@@ -21,13 +21,13 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.5.1",
-    "@mui/icons-material": "^9.3.1",
-    "@mui/material": "^9.3.1",
-    "mobx": "^7.0.3",
+    "@jbrowse/mobx-state-tree": "^6.6.1",
+    "@mui/icons-material": "^9.4.0",
+    "@mui/material": "^9.4.0",
+    "mobx": "^7.0.5",
     "mobx-react": "^10.0.2",
     "rxjs": "^7.8.2",
-    "@jbrowse/core": "^5.0.0-beta.1"
+    "@jbrowse/core": "^5.0.0-beta.10"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/esm/normalizeUriSnapshot.d.ts

@@ -1 +0,0 @@
-export declare function normalizeUriSnapshot(snap: Record<string, unknown>): Record<string, unknown>;

package/esm/normalizeUriSnapshot.js

@@ -1,13 +0,0 @@
-// allows a minimal config of `{ uri: "..." }` by lifting `uri`/`baseUri` into
-// a proper `location` fileLocation slot. Shared by the alias adapters.
-export function normalizeUriSnapshot(snap) {
-    return snap.uri
-        ? {
-            ...snap,
-            location: {
-                uri: snap.uri,
-                baseUri: snap.baseUri,
-            },
-        }
-        : snap;
-}