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

package/esm/ConfigurationEditorWidget/components/StringArrayMapEditor.js

@@ -1,43 +1,18 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState } from 'react';
-import { makeStyles } from '@jbrowse/core/util/tss-react';
-import AddIcon from '@mui/icons-material/Add';
-import DeleteIcon from '@mui/icons-material/Delete';
-import { Card, CardContent, CardHeader, FormHelperText, IconButton, InputAdornment, InputLabel, TextField, } from '@mui/material';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { observer } from 'mobx-react';
-import StringArrayEditor from "./StringArrayEditor.js";
-const useStyles = makeStyles()(theme => ({
-    card: {
-        marginTop: theme.spacing(1),
-    },
-}));
+import MapSlotEditor from './MapSlotEditor.js';
+import StringArrayEditor from './StringArrayEditor.js';
+/** #slotEditor one card per key, each holding that key's "todolist" of strings */
 const StringArrayMapEditor = observer(function StringArrayMapEditor({ slot, }) {
-    const { classes } = useStyles();
-    const [value, setValue] = useState('');
-    return (_jsxs(_Fragment, { children: [_jsx(InputLabel, { children: slot.name }), [...slot.value].map(([key, val]) => (_jsxs(Card, { raised: true, className: classes.card, children: [_jsx(CardHeader, { title: key, action: _jsx(IconButton, { onClick: () => {
-                                slot.remove(key);
-                            }, children: _jsx(DeleteIcon, {}) }) }), _jsx(CardContent, { children: _jsx(StringArrayEditor, { slot: {
-                                name: slot.name,
-                                value: val,
-                                description: `Values associated with entry ${key}`,
-                                setAtIndex: (idx, val) => {
-                                    slot.setAtKeyIndex(key, idx, val);
-                                },
-                                removeAtIndex: (idx) => {
-                                    slot.removeAtKeyIndex(key, idx);
-                                },
-                                add: (val) => {
-                                    slot.addToKey(key, val);
-                                },
-                            } }) })] }, key))), _jsx(Card, { raised: true, className: classes.card, children: _jsx(CardHeader, { disableTypography: true, title: _jsx(TextField, { fullWidth: true, value: value, placeholder: "add new", onChange: event => {
-                            setValue(event.target.value);
-                        }, slotProps: {
-                            input: {
-                                endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { disabled: value === '', onClick: () => {
-                                            slot.add(value, []);
-                                            setValue('');
-                                        }, children: _jsx(AddIcon, {}) }) })),
-                            },
-                        } }) }) }), _jsx(FormHelperText, { children: slot.description })] }));
+    return (_jsx(MapSlotEditor, { name: slot.name, description: slot.description, 
+        // deep copy so per-entry edits never reuse the live MST array nodes
+        entries: [...slot.value].map(([k, v]) => [k, [...v]]), emptyValue: [], setMap: val => {
+            slot.set(val);
+        }, renderValue: (val, set, key) => (_jsx(StringArrayEditor, { slot: {
+                name: '',
+                value: val,
+                description: `Values associated with entry ${key}`,
+                set,
+            } })) }));
 });
 export default StringArrayMapEditor;

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,8 +1,8 @@
 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-runtime").JSX.Element;
+}) => import("react").JSX.Element;
 export default TypeSelector;

package/esm/ConfigurationEditorWidget/components/TypeSelector.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { MenuItem, Paper, TextField } from '@mui/material';
 import { observer } from 'mobx-react';
-import { useSlotEditorStyles } from "./useSlotEditorStyles.js";
+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, 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/components/singularSlotName.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Singularize a config schema slot name for the per-entry label an array-typed
+ * sub-schema renders ("displays" -> "display LinearBasicDisplay").
+ *
+ * Slot names are developer-authored camelCase identifiers — `displays`,
+ * `tracks`, `connections` are the ones in tree — so the regular English endings
+ * are the whole domain. This replaced the `pluralize` dependency, whose value
+ * is its irregular-noun table, and nothing here is ever an irregular noun.
+ *
+ * The counterpart for label text, where the noun comes from a display rather
+ * than a schema key, is core's own `pluralize(count, noun)` in `stringUtils`.
+ */
+export declare function singularSlotName(name: string): string;

package/esm/ConfigurationEditorWidget/components/singularSlotName.js

