@jbrowse/plugin-data-management 2.18.0 → 3.0.0

package/esm/AddTrackWidget/components/AddTrackWidget.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const AddTrackSelector: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default AddTrackSelector;

package/esm/AddTrackWidget/components/AddTrackWidget.js

@@ -1,4 +1,5 @@
-import React, { Suspense, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Suspense, useState } from 'react';
 import { getEnv } from '@jbrowse/core/util';
 import { FormControl, FormHelperText, MenuItem, Select } from '@mui/material';
 import { observer } from 'mobx-react';
@@ -15,13 +16,8 @@ const AddTrackSelector = observer(function ({ model, }) {
     };
     const val2 = ComponentMap[val] ? val : 'Default add track workflow';
     const Component = ComponentMap[val2];
-    return (React.createElement(React.Fragment, null,
-        React.createElement(FormControl, null,
-            React.createElement(Select, { value: val2, onChange: event => {
-                    setVal(event.target.value);
-                } }, Object.keys(ComponentMap).map(e => (React.createElement(MenuItem, { key: e, value: e }, e)))),
-            React.createElement(FormHelperText, null, "Type of add track workflow")),
-        React.createElement(Suspense, { fallback: null },
-            React.createElement(Component, { model: model }))));
+    return (_jsxs(_Fragment, { children: [_jsxs(FormControl, { children: [_jsx(Select, { value: val2, onChange: event => {
+                            setVal(event.target.value);
+                        }, children: Object.keys(ComponentMap).map(e => (_jsx(MenuItem, { value: e, children: e }, e))) }), _jsx(FormHelperText, { children: "Type of add track workflow" })] }), _jsx(Suspense, { fallback: null, children: _jsx(Component, { model: model }) })] }));
 });
 export default AddTrackSelector;

package/esm/AddTrackWidget/components/ConfirmTrack.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const ConfirmTrack: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default ConfirmTrack;

package/esm/AddTrackWidget/components/ConfirmTrack.js

@@ -1,51 +1,22 @@
-import React, { useEffect, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense, useEffect, useState } from 'react';
 import { AssemblySelector } from '@jbrowse/core/ui';
-import { getSession, isElectron, isSupportedIndexingAdapter, } from '@jbrowse/core/util';
+import { getEnv, getSession, isElectron, isSupportedIndexingAdapter, } from '@jbrowse/core/util';
 import { UNKNOWN } from '@jbrowse/core/util/tracks';
