@jbrowse/plugin-data-management 2.17.0 → 3.0.0

package/esm/AddTrackWidget/components/DefaultAddTrackWorkflow.js

@@ -1,13 +1,12 @@
-import React, { useState } from 'react';
-import { Alert, Button, Step, StepContent, StepLabel, Stepper, Typography, } from '@mui/material';
-import { makeStyles } from 'tss-react/mui';
-import { getRoot } from 'mobx-state-tree';
-import { getSession, isElectron, isSessionModelWithWidgets, isSessionWithAddTracks, isSupportedIndexingAdapter, } from '@jbrowse/core/util';
-import { getConf } from '@jbrowse/core/configuration';
+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';
-// locals
+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),
@@ -30,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() {
@@ -112,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 { AddTrackModel } from '../model';
+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,9 +1,11 @@
-import React, { useState } from 'react';
-import { Button, TextField } from '@mui/material';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
 import { ErrorMessage } from '@jbrowse/core/ui';
-import { makeStyles } from 'tss-react/mui';
 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()({
     textbox: {
         width: '100%',
@@ -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);
                     }
-                }
-                catch (e) {
-                    console.error(e);
-                    setError(e);
-                }
-            } }, "Submit")));
+                }, children: "Submit" })] }));
 });
 export default PasteConfigAddTrackWorkflow;

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

