@jbrowse/plugin-grid-bookmark 2.6.3 → 2.7.0

package/esm/GridBookmarkWidget/components/GridBookmarkWidget.js

@@ -1,88 +1,37 @@
-import React, { useState } from 'react';
+import React from 'react';
 import { observer } from 'mobx-react';
-import { Link, IconButton, Typography } from '@mui/material';
+import { Alert } from '@mui/material';
 import { makeStyles } from 'tss-react/mui';
-import { DataGrid } from '@mui/x-data-grid';
-import { getSession, assembleLocString, measureGridWidth, } from '@jbrowse/core/util';
-// icons
-import DeleteIcon from '@mui/icons-material/Delete';
 // locals
-import AssemblySelector from './AssemblySelector';
-import DeleteBookmarkDialog from './DeleteBookmark';
-import DownloadBookmarks from './DownloadBookmarks';
+import BookmarkGrid from './BookmarkGrid';
+import DeleteBookmarks from './DeleteBookmarks';
+import ExportBookmarks from './ExportBookmarks';
 import ImportBookmarks from './ImportBookmarks';
-import ClearBookmarks from './ClearBookmarks';
-import { navToBookmark } from '../utils';
-const useStyles = makeStyles()(theme => ({
-    link: {
-        cursor: 'pointer',
-    },
-    margin: {
-        margin: theme.spacing(2),
+import AssemblySelector from './AssemblySelector';
+import ShareBookmarks from './ShareBookmarks';
+const useStyles = makeStyles()({
+    card: {
+        marginTop: 5,
     },
-}));
-const BookmarkGrid = observer(({ model }) => {
-    const { classes } = useStyles();
-    const [dialogRowNumber, setDialogRowNumber] = useState();
-    const { bookmarkedRegions, selectedAssembly } = model;
-    const session = getSession(model);
-    const bookmarkRows = bookmarkedRegions
-        .filter(r => selectedAssembly === 'all' || r.assemblyName === selectedAssembly)
-        .map((region, index) => {
-        const { assemblyName, ...rest } = region;
-        return {
-            ...region,
-            id: index,
-            delete: index,
-            locString: assembleLocString(selectedAssembly === 'all' ? region : rest),
-        };
-    });
-    return (React.createElement(React.Fragment, null,
-        React.createElement(DataGrid, { density: "compact", rows: bookmarkRows, columns: [
-                {
-                    field: 'locString',
-                    headerName: 'bookmark link',
-                    width: measureGridWidth(bookmarkRows.map(row => row.locString)),
-                    renderCell: params => (React.createElement(Link, { className: classes.link, href: "#", onClick: async (event) => {
-                            event.preventDefault();
-                            await navToBookmark(params.value, session.views, model);
-                        } }, params.value)),
-                },
-                {
-                    field: 'label',
-                    width: measureGridWidth(bookmarkRows.map(row => row.label)),
-                    editable: true,
-                },
-                {
-                    field: 'delete',
-                    width: 100,
-                    renderCell: params => (React.createElement(IconButton, { "data-testid": "deleteBookmark", "aria-label": "delete", onClick: () => {
-                            if (params.value != null) {
-                                setDialogRowNumber(+params.value);
-                            }
-                        } },
-                        React.createElement(DeleteIcon, null))),
-                },
-            ], processRowUpdate: row => {
-                model.updateBookmarkLabel(row.id, row.label);
-                return row;
-            }, onProcessRowUpdateError: e => {
-                session.notify(e.message, 'error');
-            }, disableRowSelectionOnClick: true }),
-        React.createElement(DeleteBookmarkDialog, { rowNumber: dialogRowNumber, model: model, onClose: () => setDialogRowNumber(undefined) })));
 });
-function GridBookmarkWidget({ model }) {
-    const { selectedAssembly } = model;
+const GridBookmarkWidget = observer(function GridBookmarkWidget({ model, }) {
     const { classes } = useStyles();
-    return (React.createElement(React.Fragment, null,
+    if (!model) {
+        return null;
+    }
+    return (React.createElement("div", { className: classes.card },
+        React.createElement("div", null,
+            React.createElement(ExportBookmarks, { model: model }),
+            React.createElement(ImportBookmarks, { model: model }),
+            React.createElement(ShareBookmarks, { model: model }),
+            React.createElement(DeleteBookmarks, { model: model })),
+        React.createElement(Alert, { severity: "info" },
+            "Click and type within the ",
+            React.createElement("strong", null, "label"),
+            " field to annotate your bookmark. Double click the ",
+            React.createElement("strong", null, "label"),
+            " field to do so within a dialog."),
         React.createElement(AssemblySelector, { model: model }),
-        React.createElement(DownloadBookmarks, { model: model }),
-        React.createElement(ImportBookmarks, { model: model, assemblyName: selectedAssembly }),
-        React.createElement(ClearBookmarks, { model: model }),
-        React.createElement(Typography, { className: classes.margin },
-            "Note: you can double click the ",
-            React.createElement("code", null, "label"),
-            " field to add your own custom notes"),
         React.createElement(BookmarkGrid, { model: model })));
-}
-export default observer(GridBookmarkWidget);
+});
+export default GridBookmarkWidget;

package/esm/GridBookmarkWidget/components/ImportBookmarks.d.ts

@@ -1,8 +1,6 @@
 import React from 'react';
 import { GridBookmarkModel } from '../model';
-declare function ImportBookmarks({ model, assemblyName, }: {
+declare const ImportBookmarks: ({ model, }: {
     model: GridBookmarkModel;
-    assemblyName: string;
-}): React.JSX.Element;
-declare const _default: typeof ImportBookmarks;
-export default _default;
+}) => React.JSX.Element;
+export default ImportBookmarks;

package/esm/GridBookmarkWidget/components/ImportBookmarks.js

@@ -1,70 +1,14 @@
-import React, { useState } from 'react';
+import React, { useState, Suspense, lazy } from 'react';
 import { observer } from 'mobx-react';
-import { getSession } from '@jbrowse/core/util';
-import AssemblySelector from '@jbrowse/core/ui/AssemblySelector';
-import { FileSelector } from '@jbrowse/core/ui';
-import { openLocation } from '@jbrowse/core/util/io';
-import { Button, DialogContent, DialogActions, Typography } from '@mui/material';
-import { Dialog } from '@jbrowse/core/ui';
-import { makeStyles } from 'tss-react/mui';
+import { Button } from '@mui/material';
 // icons
 import ImportIcon from '@mui/icons-material/Publish';
-const useStyles = makeStyles()(() => ({
-    dialogContainer: {
-        margin: 15,
-    },
-    flexItem: {
-        margin: 5,
-    },
-}));
-function ImportBookmarks({ model, assemblyName, }) {
-    const { classes } = useStyles();
-    const session = getSession(model);
-    const { assemblyNames } = session;
-    const [dialogOpen, setDialogOpen] = useState(false);
-    const [location, setLocation] = useState();
-    const [error, setError] = useState();
-    const [selectedAsm, setSelectedAsm] = useState(assemblyName || assemblyNames[0]);
+const ImportBookmarksDialog = lazy(() => import('./ImportBookmarksDialog'));
+const ImportBookmarks = observer(function ({ model, }) {
+    const [open, setOpen] = useState(false);
     return (React.createElement(React.Fragment, null,
-        React.createElement(Button, { startIcon: React.createElement(ImportIcon, null), onClick: () => setDialogOpen(true) }, "Import"),
-        React.createElement(Dialog, { open: dialogOpen, onClose: () => setDialogOpen(false), maxWidth: "xl", title: "Import bookmarks" },
-            React.createElement(DialogContent, null,
-                React.createElement(Typography, null, "Choose a BED format file to import. The first 4 columns will be used"),
-                React.createElement(FileSelector, { location: location, setLocation: setLocation, name: "File" }),
-                React.createElement(Typography, null, "Select assembly that your data belongs to"),
-                React.createElement(AssemblySelector, { onChange: val => setSelectedAsm(val), session: session, selected: selectedAsm }),
-                error ? (React.createElement(Typography, { color: "error", variant: "h6" }, `${error}`)) : null),
-            React.createElement(DialogActions, null,
-                React.createElement(Button, { variant: "contained", color: "secondary", onClick: () => setDialogOpen(false) }, "Cancel"),
-                React.createElement(Button, { className: classes.flexItem, "data-testid": "dialogImport", variant: "contained", color: "primary", disabled: !location, startIcon: React.createElement(ImportIcon, null), onClick: async () => {
-                        try {
-                            if (!location) {
-                                return;
-                            }
-                            const data = await openLocation(location).readFile('utf8');
-                            const regions = data
-                                .split(/\n|\r\n|\r/)
-                                .filter(f => !!f.trim())
-                                .filter(f => !f.startsWith('#') &&
-                                !f.startsWith('track') &&
-                                !f.startsWith('browser'))
-                                .map(line => {
-                                const [refName, start, end, name] = line.split('\t');
-                                return {
-                                    assemblyName: selectedAsm,
-                                    refName,
-                                    start: +start,
-                                    end: +end,
-                                    label: name === '.' ? undefined : name,
-                                };
-                            });
-                            model.importBookmarks(regions);
-                            setDialogOpen(false);
-                        }
-                        catch (e) {
-                            console.error(e);
-                            setError(e);
-                        }
-                    } }, "Import")))));
-}
-export default observer(ImportBookmarks);
+        React.createElement(Button, { startIcon: React.createElement(ImportIcon, null), onClick: () => setOpen(true) }, "Import"),
+        open ? (React.createElement(Suspense, { fallback: React.createElement(React.Fragment, null) },
+            React.createElement(ImportBookmarksDialog, { onClose: () => setOpen(false), model: model }))) : null));
+});
+export default ImportBookmarks;

package/esm/GridBookmarkWidget/components/ImportBookmarksDialog.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { GridBookmarkModel } from '../model';
+declare const ImportBookmarksDialog: ({ onClose, model, }: {
+    onClose: () => void;
+    model: GridBookmarkModel;
+}) => React.JSX.Element;
+export default ImportBookmarksDialog;

package/esm/GridBookmarkWidget/components/ImportBookmarksDialog.js

@@ -0,0 +1,101 @@
+import React, { useState } from 'react';
+import { observer } from 'mobx-react';
+import { getSession } from '@jbrowse/core/util';
+import { isSessionWithShareURL } from '@jbrowse/core/util/types';
+import { FileSelector } from '@jbrowse/core/ui';
+import { Button, DialogContent, DialogActions, Typography, TextField, Accordion, AccordionSummary, AccordionDetails, Tooltip, } from '@mui/material';
+import { openLocation } from '@jbrowse/core/util/io';
+import { Dialog } from '@jbrowse/core/ui';
+import AssemblySelector from '@jbrowse/core/ui/AssemblySelector';
+import { makeStyles } from 'tss-react/mui';
+// icons
+import ImportIcon from '@mui/icons-material/Publish';
+import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
+import HelpIcon from '@mui/icons-material/Help';
+import { fromUrlSafeB64 } from '../utils';
+import { readSessionFromDynamo } from '../sessionSharing';
+const useStyles = makeStyles()(theme => {
+    var _a;
+    return ({
+        flexItem: {
+            margin: 5,
+        },
+        expandIcon: {
+            color: ((_a = theme.palette.tertiary) === null || _a === void 0 ? void 0 : _a.contrastText) || '#fff',
+        },
+    });
+});
+async function getBookmarksFromShareLink(shareLink, shareURL) {
+    const defaultURL = 'https://share.jbrowse.org/api/v1/';
+    const urlParams = new URL(shareLink);
+    const sessionQueryParam = urlParams.searchParams.get('bookmarks');
+    const password = urlParams.searchParams.get('password');
+    const decryptedSession = await readSessionFromDynamo(`${shareURL !== null && shareURL !== void 0 ? shareURL : defaultURL}load`, sessionQueryParam || '', password || '');
+    const sharedSession = JSON.parse(await fromUrlSafeB64(decryptedSession));
+    return sharedSession.sharedBookmarks;
+}
+async function getBookmarksFromFile(location, selectedAsm) {
+    const data = await openLocation(location).readFile('utf8');
+    return data
+        .split(/\n|\r\n|\r/)
+        .filter(f => !!f.trim())
+        .filter(f => !f.startsWith('#') &&
+        !f.startsWith('track') &&
+        !f.startsWith('browser'))
+        .map(line => {
+        const [refName, start, end, label, assembly] = line.split('\t');
+        return {
+            assemblyName: assembly !== null && assembly !== void 0 ? assembly : selectedAsm,
+            refName,
+            start: +start,
+            end: +end,
+            label: label === '.' ? undefined : label,
+        };
+    });
+}
+const ImportBookmarksDialog = observer(function ({ onClose, model, }) {
+    const { classes } = useStyles();
+    const [location, setLocation] = useState();
+    const [error, setError] = useState();
+    const [shareLink, setShareLink] = useState('');
+    const session = getSession(model);
+    const { assemblyNames } = session;
+    const [selectedAsm, setSelectedAsm] = useState(assemblyNames[0]);
+    const [expanded, setExpanded] = useState('shareLinkAccordion');
+    return (React.createElement(Dialog, { open: true, onClose: onClose, maxWidth: "xl", title: "Import bookmarks" },
+        React.createElement(DialogContent, null,
+            React.createElement(Accordion, { expanded: expanded === 'shareLinkAccordion', onChange: () => setExpanded('shareLinkAccordion') },
+                React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMoreIcon, { className: classes.expandIcon }) },
+                    React.createElement(Typography, { style: { display: 'flex', alignItems: 'center', gap: '5px' } },
+                        "Import from share link",
+                        ' ',
+                        React.createElement(Tooltip, { title: "The appropriate share link for sharing bookmarks is one generated via the 'Share' button in the 'Bookmarked regions' drawer. Paste it below to import shared bookmarks." },
+                            React.createElement(HelpIcon, null)))),
+                React.createElement(AccordionDetails, null,
+                    React.createElement(TextField, { label: "Enter URL", variant: "outlined", style: { width: '100%' }, value: shareLink, onChange: e => setShareLink(e.target.value) }))),
+            React.createElement(Accordion, { expanded: expanded === 'fileAccordion', onChange: () => setExpanded('fileAccordion') },
+                React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMoreIcon, { className: classes.expandIcon }) },
+                    React.createElement(Typography, null, "Import from file")),
+                React.createElement(AccordionDetails, null,
+                    React.createElement(FileSelector, { location: location, setLocation: setLocation, name: "File", description: "Choose a BED or TSV format file to import." }),
+                    React.createElement(AssemblySelector, { onChange: val => setSelectedAsm(val), helperText: `Select the assembly your bookmarks belong to (BED or TSV without assembly column).`, session: session, selected: selectedAsm }))),
+            error ? (React.createElement(Typography, { color: "error", variant: "h6" }, `${error}`)) : null),
+        React.createElement(DialogActions, null,
+            React.createElement(Button, { variant: "contained", color: "secondary", onClick: onClose }, "Cancel"),
+            React.createElement(Button, { className: classes.flexItem, "data-testid": "dialogImport", variant: "contained", color: "primary", disabled: !location && !shareLink, startIcon: React.createElement(ImportIcon, null), onClick: async () => {
+                    try {
+                        if (location) {
+                            model.importBookmarks(await getBookmarksFromFile(location, selectedAsm));
+                        }
+                        else if (shareLink && isSessionWithShareURL(session)) {
+                            model.importBookmarks(await getBookmarksFromShareLink(shareLink, session.shareURL));
+                        }
+                        onClose();
+                    }
+                    catch (e) {
+                        console.error(e);
+                        setError(e);
+                    }
+                } }, "Import"))));
+});
+export default ImportBookmarksDialog;