-import { Checkbox, FormControl, FormControlLabel, Link, TextField, Typography, } from '@mui/material';
+import { Checkbox, FormControl, FormControlLabel, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
+import StatusMessage from './AddTrackStatusMessage';
+import UnknownAdapterPrompt from './AddTrackUnknownAdapterPrompt';
 import TextIndexingConfig from './TextIndexingConfig';
 import TrackAdapterSelector from './TrackAdapterSelector';
 import TrackTypeSelector from './TrackTypeSelector';
+import Unsupported from './Unsupported';
 const useStyles = makeStyles()(theme => ({
     spacing: {
         marginBottom: theme.spacing(3),
     },
 }));
-function StatusMessage({ trackAdapter, trackType, }) {
-    const { classes } = useStyles();
-    const { type, subadapter } = trackAdapter;
-    return type === 'SNPCoverageAdapter' ? (React.createElement(Typography, { className: classes.spacing },
-        "Selected ",
-        React.createElement("code", null, trackType),
-        ". Using adapter ",
-        React.createElement("code", null, type),
-        " with subadapter ",
-        React.createElement("code", null, subadapter === null || subadapter === void 0 ? void 0 : subadapter.type),
-        ". Please enter a track name and, if necessary, update the track type.")) : (React.createElement(Typography, { className: classes.spacing },
-        "Using adapter ",
-        React.createElement("code", null, type),
-        " and guessing track type",
-        ' ',
-        React.createElement("code", null, trackType),
-        ". Please enter a track name and, if necessary, update the track type."));
-}
-function UnknownAdapterPrompt({ model }) {
-    const { classes } = useStyles();
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Typography, { className: classes.spacing },
-            "JBrowse was not able to guess the adapter type for this data, but it may be in the list below. If not, you can",
-            ' ',
-            React.createElement(Link, { href: "https://github.com/GMOD/jbrowse-components/releases", target: "_blank", rel: "noopener noreferrer" }, "check for new releases"),
-            ' ',
-            "of JBrowse to see if they support this data type or",
-            ' ',
-            React.createElement(Link, { href: "https://github.com/GMOD/jbrowse-components/issues/new", target: "_blank", rel: "noopener noreferrer" }, "file an issue"),
-            ' ',
-            "and add a feature request for this data type."),
-        React.createElement(TrackAdapterSelector, { model: model })));
-}
 const ConfirmTrack = observer(function ConfirmTrack({ model, }) {
     const { classes } = useStyles();
     const [check, setCheck] = useState(true);
@@ -57,47 +28,41 @@ const ConfirmTrack = observer(function ConfirmTrack({ model, }) {
         }
     }, [adapterHint, trackAdapter, trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type, model]);
     if (unsupported) {
-        return (React.createElement(Typography, { className: classes.spacing },
-            "This version of JBrowse cannot display data of this type. It is possible, however, that there is a newer version that can display them. You can",
-            ' ',
-            React.createElement(Link, { href: "https://github.com/GMOD/jbrowse-components/releases", target: "_blank", rel: "noopener noreferrer" }, "check for new releases"),
-            ' ',
-            "of JBrowse or",
-            ' ',
-            React.createElement(Link, { href: "https://github.com/GMOD/jbrowse-components/issues/new", target: "_blank", rel: "noopener noreferrer" }, "file an issue"),
-            ' ',
-            "and add a feature request for this data type."));
+        return _jsx(Unsupported, {});
     }
-    if ((trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type) === UNKNOWN) {
-        return React.createElement(UnknownAdapterPrompt, { model: model });
+    else if ((trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type) === UNKNOWN) {
+        return _jsx(UnknownAdapterPrompt, { model: model });
     }
-    if (!(trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type)) {
-        return React.createElement(Typography, null, "Could not recognize this data type.");
+    else if (!(trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type)) {
+        return _jsx(Typography, { children: "Could not recognize this data type." });
     }
-    const supportedForIndexing = isSupportedIndexingAdapter(trackAdapter.type);
-    return (React.createElement("div", null,
-        React.createElement(StatusMessage, { trackAdapter: trackAdapter, trackType: trackType }),
-        warningMessage ? (React.createElement(Typography, { style: { color: 'orange' } }, warningMessage)) : null,
-        React.createElement(TextField, { className: classes.spacing, label: "trackName", helperText: "A name for this track", fullWidth: true, value: trackName, onChange: event => {
-                model.setTrackName(event.target.value);
-            }, slotProps: {
-                htmlInput: { 'data-testid': 'trackNameInput' },
-            } }),
-        React.createElement(TrackAdapterSelector, { model: model }),
-        React.createElement(TrackTypeSelector, { model: model }),
-        React.createElement(AssemblySelector, { session: session, helperText: "Select assembly to add track to", selected: model.assembly, onChange: asm => {
+    else {
+        const supportedForIndexing = isSupportedIndexingAdapter(trackAdapter.type);
+        const { pluginManager } = getEnv(model);
+        const Component = pluginManager.evaluateExtensionPoint('Core-addTrackComponent', ({ model }) => (_jsx(AssemblySelector, { session: session, helperText: "Select assembly to add track to", selected: model.assembly, onChange: asm => {
                 model.setAssembly(asm);
             }, TextFieldProps: {
                 fullWidth: true,
                 SelectProps: {
-                    SelectDisplayProps: { 'data-testid': 'assemblyNameSelect' },
+                    SelectDisplayProps: {
+                        'data-testid': 'assemblyNameSelect',
+                    },
                 },
-            } }),
-        isElectron && supportedForIndexing && (React.createElement(FormControl, null,
-            React.createElement(FormControlLabel, { label: 'Index track for text searching?', control: React.createElement(Checkbox, { checked: check, onChange: e => {
-                        setCheck(e.target.checked);
-                        model.setTextIndexTrack(e.target.checked);
-                    } }) }))),
-        isElectron && check && supportedForIndexing ? (React.createElement(TextIndexingConfig, { model: model })) : null));
+            } })), { model });
+        return (_jsxs("div", { children: [_jsx(StatusMessage, { trackAdapter: trackAdapter, trackType: trackType }), warningMessage ? (_jsx(Typography, { color: "warning", children: warningMessage })) : null, _jsx(TextField, { className: classes.spacing, label: "trackName", helperText: "A name for this track", fullWidth: true, value: trackName, onChange: event => {
+                        model.setTrackName(event.target.value);
+                    }, slotProps: {
+                        htmlInput: {
+                            'data-testid': 'trackNameInput',
+                        },
+                    } }), _jsxs("div", { style: {
+                        display: 'flex',
+                        flexDirection: 'column',
+                        gap: 10,
+                    }, children: [_jsx(TrackAdapterSelector, { model: model }), _jsx(TrackTypeSelector, { model: model }), _jsx(Suspense, { fallback: null, children: _jsx(Component, { model: model }) })] }), isElectron && supportedForIndexing && (_jsx(FormControl, { children: _jsx(FormControlLabel, { label: "Index track for text searching?", control: _jsx(Checkbox, { checked: check, onChange: e => {
+                                setCheck(e.target.checked);
+                                model.setTextIndexTrack(e.target.checked);
+                            } }) }) })), isElectron && check && supportedForIndexing ? (_jsx(TextIndexingConfig, { model: model })) : null] }));
+    }
 });
 export default ConfirmTrack;

package/esm/AddTrackWidget/components/DefaultAddTrackWorkflow.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const DefaultAddTrackWorkflow: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default DefaultAddTrackWorkflow;

package/esm/AddTrackWidget/components/DefaultAddTrackWorkflow.js

@@ -1,12 +1,12 @@
-import React, { useState } from 'react';
-import { getConf } from '@jbrowse/core/configuration';
-import { getSession, isElectron, isSessionModelWithWidgets, isSessionWithAddTracks, isSupportedIndexingAdapter, } from '@jbrowse/core/util';
-import { Alert, Button, Step, StepContent, StepLabel, Stepper, Typography, } from '@mui/material';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { getSession } from '@jbrowse/core/util';
+import { Button, Step, StepContent, StepLabel, Stepper, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
-import { getRoot } from 'mobx-state-tree';
 import { makeStyles } from 'tss-react/mui';
 import ConfirmTrack from './ConfirmTrack';
 import TrackSourceSelect from './TrackSourceSelect';
+import { doSubmit } from './doSubmit';
 const useStyles = makeStyles()(theme => ({
     root: {
         marginTop: theme.spacing(1),
@@ -29,76 +29,15 @@ const steps = ['Enter track data', 'Confirm track type'];
 const DefaultAddTrackWorkflow = observer(function ({ model, }) {
     const [activeStep, setActiveStep] = useState(0);
     const { classes } = useStyles();
-    const { jobsManager } = getRoot(model);
-    const session = getSession(model);
-    const { assembly, trackAdapter, trackData, trackName, trackType, textIndexTrack, textIndexingConf, } = model;
-    const [trackErrorMessage, setTrackErrorMessage] = useState();
+    const { assembly, trackAdapter, trackData, trackName, trackType } = model;
     function getStepContent(step) {
         switch (step) {
             case 0:
-                return React.createElement(TrackSourceSelect, { model: model });
+                return _jsx(TrackSourceSelect, { model: model });
             case 1:
-                return React.createElement(ConfirmTrack, { model: model });
+                return _jsx(ConfirmTrack, { model: model });
             default:
-                return React.createElement(Typography, null, "Unknown step");
-        }
-    }
-    async function handleNext() {
-        var _a, _b;
-        if (activeStep !== steps.length - 1) {
-            setActiveStep(activeStep + 1);
-            return;
-        }
-        const trackId = [
-            `${trackName.toLowerCase().replaceAll(' ', '_')}-${Date.now()}`,
-            session.adminMode ? '' : '-sessionTrack',
-        ].join('');
-        const assemblyInstance = session.assemblyManager.get(assembly);
-        if (!isSessionWithAddTracks(session)) {
-            setTrackErrorMessage('Unable to add tracks to this model');
-            return;
-        }
-        if (assemblyInstance && trackAdapter && trackAdapter.type !== 'UNKNOWN') {
-            session.addTrackConf({
-                trackId,
-                type: trackType,
-                name: trackName,
-                assemblyNames: [assembly],
-                adapter: {
-                    ...trackAdapter,
-                    sequenceAdapter: getConf(assemblyInstance, ['sequence', 'adapter']),
-                },
-            });
-            (_b = (_a = model.view).showTrack) === null || _b === void 0 ? void 0 : _b.call(_a, trackId);
-            if (isElectron &&
-                textIndexTrack &&
-                isSupportedIndexingAdapter(trackAdapter.type)) {
-                const attr = textIndexingConf || {
-                    attributes: ['Name', 'ID'],
-                    exclude: ['CDS', 'exon'],
-                };
-                const indexName = `${trackName}-index`;
-                const newEntry = {
-                    indexingParams: {
-                        ...attr,
-                        assemblies: [assembly],
-                        tracks: [trackId],
-                        indexType: 'perTrack',
-                        name: indexName,
-                        timestamp: new Date().toISOString(),
-                    },
-                    name: indexName,
-                    cancelCallback: () => jobsManager.abortJob(),
-                };
-                jobsManager.queueJob(newEntry);
-            }
-            model.clearData();
-            if (isSessionModelWithWidgets(session)) {
-                session.hideWidget(model);
-            }
-        }
-        else {
-            setTrackErrorMessage('Failed to add track.\nThe configuration of this file is not currently supported.');
+                return _jsx(Typography, { children: "Unknown step" });
         }
     }
     function isNextDisabled() {
@@ -111,18 +50,20 @@ const DefaultAddTrackWorkflow = observer(function ({ model, }) {
                 return true;
         }
     }
-    return (React.createElement("div", { className: classes.root },
-        React.createElement(Stepper, { className: classes.stepper, activeStep: activeStep, orientation: "vertical" }, steps.map((label, idx) => (React.createElement(Step, { key: label },
-            React.createElement(StepLabel, null, label),
-            React.createElement(StepContent, null,
-                getStepContent(idx),
-                React.createElement("div", { className: classes.actionsContainer },
-                    React.createElement(Button, { disabled: activeStep === 0, onClick: () => {
-                            setTrackErrorMessage(undefined);
-                            setActiveStep(activeStep - 1);
-                        }, className: classes.button }, "Back"),
-                    React.createElement(Button, { disabled: isNextDisabled(), variant: "contained", color: "primary", onClick: handleNext, className: classes.button, "data-testid": "addTrackNextButton" }, activeStep === steps.length - 1 ? 'Add' : 'Next')),
-                trackErrorMessage ? (React.createElement("div", { className: classes.alertContainer },
-                    React.createElement(Alert, { severity: "error" }, trackErrorMessage))) : null)))))));
+    return (_jsx("div", { className: classes.root, children: _jsx(Stepper, { className: classes.stepper, activeStep: activeStep, orientation: "vertical", children: steps.map((label, idx) => (_jsxs(Step, { children: [_jsx(StepLabel, { children: label }), _jsxs(StepContent, { children: [getStepContent(idx), _jsxs("div", { className: classes.actionsContainer, children: [_jsx(Button, { disabled: activeStep === 0, className: classes.button, onClick: () => {
+                                            setActiveStep(activeStep - 1);
+                                        }, children: "Back" }), _jsx(Button, { disabled: isNextDisabled(), variant: "contained", color: "primary", onClick: () => {
+                                            if (activeStep !== steps.length - 1) {
+                                                setActiveStep(activeStep + 1);
+                                            }
+                                            else {
+                                                try {
+                                                    doSubmit({ model });
+                                                }
+                                                catch (e) {
+                                                    getSession(model).notifyError(`${e}`, e);
+                                                }
+                                            }
+                                        }, className: classes.button, "data-testid": "addTrackNextButton", children: activeStep === steps.length - 1 ? 'Add' : 'Next' })] })] })] }, label))) }) }));
 });
 export default DefaultAddTrackWorkflow;

package/esm/AddTrackWidget/components/PasteConfigWorkflow.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const PasteConfigAddTrackWorkflow: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default PasteConfigAddTrackWorkflow;

package/esm/AddTrackWidget/components/PasteConfigWorkflow.js

@@ -1,7 +1,9 @@
-import React, { useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
 import { ErrorMessage } from '@jbrowse/core/ui';
 import { getSession, isSessionModelWithWidgets, isSessionWithAddTracks, } from '@jbrowse/core/util';
 import { Button, TextField } from '@mui/material';
+import { transaction } from 'mobx';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
 const useStyles = makeStyles()({
@@ -18,31 +20,32 @@ const PasteConfigAddTrackWorkflow = observer(function ({ model, }) {
     const { classes } = useStyles();
     const [val, setVal] = useState('');
     const [error, setError] = useState();
-    return (React.createElement("div", null,
-        error ? React.createElement(ErrorMessage, { error: error }) : null,
-        React.createElement(TextField, { multiline: true, rows: 10, value: val, onChange: event => {
-                setVal(event.target.value);
-            }, placeholder: 'Paste track config or array of track configs in JSON format', variant: "outlined", className: classes.textbox }),
-        React.createElement(Button, { variant: "contained", className: classes.submit, onClick: () => {
-                try {
-                    setError(undefined);
-                    const session = getSession(model);
-                    const conf = JSON.parse(val);
-                    const confs = Array.isArray(conf) ? conf : [conf];
-                    if (isSessionWithAddTracks(session) &&
-                        isSessionModelWithWidgets(session)) {
-                        confs.forEach(c => {
-                            session.addTrackConf(c);
-                        });
-                        confs.forEach(c => model.view.showTrack(c.trackId));
-                        model.clearData();
-                        session.hideWidget(model);
+    return (_jsxs("div", { children: [error ? _jsx(ErrorMessage, { error: error }) : null, _jsx(TextField, { multiline: true, rows: 10, value: val, placeholder: "Paste track config or array of track configs in JSON format", variant: "outlined", className: classes.textbox, onChange: event => {
+                    setVal(event.target.value);
+                } }), _jsx(Button, { variant: "contained", className: classes.submit, onClick: () => {
+                    try {
+                        setError(undefined);
+                        const session = getSession(model);
+                        const conf = JSON.parse(val);
+                        const confs = Array.isArray(conf) ? conf : [conf];
+                        if (isSessionWithAddTracks(session) &&
+                            isSessionModelWithWidgets(session)) {
+                            transaction(() => {
+                                confs.forEach(c => {
+                                    session.addTrackConf(c);
+                                });
+                                confs.forEach(c => {
+                                    model.view.showTrack(c.trackId);
+                                });
+                                model.clearData();
+                            });
+                            session.hideWidget(model);
+                        }
                     }
-                }
-                catch (e) {
-                    console.error(e);
-                    setError(e);
-                }
-            } }, "Submit")));
+                    catch (e) {
+                        console.error(e);
+                        setError(e);
+                    }
+                }, children: "Submit" })] }));
 });
 export default PasteConfigAddTrackWorkflow;

package/esm/AddTrackWidget/components/TextIndexingConfig.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const TextIndexingConfig: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default TextIndexingConfig;

package/esm/AddTrackWidget/components/TextIndexingConfig.js

@@ -1,4 +1,5 @@
-import React, { useEffect, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
 import AddIcon from '@mui/icons-material/Add';
 import DeleteIcon from '@mui/icons-material/Delete';
 import { Card, CardContent, IconButton, InputAdornment, InputLabel, List, ListItem, Paper, TextField, } from '@mui/material';
@@ -33,51 +34,38 @@ const TextIndexingConfig = observer(function ({ model, }) {
     useEffect(() => {
         model.setTextIndexingConf({ attributes, exclude });
     }, [model, attributes, exclude]);
-    return (React.createElement(Paper, { className: classes.paper },
-        React.createElement(InputLabel, null, "Indexing configuration"),
-        sections.map((section, index) => (React.createElement(Card, { raised: true, key: section.label, className: classes.card },
-            React.createElement(CardContent, null,
-                React.createElement(InputLabel, null, section.label),
-                React.createElement(List, { disablePadding: true },
-                    section.values.map((val, idx) => (React.createElement(ListItem, { key: `${val}-${idx}`, disableGutters: true },
-                        React.createElement(TextField, { value: val, slotProps: {
-                                input: {
-                                    endAdornment: (React.createElement(InputAdornment, { position: "end" },
-                                        React.createElement(IconButton, { onClick: () => {
-                                                const newAttr = section.values.filter((_, i) => i !== idx);
-                                                if (index === 0) {
-                                                    setAttributes(newAttr);
-                                                }
-                                                else {
-                                                    setExclude(newAttr);
-                                                }
-                                            } },
-                                            React.createElement(DeleteIcon, null)))),
-                                },
-                            } })))),
-                    React.createElement(ListItem, { disableGutters: true },
-                        React.createElement(TextField, { value: index === 0 ? value1 : value2, placeholder: "add new", onChange: event => {
-                                if (index === 0) {
-                                    setValue1(event.target.value);
-                                }
-                                else {
-                                    setValue2(event.target.value);
-                                }
-                            }, slotProps: {
-                                input: {
-                                    endAdornment: (React.createElement(InputAdornment, { position: "end" },
-                                        React.createElement(IconButton, { onClick: () => {
-                                                if (index === 0) {
-                                                    setAttributes([...attributes, value1]);
-                                                    setValue1('');
-                                                }
-                                                else {
-                                                    setExclude([...exclude, value2]);
-                                                    setValue2('');
-                                                }
-                                            }, disabled: index === 0 ? value1 === '' : value2 === '', "data-testid": "stringArrayAdd-Feat" },
-                                            React.createElement(AddIcon, null)))),
-                                },
-                            } })))))))));
+    return (_jsxs(Paper, { className: classes.paper, children: [_jsx(InputLabel, { children: "Indexing configuration" }), sections.map((section, index) => (_jsx(Card, { raised: true, className: classes.card, children: _jsxs(CardContent, { children: [_jsx(InputLabel, { children: section.label }), _jsxs(List, { disablePadding: true, children: [section.values.map((val, idx) => (_jsx(ListItem, { disableGutters: true, children: _jsx(TextField, { value: val, slotProps: {
+                                            input: {
+                                                endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { onClick: () => {
+                                                            const newAttr = section.values.filter((_, i) => i !== idx);
+                                                            if (index === 0) {
+                                                                setAttributes(newAttr);
+                                                            }
+                                                            else {
+                                                                setExclude(newAttr);
+                                                            }
+                                                        }, children: _jsx(DeleteIcon, {}) }) })),
+                                            },
+                                        } }) }, `${val}-${idx}`))), _jsx(ListItem, { disableGutters: true, children: _jsx(TextField, { value: index === 0 ? value1 : value2, placeholder: "add new", onChange: event => {
+                                            if (index === 0) {
+                                                setValue1(event.target.value);
+                                            }
+                                            else {
+                                                setValue2(event.target.value);
+                                            }
+                                        }, slotProps: {
+                                            input: {
+                                                endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { onClick: () => {
+                                                            if (index === 0) {
+                                                                setAttributes([...attributes, value1]);
+                                                                setValue1('');
+                                                            }
+                                                            else {
+                                                                setExclude([...exclude, value2]);
+                                                                setValue2('');
+                                                            }
+                                                        }, disabled: index === 0 ? value1 === '' : value2 === '', "data-testid": "stringArrayAdd-Feat", children: _jsx(AddIcon, {}) }) })),
+                                            },
+                                        } }) })] })] }) }, section.label)))] }));
 });
 export default TextIndexingConfig;

package/esm/AddTrackWidget/components/TrackAdapterSelector.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const TrackAdapterSelector: ({ model }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default TrackAdapterSelector;

package/esm/AddTrackWidget/components/TrackAdapterSelector.js

@@ -1,42 +1,24 @@
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { getEnv } from '@jbrowse/core/util';
 import { ListSubheader, MenuItem, TextField } from '@mui/material';
 import { observer } from 'mobx-react';
-import { makeStyles } from 'tss-react/mui';
-const useStyles = makeStyles()(theme => ({
-    spacing: {
-        marginBottom: theme.spacing(3),
-    },
-}));
-function categorizeAdapters(adaptersList) {
-    const map = {};
-    adaptersList.forEach(adapter => {
-        var _a;
-        const key = ((_a = adapter.adapterMetadata) === null || _a === void 0 ? void 0 : _a.category) || 'Default';
-        if (!map[key]) {
-            map[key] = [];
-        }
-        map[key].push(adapter);
-    });
-    return map;
-}
+import { categorizeAdapters } from './util';
 const TrackAdapterSelector = observer(({ model }) => {
-    const { classes } = useStyles();
     const { trackAdapter } = model;
     const { pluginManager } = getEnv(model);
-    return (React.createElement(TextField, { className: classes.spacing, value: (trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type) !== 'UNKNOWN' ? trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type : '', label: "Adapter type", variant: "outlined", helperText: "Select an adapter type", select: true, fullWidth: true, onChange: event => {
+    return (_jsx(TextField, { value: (trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type) !== 'UNKNOWN' ? trackAdapter === null || trackAdapter === void 0 ? void 0 : trackAdapter.type : '', label: "Adapter type", variant: "outlined", select: true, fullWidth: true, onChange: event => {
             model.setAdapterHint(event.target.value);
         }, slotProps: {
             select: {
-                SelectDisplayProps: { 'data-testid': 'adapterTypeSelect' },
+                SelectDisplayProps: {
+                    'data-testid': 'adapterTypeSelect',
+                },
             },
-        } }, Object.entries(categorizeAdapters(pluginManager
-        .getAdapterElements()
-        .filter(e => { var _a; return !((_a = e.adapterMetadata) === null || _a === void 0 ? void 0 : _a.hiddenFromGUI); }))).map(([key, val]) => {
-        return [
-            React.createElement(ListSubheader, { key: key }, key),
-            val.map(elt => (React.createElement(MenuItem, { key: elt.name, value: elt.name }, elt.displayName))),
-        ];
-    })));
+        }, children: Object.entries(categorizeAdapters(pluginManager
+            .getAdapterElements()
+            .filter(e => { var _a; return !((_a = e.adapterMetadata) === null || _a === void 0 ? void 0 : _a.hiddenFromGUI); }))).map(([key, val]) => [
+            _jsx(ListSubheader, { children: key }, key),
+            val.map(elt => (_jsx(MenuItem, { value: elt.name, children: elt.displayName }, elt.name))),
+        ]) }));
 });
 export default TrackAdapterSelector;

package/esm/AddTrackWidget/components/TrackSourceSelect.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
 declare const TrackSourceSelect: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default TrackSourceSelect;

package/esm/AddTrackWidget/components/TrackSourceSelect.js

@@ -1,4 +1,4 @@
-import React from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { FileSelector } from '@jbrowse/core/ui';
 import { Paper } from '@mui/material';
 import { observer } from 'mobx-react';
@@ -15,9 +15,6 @@ const useStyles = makeStyles()(theme => ({
 const TrackSourceSelect = observer(function ({ model, }) {
     const { classes } = useStyles();
     const rootModel = getRoot(model);
-    return (React.createElement(Paper, { className: classes.paper },
-        React.createElement(FileSelector, { name: "Main file", description: "", location: model.trackData, setLocation: model.setTrackData, setName: model.setTrackName, rootModel: rootModel }),
-        React.createElement("div", { className: classes.spacer }),
-        React.createElement(FileSelector, { name: "Index file", description: "(Optional) The URL of the index file is automatically inferred from the URL of the main file if it is not supplied.", location: model.indexTrackData, setLocation: model.setIndexTrackData, setName: model.setTrackName, rootModel: rootModel })));
+    return (_jsxs(Paper, { className: classes.paper, children: [_jsx(FileSelector, { name: "Main file", description: "", location: model.trackData, setLocation: model.setTrackData, setName: model.setTrackName, rootModel: rootModel }), _jsx("div", { className: classes.spacer }), _jsx(FileSelector, { name: "Index file", description: "(Optional) The URL of the index file is automatically inferred from the URL of the main file if it is not supplied.", location: model.indexTrackData, setLocation: model.setIndexTrackData, setName: model.setTrackName, rootModel: rootModel })] }));
 });
 export default TrackSourceSelect;

package/esm/AddTrackWidget/components/TrackTypeSelector.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { AddTrackModel } from '../model';
-declare const TrackTypeSelector: ({ model }: {
+declare const TrackTypeSelector: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default TrackTypeSelector;