@@ -1,6 +1,5 @@
-import React from 'react';
-import { AddTrackModel } from '../model';
+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,10 +1,10 @@
-import React, { useEffect, useState } from 'react';
-import { Card, CardContent, IconButton, InputLabel, InputAdornment, List, ListItem, Paper, TextField, } from '@mui/material';
-import { makeStyles } from 'tss-react/mui';
-import { observer } from 'mobx-react';
-// icons
-import DeleteIcon from '@mui/icons-material/Delete';
+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';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
 const useStyles = makeStyles()(theme => ({
     paper: {
         display: 'flex',
@@ -34,53 +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) => (
-                    /* biome-ignore lint/suspicious/noArrayIndexKey: */
-                    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 { AddTrackModel } from '../model';
+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,48 +1,24 @@
-import React from 'react';
-import { ListSubheader, MenuItem, TextField } from '@mui/material';
-import { makeStyles } from 'tss-react/mui';
+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';
-const useStyles = makeStyles()(theme => ({
-    spacing: {
-        marginBottom: theme.spacing(3),
-    },
-}));
-// collate adapters into a map with
-// key: category
-// value: array of adapters with that category
-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: {
-                // @ts-expect-error
-                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]) => {
-        // returning array avoids needing to use a react fragment which
-        // Select/TextField sub-elements disagree with
-        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 { AddTrackModel } from '../model';
+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,9 +1,9 @@
-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 { makeStyles } from 'tss-react/mui';
-import { getRoot } from 'mobx-state-tree';
 import { observer } from 'mobx-react';
+import { getRoot } from 'mobx-state-tree';
+import { makeStyles } from 'tss-react/mui';
 const useStyles = makeStyles()(theme => ({
     paper: {
         padding: theme.spacing(2),
@@ -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 { AddTrackModel } from '../model';
-declare const TrackTypeSelector: ({ model }: {
+import type { AddTrackModel } from '../model';
+declare const TrackTypeSelector: ({ model, }: {
     model: AddTrackModel;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default TrackTypeSelector;

package/esm/AddTrackWidget/components/TrackTypeSelector.js

@@ -1,25 +1,19 @@
-import React from 'react';
-import { MenuItem, TextField } from '@mui/material';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { getEnv } from '@jbrowse/core/util';
+import { 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),
-    },
-}));
-const TrackTypeSelector = observer(({ model }) => {
-    const { classes } = useStyles();
+const TrackTypeSelector = observer(function ({ model, }) {
     const { pluginManager } = getEnv(model);
     const { trackType } = model;
     const trackTypes = pluginManager.getTrackElements();
-    return (React.createElement(TextField, { className: classes.spacing, value: trackType, variant: "outlined", label: "Track type", helperText: "Select track type", select: true, fullWidth: true, onChange: event => {
+    return (_jsx(TextField, { value: trackType, variant: "outlined", label: "Track type", select: true, fullWidth: true, onChange: event => {
             model.setTrackType(event.target.value);
         }, slotProps: {
             select: {
-                // @ts-expect-error
-                SelectDisplayProps: { 'data-testid': 'trackTypeSelect' },
+                SelectDisplayProps: {
+                    'data-testid': 'trackTypeSelect',
+                },
             },
-        } }, trackTypes.map(({ name, displayName }) => (React.createElement(MenuItem, { key: name, value: name }, displayName)))));
+        }, children: trackTypes.map(({ name, displayName }) => (_jsx(MenuItem, { value: name, children: displayName }, name))) }));
 });
 export default TrackTypeSelector;

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

@@ -0,0 +1 @@
+export default function Unsupported(): import("react/jsx-runtime").JSX.Element;

package/esm/AddTrackWidget/components/Unsupported.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Link, Typography } from '@mui/material';
+import { makeStyles } from 'tss-react/mui';
+const useStyles = makeStyles()(theme => ({
+    spacing: {
+        marginBottom: theme.spacing(3),
+    },
+}));
+export default function Unsupported() {
+    const { classes } = useStyles();
+    return (_jsxs(Typography, { className: classes.spacing, children: ["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", ' ', _jsx(Link, { href: "https://github.com/GMOD/jbrowse-components/releases", target: "_blank", rel: "noopener noreferrer", children: "check for new releases" }), ' ', "of JBrowse or", ' ', _jsx(Link, { href: "https://github.com/GMOD/jbrowse-components/issues/new", target: "_blank", rel: "noopener noreferrer", children: "file an issue" }), ' ', "and add a feature request for this data type."] }));
+}

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

@@ -0,0 +1,4 @@
+import type { AddTrackModel } from '../model';
+export declare function doSubmit({ model }: {
+    model: AddTrackModel;
+}): void;

package/esm/AddTrackWidget/components/doSubmit.js

@@ -0,0 +1,47 @@
+import { getSession, isElectron, isSessionModelWithWidgets, isSessionWithAddTracks, isSupportedIndexingAdapter, } from '@jbrowse/core/util';
+import { getRoot } from 'mobx-state-tree';
+function doTextIndexTrack({ model }) {
+    const { textIndexingConf, trackConfig, trackName, assembly } = model;
+    const { jobsManager } = getRoot(model);
+    const attr = textIndexingConf || {
+        attributes: ['Name', 'ID'],
+        exclude: ['CDS', 'exon'],
+    };
+    const indexName = `${trackName}-index`;
+    jobsManager.queueJob({
+        indexingParams: {
+            ...attr,
+            assemblies: [assembly],
+            tracks: [trackConfig.trackId],
+            indexType: 'perTrack',
+            name: indexName,
+            timestamp: new Date().toISOString(),
+        },
+        name: indexName,
+        cancelCallback: () => jobsManager.abortJob(),
+    });
+}
+export function doSubmit({ model }) {
+    var _a;
+    const { textIndexTrack, trackConfig, trackAdapter, view } = model;
+    const session = getSession(model);
+    if (!isSessionWithAddTracks(session)) {
+        throw new Error("Can't add tracks to this session");
+    }
+    else if (trackConfig && trackAdapter) {
+        session.addTrackConf(trackConfig);
+        (_a = view === null || view === void 0 ? void 0 : view.showTrack) === null || _a === void 0 ? void 0 : _a.call(view, trackConfig.trackId);
+        if (isElectron &&
+            textIndexTrack &&
+            isSupportedIndexingAdapter(trackAdapter.type)) {
+            doTextIndexTrack({ model });
+        }
+        model.clearData();
+        if (isSessionModelWithWidgets(session)) {
+            session.hideWidget(model);
+        }
+    }
+    else {
+        throw new Error('Failed to add track.\nThe configuration of this file is not currently supported.');
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { AdapterType } from '@jbrowse/core/pluggableElementTypes';
+export declare function categorizeAdapters(adaptersList: AdapterType[]): Record<string, AdapterType[]>;

package/esm/AddTrackWidget/components/util.js

@@ -0,0 +1,12 @@
+export function categorizeAdapters(adaptersList) {
+    var _a;
+    const map = {};
+    for (const adapter of adaptersList) {
+        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;
+}

package/esm/AddTrackWidget/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function AddTrackWidgetF(pluginManager: PluginManager): void;

package/esm/AddTrackWidget/index.js

@@ -1,6 +1,6 @@
+import { lazy } from 'react';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { WidgetType } from '@jbrowse/core/pluggableElementTypes';
-import { lazy } from 'react';
 import stateModelFactory from './model';
 const configSchema = ConfigurationSchema('AddTrackWidget', {});
 export default function AddTrackWidgetF(pluginManager) {