package/esm/GridBookmarkWidget/components/{DownloadBookmarks.d.ts → ShareBookmarks.d.ts}

@@ -1,7 +1,6 @@
 import React from 'react';
 import { GridBookmarkModel } from '../model';
-declare function DownloadBookmarks({ model }: {
+declare function ShareBookmarks({ model }: {
     model: GridBookmarkModel;
 }): React.JSX.Element;
-declare const _default: typeof DownloadBookmarks;
-export default _default;
+export default ShareBookmarks;

package/esm/GridBookmarkWidget/components/ShareBookmarks.js

@@ -0,0 +1,12 @@
+import React, { Suspense, lazy, useState } from 'react';
+import { Button } from '@mui/material';
+import { ContentCopy as ContentCopyIcon } from '@jbrowse/core/ui/Icons';
+const ShareBookmarksDialog = lazy(() => import('./ShareBookmarksDialog'));
+function ShareBookmarks({ model }) {
+    const [open, setOpen] = useState(false);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Button, { startIcon: React.createElement(ContentCopyIcon, null), onClick: () => setOpen(true) }, "Share"),
+        open ? (React.createElement(Suspense, { fallback: React.createElement(React.Fragment, null) },
+            React.createElement(ShareBookmarksDialog, { onClose: () => setOpen(false), model: model }))) : null));
+}
+export default ShareBookmarks;

