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

package/esm/ConfigurationEditorWidget/components/ConfigurationEditor.js

@@ -71,8 +71,8 @@ function schemaMatches(schema, query) {
     const { properties } = getMembers(schema);
     return Object.entries(properties).some(([slotName, slotSchema]) => memberMatches(schema, slotName, slotSchema, query));
 }
-// a slot flagged `advanced` in its schema definition, hidden behind a toggle
-function isAdvancedSlot(schema, slotName) {
+// narrower than the About dialog's Advanced card, which also takes callbacks
+function hidesBehindAdvancedToggle(schema, slotName) {
     return (isConfigurationSlot(schema, slotName) &&
         !!getSlotDefinition(schema, slotName).advanced);
 }
@@ -176,8 +176,8 @@ const Schema = observer(function Schema({ schema, path = [], filter = '', expand
     const query = filter.toLowerCase();
     const properties = getMembers(schema).properties;
     const visible = Object.entries(properties).filter(([slotName, slotSchema]) => !query || memberMatches(schema, slotName, slotSchema, query));
-    const normal = visible.filter(([slotName]) => !isAdvancedSlot(schema, slotName));
-    const advanced = visible.filter(([slotName]) => isAdvancedSlot(schema, slotName));
+    const normal = visible.filter(([slotName]) => !hidesBehindAdvancedToggle(schema, slotName));
+    const advanced = visible.filter(([slotName]) => hidesBehindAdvancedToggle(schema, slotName));
     const renderMember = ([slotName, slotSchema]) => (_jsx(Member, { slotName: slotName, slotSchema: slotSchema, path: path, schema: schema, filter: filter, expandedDisplayId: expandedDisplayId }, slotName));
     return (_jsxs(_Fragment, { children: [normal.map(renderMember), advanced.length && !query ? (_jsxs(Button, { className: classes.advancedToggle, size: "small", startIcon: showAdvanced ? _jsx(ExpandLessIcon, {}) : _jsx(ExpandMoreIcon, {}), onClick: () => {
                     setShowAdvanced(!showAdvanced);

package/esm/ConfigurationEditorWidget/components/SlotEditor.js

@@ -52,11 +52,9 @@ const FileSelectorWrapper = observer(function FileSelectorWrapper({ slot, }) {
             slot.set(location);
         }, name: slot.name, description: slot.description, rootModel: slot.pluginManager.rootModel }));
 });
-// dynamic dispatch from a runtime slot `type` string to a typed editor. The
-// `any` is irreducible here: each editor declares a narrow `slot.value` type
-// (number, boolean, FileLocation, string[], ...) but makeSlotFacade can only
-// type value as `unknown`, so no single registry prop type satisfies them all.
-// The editors stay fully typed internally; only this lookup is untyped.
+// The `any` is irreducible: each editor declares a narrow `slot.value` type, but
+// makeSlotFacade can only type value as `unknown`. The keys are checked: a slot
+// type with no editor is a compile error.
 const valueComponents = {
     string: StringEditor,
     maybeString: StringEditor,
@@ -97,13 +95,9 @@ const SlotEditor = observer(function SlotEditor({ slot, }) {
     // json, callback) seed internal state from slot.value only on mount, so an
     // external set wouldn't otherwise show in the field
     const [resetNonce, setResetNonce] = useState(0);
-    const TypedComponent = valueComponents[type];
-    if (!callbackMode && !TypedComponent) {
-        console.warn(`no slot editor defined for ${type}, editing as string`);
-    }
     const ValueComponent = callbackMode
         ? CallbackEditor
-        : (TypedComponent ?? StringEditor);
+        : valueComponents[type];
     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);

package/esm/ConfigurationEditorWidget/index.js

@@ -9,6 +9,7 @@ export default function registerConfigurationEditorWidget(pluginManager) {
     pluginManager.addWidgetType(() => {
         return new WidgetType({
             name: 'ConfigurationEditorWidget',
+            discardOnClose: true,
             HeadingComponent,
             configSchema,
             stateModel: stateModelFactory(pluginManager),

package/esm/ConfigurationEditorWidget/model.d.ts

@@ -8,11 +8,34 @@ import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 export default function stateModelFactory(_pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     type: import("@jbrowse/mobx-state-tree").ILiteralType<"ConfigurationEditorWidget">;
+    /**
+     * #property
+     * the track whose working copy this edits, re-resolved on every read so
+     * an undo that replaces the copy moves the editor with it
+     */
+    trackId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
 }, {
-    target: AnyConfigurationModel | undefined;
+    inlineTarget: AnyConfigurationModel | undefined;
     expandedDisplayId: string | undefined;
 } & {
+    /**
+     * #getter
+     */
+    readonly target: AnyConfigurationModel | undefined;
+} & {
+    /**
+     * #action
+     * edit the working copy of `trackId`, saving any edit still pending
+     * on the previous target first
+     */
+    setTrackId(trackId: string): void;
+    /**
+     * #action
+     * edit a config node directly, saving any edit still pending on the
+     * previous target first
+     */
     setTarget(newTarget: AnyConfigurationModel | undefined): void;
     setExpandedDisplayId(displayId: string | undefined): void;
     afterCreate(): void;
+    beforeDetach(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ConfigurationEditorWidget/model.js

@@ -1,4 +1,5 @@
 import { getSession } from '@jbrowse/core/util';
+import { getEditableTrackConfigById } from '@jbrowse/core/util/types';
 import { ElementId } from '@jbrowse/core/util/types/mst';
 import { addDisposer, getSnapshot, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
@@ -12,60 +13,92 @@ export default function stateModelFactory(_pluginManager) {
         .model('ConfigurationEditorWidget', {
         id: ElementId,
         type: types.literal('ConfigurationEditorWidget'),
+        /**
+         * #property
+         * the track whose working copy this edits, re-resolved on every read so
+         * an undo that replaces the copy moves the editor with it
+         */
+        trackId: types.maybe(types.string),
     })
         .volatile(() => ({
-        // Target is stored as volatile since it doesn't need to be serialized.
-        // The target is an MST model from track.configuration (which creates
-        // an MST model from frozen config via ConfigurationReference).
-        target: undefined,
+        // a config the session cannot resolve by trackId: an assembly, a
+        // connection, or a track a view holds inline
+        inlineTarget: undefined,
         // displayId of the display active in the view this editor was opened
         // from; its config accordion expands by default while the track's other
         // (incompatible/inactive) displays start collapsed
         expandedDisplayId: undefined,
     }))
-        .actions(self => ({
-        setTarget(newTarget) {
-            self.target = newTarget;
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get target() {
+            return self.trackId === undefined
+                ? self.inlineTarget
+                : getEditableTrackConfigById(getSession(self), self.trackId);
         },
-        setExpandedDisplayId(displayId) {
-            self.expandedDisplayId = displayId;
-        },
-        afterCreate() {
-            let timeout;
-            // Auto-save configuration changes with 400ms debounce. The autorun
-            // reacts to any changes in the target configuration model and persists
-            // them back to the session after a short delay via
-            // updateTrackConfiguration, which routes admin edits to the jbrowse
-            // config in place and everyone else's to a shareable per-track delta
-            // (trackConfigDeltas) against the admin base. It keys off trackId; in
-            // practice the widget is only opened on track configs. A config with no
-            // trackId (assembly/connection) degrades gracefully: updateTrackConfiguration
-            // finds no base/session/connection home and the edit just applies to the
-            // live MST node in memory for this session.
-            //
-            // BaseTrackModel's afterAttach runs a sibling debounced save (a reaction
-            // on the same config node) for direct setSlot quick-edits on a *shown*
-            // track. Both intentionally coexist: this widget also handles an unshown
-            // track edited from the selector, which has no BaseTrackModel. When both
-            // fire they compute an identical delta, deduped in updateTrackConfiguration
-            // — don't drop one to "simplify".
-            addDisposer(self, autorun(() => {
-                if (self.target) {
-                    // track configs (the practical case) carry a trackId; a
-                    // trackId-less snapshot degrades to an in-memory edit (see above)
-                    const snapshot = getSnapshot(self.target);
+    }))
+        .actions(self => {
+        let timeout;
+        let unsaved;
+        function save() {
+            clearTimeout(timeout);
+            if (unsaved) {
+                const session = getSession(self);
+                session.updateTrackConfiguration(unsaved);
+                unsaved = undefined;
+            }
+        }
+        return {
+            /**
+             * #action
+             * edit the working copy of `trackId`, saving any edit still pending
+             * on the previous target first
+             */
+            setTrackId(trackId) {
+                save();
+                self.inlineTarget = undefined;
+                self.trackId = trackId;
+            },
+            /**
+             * #action
+             * edit a config node directly, saving any edit still pending on the
+             * previous target first
+             */
+            setTarget(newTarget) {
+                save();
+                self.trackId = undefined;
+                self.inlineTarget = newTarget;
+            },
+            setExpandedDisplayId(displayId) {
+                self.expandedDisplayId = displayId;
+            },
+            afterCreate() {
+                // Saves through updateTrackConfiguration as a per-track delta. A
+                // config with no trackId (assembly/connection) finds no home there,
+                // so the edit stays on the live MST node for this session.
+                //
+                // BaseTrackModel runs a sibling saver on a shown track's working
+                // copy, which this widget edits too; this one covers a track that is
+                // not shown. When both fire they compute an identical delta, deduped
+                // in updateTrackConfiguration.
+                addDisposer(self, autorun(() => {
+                    if (self.target) {
+                        unsaved = getSnapshot(self.target);
+                        clearTimeout(timeout);
+                        timeout = setTimeout(save, 400);
+                    }
+                }));
+                addDisposer(self, () => {
                     clearTimeout(timeout);
-                    timeout = setTimeout(() => {
-                        const session = getSession(self);
-                        session.updateTrackConfiguration(snapshot);
-                    }, 400);
-                }
-            }));
-            // ensure a pending debounced save can't fire after disposal, where
-            // getSession(self) would throw on the now-detached node
-            addDisposer(self, () => {
-                clearTimeout(timeout);
-            });
-        },
-    }));
+                });
+            },
+            // closing the editor detaches it from the session, so an edit still
+            // inside the debounce saves now, while getSession(self) resolves
+            beforeDetach() {
+                save();
+            },
+        };
+    });
 }

package/package.json

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