@@ -0,0 +1,23 @@
+/**
+ * Singularize a config schema slot name for the per-entry label an array-typed
+ * sub-schema renders ("displays" -> "display LinearBasicDisplay").
+ *
+ * Slot names are developer-authored camelCase identifiers — `displays`,
+ * `tracks`, `connections` are the ones in tree — so the regular English endings
+ * are the whole domain. This replaced the `pluralize` dependency, whose value
+ * is its irregular-noun table, and nothing here is ever an irregular noun.
+ *
+ * The counterpart for label text, where the noun comes from a display rather
+ * than a schema key, is core's own `pluralize(count, noun)` in `stringUtils`.
+ */
+export function singularSlotName(name) {
+    return /[^aeiou]ies$/.test(name)
+        ? `${name.slice(0, -3)}y`
+        : /(?:s|sh|ch|x|z)es$/.test(name)
+            ? name.slice(0, -2)
+            : // a trailing `s` after `a`/`i`/`u`/`s` belongs to a word that is already
+                // singular — `bias`, `alias`, `axis`, `status`, `class` — not to a plural
+                /[^saiu]s$/.test(name)
+                    ? name.slice(0, -1)
+                    : name;
+}

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

@@ -3,8 +3,8 @@ export declare const useSlotEditorStyles: (_params?: unknown, muiStyleOverridesP
         classes?: Record<string, string>;
     };
 } | undefined) => {
-    classes: Record<"paper" | "paperContent" | "slotModeSwitch", string>;
-    theme: import("@mui/material").Theme;
+    classes: Record<"paper" | "paperContent" | "resetButton" | "slotModeSwitch", string>;
+    theme: import("@jbrowse/core/ui/styleTheme").JBrowseStyleTheme;
     css: import("@jbrowse/core/util/tss-react/types").Css;
     cx: import("@jbrowse/core/util/tss-react/types").Cx;
 };

package/esm/ConfigurationEditorWidget/components/useSlotEditorStyles.js

@@ -6,7 +6,8 @@ export const useSlotEditorStyles = makeStyles()(theme => ({
         position: 'relative',
     },
     paperContent: {
-        width: '100%',
+        flex: 1,
+        minWidth: 0,
     },
     slotModeSwitch: {
         width: 24,
@@ -15,4 +16,8 @@ export const useSlotEditorStyles = makeStyles()(theme => ({
         justifyContent: 'center',
         alignItems: 'center',
     },
+    resetButton: {
+        display: 'flex',
+        alignItems: 'center',
+    },
 }));

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 HeadingComponent from "./components/HeadingComponent.js";
-import stateModelFactory from "./model.js";
+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/ConfigurationEditorWidget/model.d.ts

@@ -1,11 +1,18 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+/**
+ * #stateModel ConfigurationEditorWidget
+ * Widget for editing a config model's slots in a form: holds the target
+ * configuration and debounce-saves edits back to the session.
+ */
 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").ISimpleType<"ConfigurationEditorWidget">;
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<"ConfigurationEditorWidget">;
 }, {
     target: AnyConfigurationModel | undefined;
+    expandedDisplayId: string | undefined;
 } & {
     setTarget(newTarget: AnyConfigurationModel | undefined): void;
+    setExpandedDisplayId(displayId: string | undefined): void;
     afterCreate(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ConfigurationEditorWidget/model.js

@@ -2,6 +2,11 @@ import { getSession } from '@jbrowse/core/util';
 import { ElementId } from '@jbrowse/core/util/types/mst';
 import { addDisposer, getSnapshot, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
+/**
+ * #stateModel ConfigurationEditorWidget
+ * Widget for editing a config model's slots in a form: holds the target
+ * configuration and debounce-saves edits back to the session.
+ */
 export default function stateModelFactory(_pluginManager) {
     return types
         .model('ConfigurationEditorWidget', {
@@ -9,24 +14,58 @@ export default function stateModelFactory(_pluginManager) {
         type: types.literal('ConfigurationEditorWidget'),
     })
         .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,
+        // 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;
         },
+        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);
                     clearTimeout(timeout);
                     timeout = setTimeout(() => {
                         const session = getSession(self);
-                        session.jbrowse.updateTrackConf(snapshot);
+                        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);
+            });
         },
     }));
 }

package/esm/FromConfigAdapter/FromConfigAdapter.d.ts

@@ -4,6 +4,11 @@ import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util/simpleFeature';
 import type { NoAssemblyRegion } from '@jbrowse/core/util/types';
+export declare function mergeFeaturesToRegions(features: Map<string, Feature[]>): {
+    refName: string;
+    start: number;
+    end: number;
+}[];
 export declare function makeFeatures(fdata: SimpleFeatureSerialized[]): Map<string, Feature[]>;
 export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     protected features: Map<string, Feature[]>;
@@ -11,7 +16,7 @@ export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     getRefNames(): Promise<string[]>;
     getRefNameAliases(): Promise<{
         refName: string;
-        aliases: any;
+        aliases: unknown;
     }[]>;
     getFeatures(region: NoAssemblyRegion): import("rxjs").Observable<Feature>;
 }