package/esm/GridBookmarkWidget/components/ShareBookmarksDialog.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { GridBookmarkModel } from '../model';
+declare const ShareBookmarksDialog: ({ onClose, model, }: {
+    onClose: () => void;
+    model: GridBookmarkModel;
+}) => React.JSX.Element;
+export default ShareBookmarksDialog;

package/esm/GridBookmarkWidget/components/ShareBookmarksDialog.js

@@ -0,0 +1,78 @@
+import React, { useEffect, useState } from 'react';
+import { observer } from 'mobx-react';
+import { getSnapshot } from 'mobx-state-tree';
+import { Alert, Button, DialogActions, DialogContent, DialogContentText, TextField, Typography, } from '@mui/material';
+import { makeStyles } from 'tss-react/mui';
+import copy from 'copy-to-clipboard';
+import { getSession, isSessionWithShareURL } from '@jbrowse/core/util';
+import { Dialog, ErrorMessage } from '@jbrowse/core/ui';
+import { ContentCopy as ContentCopyIcon } from '@jbrowse/core/ui/Icons';
+// locals
+import { shareSessionToDynamo } from '../sessionSharing';
+const useStyles = makeStyles()(() => ({
+    flexItem: {
+        margin: 5,
+    },
+}));
+const ShareBookmarksDialog = observer(function ({ onClose, model, }) {
+    const { classes } = useStyles();
+    const [url, setUrl] = useState('');
+    const [error, setError] = useState();
+    const [loading, setLoading] = useState(true);
+    const session = getSession(model);
+    const { selectedBookmarks } = model;
+    const shareAll = selectedBookmarks.length === 0;
+    const bookmarksToShare = selectedBookmarks.length === 0
+        ? model.allBookmarksModel
+        : model.sharedBookmarksModel;
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            try {
+                if (!isSessionWithShareURL(session)) {
+                    throw new Error('No shareURL configured');
+                }
+                setLoading(true);
+                const snap = getSnapshot(bookmarksToShare);
+                const locationUrl = new URL(window.location.href);
+                const result = await shareSessionToDynamo(snap, session.shareURL, locationUrl.href);
+                if (!cancelled) {
+                    const params = new URLSearchParams(locationUrl.search);
+                    params.set('bookmarks', `share-${result.json.sessionId}`);
+                    params.set('password', result.password);
+                    locationUrl.search = params.toString();
+                    setUrl(locationUrl.href);
+                    setLoading(false);
+                }
+            }
+            catch (e) {
+                setError(e);
+            }
+            finally {
+                setLoading(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [bookmarksToShare, session]);
+    return (React.createElement(Dialog, { open: true, onClose: onClose, title: "Share bookmarks" },
+        React.createElement(DialogContent, { style: { display: 'flex', flexFlow: 'column', gap: '5px' } },
+            React.createElement(Alert, { severity: "info" }, shareAll ? (React.createElement(React.Fragment, null,
+                React.createElement("span", null, "All bookmarks will be shared."),
+                React.createElement("br", null),
+                React.createElement("span", null, "Use the checkboxes to select individual bookmarks to share."))) : ('Only selected bookmarks will be shared.')),
+            React.createElement(DialogContentText, null, "Copy the URL below to share your bookmarks."),
+            error ? (React.createElement(ErrorMessage, { error: error })) : loading ? (React.createElement(Typography, null, "Generating short URL...")) : (React.createElement(TextField, { label: "URL", value: url, InputProps: { readOnly: true }, variant: "filled", fullWidth: true, onClick: event => {
+                    const target = event.target;
+                    target.select();
+                } })),
+            React.createElement(DialogContentText, null, "The URL should be pasted into the \"Import from share link\" field in the \"Import\" form found in the \"Bookmarked regions\" drawer.")),
+        React.createElement(DialogActions, null,
+            React.createElement(Button, { className: classes.flexItem, "data-testid": "dialogShare", variant: "contained", color: "primary", disabled: loading, startIcon: React.createElement(ContentCopyIcon, null), onClick: async () => {
+                    copy(url);
+                    session.notify('Copied to clipboard', 'success');
+                    onClose();
+                } }, "Copy share link"))));
+});
+export default ShareBookmarksDialog;

package/esm/GridBookmarkWidget/model.d.ts

@@ -1,11 +1,48 @@
-import { Instance } from 'mobx-state-tree';
+import { Instance, SnapshotIn, IMSTArray } from 'mobx-state-tree';
 import PluginManager from '@jbrowse/core/PluginManager';
 import { Region } from '@jbrowse/core/util/types';
-export default function f(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+declare const LabeledRegionModel: import("mobx-state-tree").IModelType<{
+    refName: import("mobx-state-tree").ISimpleType<string>;
+    start: import("mobx-state-tree").ISimpleType<number>;
+    end: import("mobx-state-tree").ISimpleType<number>;
+    reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+} & {
+    assemblyName: import("mobx-state-tree").ISimpleType<string>;
+} & {
+    label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+}, {
+    setRefName(newRefName: string): void;
+} & {
+    setLabel(label: string): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export interface ILabeledRegionModel extends SnapshotIn<typeof LabeledRegionModel> {
+    refName: string;
+    start: number;
+    end: number;
+    reversed: boolean;
+    assemblyName: string;
+    label: string;
+    setRefName: (newRefName: string) => void;
+    setLabel: (label: string) => void;
+}
+export interface IExtendedLabeledRegionModel extends ILabeledRegionModel {
+    id: number;
+    correspondingObj: ILabeledRegionModel;
+}
+export default function f(_pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    /**
+     * #property
+     */
     type: import("mobx-state-tree").ISimpleType<"GridBookmarkWidget">;
-    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    bookmarkedRegions: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     * removed by postProcessSnapshot, only loaded from localStorage
+     */
+    bookmarks: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
         refName: import("mobx-state-tree").ISimpleType<string>;
         start: import("mobx-state-tree").ISimpleType<number>;
         end: import("mobx-state-tree").ISimpleType<number>;
@@ -18,18 +55,148 @@ export default function f(pluginManager: PluginManager): import("mobx-state-tree
         setRefName(newRefName: string): void;
     } & {
         setLabel(label: string): void;
-    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    modelSelectedAssembly: import("mobx-state-tree").IType<string | undefined, string, string>;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, [undefined]>;
 }, {
+    selectedBookmarks: IExtendedLabeledRegionModel[];
+    selectedAssembliesPre: string[] | undefined;
+} & {
+    readonly bookmarkAssemblies: string[];
+    readonly validAssemblies: Set<string>;
+} & {
+    readonly bookmarksWithValidAssemblies: ({
+        refName: string;
+        start: number;
+        end: number;
+        reversed: boolean;
+        assemblyName: string;
+        label: string;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setRefName(newRefName: string): void;
+    } & {
+        setLabel(label: string): void;
+    } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        refName: import("mobx-state-tree").ISimpleType<string>;
+        start: import("mobx-state-tree").ISimpleType<number>;
+        end: import("mobx-state-tree").ISimpleType<number>;
+        reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    } & {
+        assemblyName: import("mobx-state-tree").ISimpleType<string>;
+    } & {
+        label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    }, {
+        setRefName(newRefName: string): void;
+    } & {
+        setLabel(label: string): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>)[];
+} & {
+    readonly sharedBookmarksModel: {
+        sharedBookmarks: (IMSTArray<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IMaybe<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>>>) | undefined;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        sharedBookmarks: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>>;
+    }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    readonly allBookmarksModel: {
+        sharedBookmarks: (IMSTArray<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IMaybe<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>>>) | undefined;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        sharedBookmarks: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
+            refName: import("mobx-state-tree").ISimpleType<string>;
+            start: import("mobx-state-tree").ISimpleType<number>;
+            end: import("mobx-state-tree").ISimpleType<number>;
+            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        } & {
+            assemblyName: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        }, {
+            setRefName(newRefName: string): void;
+        } & {
+            setLabel(label: string): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>>;
+    }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+} & {
+    setSelectedAssemblies(assemblies?: string[]): void;
+} & {
+    readonly selectedAssemblies: string[];
+} & {
     importBookmarks(regions: Region[]): void;
     addBookmark(region: Region): void;
     removeBookmark(index: number): void;
+    updateBookmarkLabel(bookmark: IExtendedLabeledRegionModel, label: string): void;
+    setSelectedBookmarks(bookmarks: IExtendedLabeledRegionModel[]): void;
+    setBookmarkedRegions(regions: IMSTArray<typeof LabeledRegionModel>): void;
+} & {
     clearAllBookmarks(): void;
-    updateBookmarkLabel(index: number, label: string): void;
-    setSelectedAssembly(assembly: string): void;
+    clearSelectedBookmarks(): void;
 } & {
-    readonly selectedAssembly: string;
-    readonly assemblies: string[];
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+    afterAttach(): void;
+}, import("mobx-state-tree")._NotCustomized, {
+    type: "GridBookmarkWidget";
+    id: string;
+}>;
 export type GridBookmarkStateModel = ReturnType<typeof f>;
 export type GridBookmarkModel = Instance<GridBookmarkStateModel>;
+export {};