package/esm/FromConfigAdapter/FromConfigAdapter.js

@@ -2,6 +2,35 @@ import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
+export function mergeFeaturesToRegions(features) {
+    const regions = [];
+    for (const [refName, feats] of features) {
+        let currentRegion;
+        for (const feature of feats) {
+            if (currentRegion &&
+                currentRegion.end >= feature.get('start') &&
+                currentRegion.start <= feature.get('end')) {
+                // take the max: a fully-contained feature (smaller end) must not
+                // shrink the merged region
+                currentRegion.end = Math.max(currentRegion.end, feature.get('end'));
+            }
+            else {
+                if (currentRegion) {
+                    regions.push(currentRegion);
+                }
+                currentRegion = {
+                    refName,
+                    start: feature.get('start'),
+                    end: feature.get('end'),
+                };
+            }
+        }
+        if (currentRegion) {
+            regions.push(currentRegion);
+        }
+    }
+    return regions;
+}
 export function makeFeatures(fdata) {
     const features = new Map();
     for (const entry of fdata) {
@@ -14,6 +43,7 @@ export function makeFeatures(fdata) {
         }
         bucket.push(f);
     }
+    // sort the features on each reference sequence by start coordinate
     for (const refFeatures of features.values()) {
         refFeatures.sort((a, b) => a.get('start') - b.get('start'));
     }
@@ -38,7 +68,7 @@ export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     getFeatures(region) {
         const { refName, start, end } = region;
         return ObservableCreate(async (observer) => {
-            const features = this.features.get(refName) || [];
+            const features = this.features.get(refName) ?? [];
             for (const f of features) {
                 if (f.get('end') > start && f.get('start') < end) {
                     observer.next(f);

package/esm/FromConfigAdapter/configSchema.d.ts

@@ -1,7 +1,35 @@
+/**
+ * #config FromConfigAdapter
+ * #trackType FeatureTrack
+ * #fileFormat inline | Inline features | Features written straight into config.json
+ * supplies features inline in the config instead of reading a file, useful for
+ * small feature sets added via a URL or session spec
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'FromConfigAdapter',
+ *   features: [
+ *     { uniqueId: 'f1', refName: 'ctgA', start: 100, end: 200, name: 'feature1' },
+ *   ],
+ * }
+ * ```
+ */
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    features: {
-        type: string;
-        defaultValue: never[];
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    readonly adapterId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    readonly features: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+}, 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/FromConfigAdapter/configSchema.js

@@ -1,9 +1,41 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+/**
+ * #config FromConfigAdapter
+ * #trackType FeatureTrack
+ * #fileFormat inline | Inline features | Features written straight into config.json
+ * supplies features inline in the config instead of reading a file, useful for
+ * small feature sets added via a URL or session spec
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'FromConfigAdapter',
+ *   features: [
+ *     { uniqueId: 'f1', refName: 'ctgA', start: 100, end: 200, name: 'feature1' },
+ *   ],
+ * }
+ * ```
+ */
 const configSchema = ConfigurationSchema('FromConfigAdapter', {
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    adapterId: {
+        type: 'string',
+        defaultValue: '',
+    },
+    /**
+     * #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.
+     */
     features: {
         type: 'frozen',
         defaultValue: [],
     },
-}, { explicitlyTyped: true, implicitIdentifier: 'adapterId' });
+}, { explicitlyTyped: true });
 export default configSchema;

package/esm/FromConfigAdapter/index.js

@@ -1,10 +1,10 @@
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes';
-import configSchema from "./configSchema.js";
+import configSchema from './configSchema.js';
 export default function FromConfigAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'FromConfigAdapter',
         configSchema,
-        getAdapterClass: () => import("./FromConfigAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./FromConfigAdapter.js').then(r => r.default),
         adapterMetadata: {
             hiddenFromGUI: true,
         },

package/esm/FromConfigRegionsAdapter/FromConfigRegionsAdapter.d.ts

@@ -3,9 +3,17 @@ import type PluginManager from '@jbrowse/core/PluginManager';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { RegionsAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
+/**
+ * Adapter that just returns the features defined in its `features` configuration
+ * key, like:
+ *   `"features": [ { "refName": "ctgA", "start":1, "end":20 }, ... ]`
+ */
 export default class FromConfigRegionsAdapter extends BaseAdapter implements RegionsAdapter {
     private features;
     constructor(config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    /**
+     * Get refName, start, and end for all features after collapsing any overlaps
+     */
     getRegions(): Promise<{
         refName: string;
         start: number;

package/esm/FromConfigRegionsAdapter/FromConfigRegionsAdapter.js

@@ -1,6 +1,11 @@
 import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { makeFeatures } from "../FromConfigAdapter/FromConfigAdapter.js";
+import { makeFeatures, mergeFeaturesToRegions, } from '../FromConfigAdapter/FromConfigAdapter.js';
+/**
+ * Adapter that just returns the features defined in its `features` configuration
+ * key, like:
+ *   `"features": [ { "refName": "ctgA", "start":1, "end":20 }, ... ]`
+ */
 export default class FromConfigRegionsAdapter extends BaseAdapter {
     features;
     constructor(config, getSubAdapter, pluginManager) {
@@ -8,31 +13,11 @@ export default class FromConfigRegionsAdapter extends BaseAdapter {
         const f = readConfObject(config, 'features');
         this.features = makeFeatures(f);
     }
+    /**
+     * Get refName, start, and end for all features after collapsing any overlaps
+     */
     async getRegions() {
-        const regions = [];
-        for (const [refName, features] of this.features) {
-            let currentRegion;
-            for (const feature of features) {
-                if (currentRegion &&
-                    currentRegion.end >= feature.get('start') &&
-                    currentRegion.start <= feature.get('end')) {
-                    currentRegion.end = feature.get('end');
-                }
-                else {
-                    if (currentRegion) {
-                        regions.push(currentRegion);
-                    }
-                    currentRegion = {
-                        refName,
-                        start: feature.get('start'),
-                        end: feature.get('end'),
-                    };
-                }
-            }
-            if (currentRegion) {
-                regions.push(currentRegion);
-            }
-        }
+        const regions = mergeFeaturesToRegions(this.features);
         regions.sort((a, b) => a.refName.localeCompare(b.refName));
         return regions;
     }

package/esm/FromConfigRegionsAdapter/configSchema.d.ts

@@ -1,7 +1,41 @@
+/**
+ * #config FromConfigRegionsAdapter
+ * #trackType ReferenceSequenceTrack
+ * #fileFormat inline | Inline regions | refNames and sizes only, no sequence
+ * used for specifying refNames+sizes of an assembly
+ *
+ * #example
+ * Supplies refNames+sizes with no sequence, as the adapter of an assembly's
+ * `sequence` (a `ReferenceSequenceTrack`):
+ * ```js
+ * {
+ *   type: 'ReferenceSequenceTrack',
+ *   trackId: 'my_refseq',
+ *   adapter: {
+ *     type: 'FromConfigRegionsAdapter',
+ *     features: [
+ *       { uniqueId: 'ctgA', refName: 'ctgA', start: 0, end: 50000 },
+ *       { uniqueId: 'ctgB', refName: 'ctgB', start: 0, end: 6079 },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
 declare const regionsConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    features: {
-        type: string;
-        defaultValue: never[];
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    readonly adapterId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    readonly features: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+}, 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/FromConfigRegionsAdapter/configSchema.js

@@ -1,12 +1,49 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+/**
+ * #config FromConfigRegionsAdapter
+ * #trackType ReferenceSequenceTrack
+ * #fileFormat inline | Inline regions | refNames and sizes only, no sequence
+ * used for specifying refNames+sizes of an assembly
+ *
+ * #example
+ * Supplies refNames+sizes with no sequence, as the adapter of an assembly's
+ * `sequence` (a `ReferenceSequenceTrack`):
+ * ```js
+ * {
+ *   type: 'ReferenceSequenceTrack',
+ *   trackId: 'my_refseq',
+ *   adapter: {
+ *     type: 'FromConfigRegionsAdapter',
+ *     features: [
+ *       { uniqueId: 'ctgA', refName: 'ctgA', start: 0, end: 50000 },
+ *       { uniqueId: 'ctgB', refName: 'ctgB', start: 0, end: 6079 },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
 const regionsConfigSchema = ConfigurationSchema('FromConfigRegionsAdapter', {
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    adapterId: {
+        type: 'string',
+        defaultValue: '',
+    },
+    /**
+     * #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.
+     */
     features: {
         type: 'frozen',
         defaultValue: [],
     },
 }, {
     explicitlyTyped: true,
-    implicitIdentifier: 'adapterId',
 });
 export default regionsConfigSchema;

package/esm/FromConfigRegionsAdapter/index.js

@@ -1,10 +1,10 @@
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes';
-import configSchema from "./configSchema.js";
+import configSchema from './configSchema.js';
 export default function FromConfigRegionsAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'FromConfigRegionsAdapter',
         configSchema,
-        getAdapterClass: () => import("./FromConfigRegionsAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./FromConfigRegionsAdapter.js').then(r => r.default),
         adapterMetadata: {
             hiddenFromGUI: true,
         },