@jbrowse/plugin-grid-bookmark 2.6.2 → 2.7.0

package/esm/GridBookmarkWidget/model.js

@@ -1,53 +1,131 @@
-import { types, cast } from 'mobx-state-tree';
+import { types, cast, addDisposer, } from 'mobx-state-tree';
 import { Region as RegionModel, ElementId } from '@jbrowse/core/util/types/mst';
+import { getSession, localStorageGetItem, localStorageSetItem, } from '@jbrowse/core/util';
+import { autorun } from 'mobx';
 const LabeledRegionModel = types
-    .compose(RegionModel, types.model('Label', { label: types.optional(types.string, '') }))
+    .compose(RegionModel, types.model('Label', {
+    label: types.optional(types.string, ''),
+}))
     .actions(self => ({
     setLabel(label) {
         self.label = label;
     },
 }));
-export default function f(pluginManager) {
+const SharedBookmarksModel = types.model('SharedBookmarksModel', {
+    sharedBookmarks: types.maybe(types.array(LabeledRegionModel)),
+});
+const localStorageKeyF = () => typeof window !== undefined
+    ? `bookmarks-${[window.location.host + window.location.pathname].join('-')}`
+    : 'empty';
+export default function f(_pluginManager) {
     return types
         .model('GridBookmarkModel', {
+        /**
+         * #property
+         */
         id: ElementId,
+        /**
+         * #property
+         */
         type: types.literal('GridBookmarkWidget'),
-        view: types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
-        bookmarkedRegions: types.array(LabeledRegionModel),
-        modelSelectedAssembly: '',
+        /**
+         * #property
+         * removed by postProcessSnapshot, only loaded from localStorage
+         */
+        bookmarks: types.optional(types.array(LabeledRegionModel), () => JSON.parse(localStorageGetItem(localStorageKeyF()) || '[]')),
     })
+        .volatile(() => ({
+        selectedBookmarks: [],
+        selectedAssembliesPre: undefined,
+    }))
+        .views(self => ({
+        get bookmarkAssemblies() {
+            return [...new Set(self.bookmarks.map(r => r.assemblyName))];
+        },
+        get validAssemblies() {
+            const { assemblyManager } = getSession(self);
+            return new Set(this.bookmarkAssemblies.filter(a => assemblyManager.get(a)));
+        },
+    }))
+        .views(self => ({
+        get bookmarksWithValidAssemblies() {
+            return self.bookmarks.filter(e => self.validAssemblies.has(e.assemblyName));
+        },
+    }))
+        .views(self => ({
+        get sharedBookmarksModel() {
+            // requires cloning bookmarks with JSON.stringify/parse to avoid duplicate
+            // reference to same object in the same state tree, will otherwise error
+            // when performing share
+            return SharedBookmarksModel.create({
+                sharedBookmarks: JSON.parse(JSON.stringify(self.selectedBookmarks)),
+            });
+        },
+        get allBookmarksModel() {
+            // requires cloning bookmarks with JSON.stringify/parse to avoid duplicate
+            // reference to same object in the same state tree, will otherwise error
+            // when performing share
+            return SharedBookmarksModel.create({
+                sharedBookmarks: JSON.parse(JSON.stringify(self.bookmarksWithValidAssemblies)),
+            });
+        },
+    }))
+        .actions(self => ({
+        setSelectedAssemblies(assemblies) {
+            self.selectedAssembliesPre = assemblies;
+        },
+    }))
+        .views(self => ({
+        get selectedAssemblies() {
+            var _a, _b;
+            return ((_b = (_a = self.selectedAssembliesPre) === null || _a === void 0 ? void 0 : _a.filter(f => self.validAssemblies.has(f))) !== null && _b !== void 0 ? _b : [...self.validAssemblies]);
+        },
+    }))
         .actions(self => ({
         importBookmarks(regions) {
-            self.bookmarkedRegions = cast([...self.bookmarkedRegions, ...regions]);
+            self.bookmarks = cast([...self.bookmarks, ...regions]);
         },
         addBookmark(region) {
-            self.bookmarkedRegions.push(region);
+            self.bookmarks.push(region);
         },
         removeBookmark(index) {
-            self.bookmarkedRegions.splice(index, 1);
+            self.bookmarks.splice(index, 1);
+        },
+        updateBookmarkLabel(bookmark, label) {
+            bookmark.correspondingObj.setLabel(label);
+        },
+        setSelectedBookmarks(bookmarks) {
+            self.selectedBookmarks = bookmarks;
         },
+        setBookmarkedRegions(regions) {
+            self.bookmarks = cast(regions);
+        },
+    }))
+        .actions(self => ({
         clearAllBookmarks() {
-            self.bookmarkedRegions.clear();
+            for (const bookmark of self.bookmarks) {
+                if (self.validAssemblies.has(bookmark.assemblyName)) {
+                    self.bookmarks.remove(bookmark);
+                }
+            }
         },
-        updateBookmarkLabel(index, label) {
-            var _a;
-            (_a = self.bookmarkedRegions[index]) === null || _a === void 0 ? void 0 : _a.setLabel(label);
+        clearSelectedBookmarks() {
+            for (const bookmark of self.selectedBookmarks) {
+                self.bookmarks.remove(bookmark.correspondingObj);
+            }
+            self.selectedBookmarks = [];
         },
-        setSelectedAssembly(assembly) {
-            self.modelSelectedAssembly = assembly;
+    }))
+        .actions(self => ({
+        afterAttach() {
+            const key = localStorageKeyF();
+            addDisposer(self, autorun(() => {
+                localStorageSetItem(key, JSON.stringify(self.bookmarks));
+            }));
         },
     }))
-        .views(self => ({
-        get selectedAssembly() {
-            return (self.modelSelectedAssembly ||
-                (self.bookmarkedRegions.length
-                    ? self.bookmarkedRegions[0].assemblyName
-                    : ''));
-        },
-        get assemblies() {
-            return [
-                ...new Set(self.bookmarkedRegions.map(region => region.assemblyName)),
-            ];
-        },
-    }));
+        .postProcessSnapshot(snap => {
+        const { bookmarks: _, ...rest } = snap;
+        return rest;
+    });
 }

package/esm/GridBookmarkWidget/sessionSharing.d.ts

@@ -0,0 +1,6 @@
+export declare function shareSessionToDynamo(session: unknown, url: string, referer: string): Promise<{
+    json: any;
+    encryptedSession: string;
+    password: string;
+}>;
+export declare function readSessionFromDynamo(baseUrl: string, sessionQueryParam: string, password: string, signal?: AbortSignal): Promise<string>;

package/esm/GridBookmarkWidget/sessionSharing.js

@@ -0,0 +1,68 @@
+// duplicated from products/jbrowse-web/src/sessionSharing.ts ; could possibly be moved into a higher directory and shared between the two
+import { toUrlSafeB64 } from './utils';
+// from https://stackoverflow.com/questions/1349404/
+function generateUID(length) {
+    return window
+        .btoa([...window.crypto.getRandomValues(new Uint8Array(length * 2))]
+        .map(b => String.fromCharCode(b))
+        .join(''))
+        .replaceAll(/[+/]/g, '')
+        .slice(0, length);
+}
+const encrypt = async (text, password) => {
+    const AES = await import('crypto-js/aes');
+    return AES.encrypt(text, password).toString();
+};
+const decrypt = async (text, password) => {
+    const AES = await import('crypto-js/aes');
+    const Utf8 = await import('crypto-js/enc-utf8');
+    const bytes = AES.decrypt(text, password);
+    return bytes.toString(Utf8);
+};
+function getErrorMsg(err) {
+    try {
+        const obj = JSON.parse(err);
+        return obj.message;
+    }
+    catch (e) {
+        return err;
+    }
+}
+// writes the encrypted session, current datetime, and referer to DynamoDB
+export async function shareSessionToDynamo(session, url, referer) {
+    const sess = await toUrlSafeB64(JSON.stringify(session));
+    const password = generateUID(5);
+    const encryptedSession = await encrypt(sess, password);
+    const data = new FormData();
+    data.append('session', encryptedSession);
+    data.append('dateShared', `${Date.now()}`);
+    data.append('referer', referer);
+    const response = await fetch(`${url}share`, {
+        method: 'POST',
+        mode: 'cors',
+        body: data,
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(getErrorMsg(err));
+    }
+    const json = await response.json();
+    return {
+        json,
+        encryptedSession,
+        password,
+    };
+}
+export async function readSessionFromDynamo(baseUrl, sessionQueryParam, password, signal) {
+    const sessionId = sessionQueryParam.split('share-')[1];
+    const url = `${baseUrl}?sessionId=${encodeURIComponent(sessionId)}`;
+    const response = await fetch(url, {
+        signal,
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(getErrorMsg(err));
+    }
+    const json = await response.json();
+    return decrypt(json.session, password);
+}

package/esm/GridBookmarkWidget/utils.d.ts

@@ -1,5 +1,21 @@
 import { AbstractViewModel } from '@jbrowse/core/util/types';
 import { GridBookmarkModel } from './model';
-import { LabeledRegion } from './types';
-export declare function navToBookmark(locString: string, views: AbstractViewModel[], model: GridBookmarkModel): Promise<void>;
-export declare function downloadBookmarkFile(bookmarkedRegions: LabeledRegion[], fileFormat: string, model: GridBookmarkModel): void;
+export declare function navToBookmark(locString: string, assembly: string, views: AbstractViewModel[], model: GridBookmarkModel): Promise<void>;
+export declare function downloadBookmarkFile(fileFormat: string, model: GridBookmarkModel): void;
+/**
+ * Pad the end of a base64 string with "=" to make it valid
+ * @param b64 - unpadded b64 string
+ */
+export declare function b64PadSuffix(b64: string): string;
+/**
+ * Decode and inflate a url-safe base64 to a string
+ * See {@link https://en.wikipedia.org/wiki/Base64#URL_applications}
+ * @param b64 - a base64 string to decode and inflate
+ */
+export declare function fromUrlSafeB64(b64: string): Promise<string>;
+/**
+ * Compress and encode a string as url-safe base64
+ * See {@link https://en.wikipedia.org/wiki/Base64#URL_applications}
+ * @param str-  a string to compress and encode
+ */
+export declare function toUrlSafeB64(str: string): Promise<string>;

package/esm/GridBookmarkWidget/utils.js

@@ -1,56 +1,122 @@
 import { saveAs } from 'file-saver';
 import { getSession, assembleLocString } from '@jbrowse/core/util';
-export async function navToBookmark(locString, views, model) {
+export async function navToBookmark(locString, assembly, views, model) {
     const session = getSession(model);
     try {
-        // search for exact match to an lgv that this bookmark widget launched, or
-        // any lgv that looks like it is relevant to what we are browsing
-        const { selectedAssembly } = model;
-        const newViewId = `${model.id}_${selectedAssembly}`;
-        let view = (views.find(v => v.type === 'LinearGenomeView' && v.id === newViewId) ||
-            views.find(v => v.type === 'LinearGenomeView' &&
-                // @ts-expect-error
-                v.assemblyNames[0] === selectedAssembly));
+        // get the focused view
+        let view = views.find(view => view.id === session.focusedViewId);
+        // check if the focused view is the appropriate assembly, if not proceed
+        if ((view === null || view === void 0 ? void 0 : view.assemblyNames[0]) !== assembly) {
+            view = views.find(elt => 
+            // @ts-expect-error
+            elt.type === 'LinearGenomeView' && elt.assemblyNames[0] === assembly);
+        }
+        // if no view is opened of the selectedAssembly, open a new
+        // view with that assembly
         if (!view) {
+            const newViewId = `${model.id}_${assembly}`;
             view = session.addView('LinearGenomeView', {
                 id: newViewId,
             });
         }
-        await view.navToLocString(locString, selectedAssembly);
+        await view.navToLocString(locString, assembly);
     }
     catch (e) {
         console.error(e);
         session.notify(`${e}`, 'error');
     }
 }
-export function downloadBookmarkFile(bookmarkedRegions, fileFormat, model) {
-    const { selectedAssembly } = model;
-    const fileHeader = fileFormat === 'TSV'
-        ? 'chrom\tstart\tend\tlabel\tassembly_name\tcoord_range\n'
-        : '';
-    const fileContents = bookmarkedRegions
-        .map(b => {
-        const { label } = b;
-        const labelVal = label === '' ? '.' : label;
-        const locString = assembleLocString(b);
-        if (fileFormat === 'BED') {
-            if (b.assemblyName === selectedAssembly || selectedAssembly === 'all') {
-                return `${b.refName}\t${b.start}\t${b.end}\t${labelVal}\n`;
-            }
-            return '';
-        }
-        else {
-            return `${b.refName}\t${b.start + 1}\t${b.end}\t${labelVal}\t${b.assemblyName}\t${locString}\n`;
+export function downloadBookmarkFile(fileFormat, model) {
+    const { selectedBookmarks, bookmarksWithValidAssemblies } = model;
+    const bookmarksToDownload = selectedBookmarks.length === 0
+        ? bookmarksWithValidAssemblies
+        : selectedBookmarks;
+    if (fileFormat === 'BED') {
+        const fileHeader = '';
+        const fileContents = {};
+        bookmarksToDownload.forEach(bookmark => {
+            const { label } = bookmark;
+            const labelVal = label === '' ? '.' : label;
+            const line = `${bookmark.refName}\t${bookmark.start}\t${bookmark.end}\t${labelVal}\n`;
+            fileContents[bookmark.assemblyName]
+                ? fileContents[bookmark.assemblyName].push(line)
+                : (fileContents[bookmark.assemblyName] = [line]);
+        });
+        for (const assembly in fileContents) {
+            const fileContent = fileContents[assembly].reduce((a, b) => a + b, fileHeader);
+            const blob = new Blob([fileContent || ''], {
+                type: 'text/x-bed;charset=utf-8',
+            });
+            const fileName = `jbrowse_bookmarks_${assembly}.bed`;
+            saveAs(blob, fileName);
         }
-    })
-        .reduce((a, b) => a + b, fileHeader);
-    const blob = new Blob([fileContents || ''], {
-        type: fileFormat === 'BED'
-            ? 'text/x-bed;charset=utf-8'
-            : 'text/tab-separated-values;charset=utf-8',
-    });
-    const fileName = fileFormat === 'BED'
-        ? `jbrowse_bookmarks_${selectedAssembly}.bed`
-        : 'jbrowse_bookmarks.tsv';
-    saveAs(blob, fileName);
+    }
+    else {
+        // TSV
+        const fileHeader = 'chrom\tstart\tend\tlabel\tassembly_name\tcoord_range\n';
+        const fileContents = bookmarksToDownload
+            .map(bookmark => {
+            const { label } = bookmark;
+            const labelVal = label === '' ? '.' : label;
+            const locString = assembleLocString(bookmark);
+            return `${bookmark.refName}\t${bookmark.start + 1}\t${bookmark.end}\t${labelVal}\t${bookmark.assemblyName}\t${locString}\n`;
+        })
+            .reduce((a, b) => a + b, fileHeader);
+        const blob = new Blob([fileContents || ''], {
+            type: 'text/tab-separated-values;charset=utf-8',
+        });
+        const fileName = 'jbrowse_bookmarks.tsv';
+        saveAs(blob, fileName);
+    }
+}
+/**
+ * Pad the end of a base64 string with "=" to make it valid
+ * @param b64 - unpadded b64 string
+ */
+export function b64PadSuffix(b64) {
+    let num = 0;
+    const mo = b64.length % 4;
+    switch (mo) {
+        case 3:
+            num = 1;
+            break;
+        case 2:
+            num = 2;
+            break;
+        case 0:
+            num = 0;
+            break;
+        default:
+            throw new Error('base64 not a valid length');
+    }
+    return b64 + '='.repeat(num);
+}
+/**
+ * Decode and inflate a url-safe base64 to a string
+ * See {@link https://en.wikipedia.org/wiki/Base64#URL_applications}
+ * @param b64 - a base64 string to decode and inflate
+ */
+export async function fromUrlSafeB64(b64) {
+    const originalB64 = b64PadSuffix(b64.replaceAll('-', '+').replaceAll('_', '/'));
+    const { toByteArray } = await import('base64-js');
+    const { inflate } = await import('pako');
+    const bytes = toByteArray(originalB64);
+    const inflated = inflate(bytes);
+    return new TextDecoder().decode(inflated);
+}
+/**
+ * Compress and encode a string as url-safe base64
+ * See {@link https://en.wikipedia.org/wiki/Base64#URL_applications}
+ * @param str-  a string to compress and encode
+ */
+export async function toUrlSafeB64(str) {
+    const bytes = new TextEncoder().encode(str);
+    const { deflate } = await import('pako');
+    const { fromByteArray } = await import('base64-js');
+    const deflated = deflate(bytes);
+    const encoded = fromByteArray(deflated);
+    const pos = encoded.indexOf('=');
+    return pos > 0
+        ? encoded.slice(0, pos).replaceAll('+', '-').replaceAll('/', '_')
+        : encoded.replaceAll('+', '-').replaceAll('/', '_');
 }

package/esm/index.d.ts

@@ -3,5 +3,5 @@ import PluginManager from '@jbrowse/core/PluginManager';
 export default class extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;
-    configure(_pluginManager: PluginManager): void;
+    configure(pluginManager: PluginManager): void;
 }

package/esm/index.js

@@ -1,5 +1,5 @@
 import Plugin from '@jbrowse/core/Plugin';
-import { getSession, isSessionModelWithWidgets } from '@jbrowse/core/util';
+import { getSession, isAbstractMenuManager, isSessionModelWithWidgets, } from '@jbrowse/core/util';
 // icons
 import BookmarkIcon from '@mui/icons-material/Bookmark';
 import BookmarksIcon from '@mui/icons-material/Bookmarks';
@@ -14,91 +14,116 @@ export default class extends Plugin {
         pluginManager.addToExtensionPoint('Core-extendPluggableElement', (pluggableElement) => {
             if (pluggableElement.name === 'LinearGenomeView') {
                 const { stateModel } = pluggableElement;
-                const newStateModel = stateModel.extend((self) => {
+                const lgv = stateModel;
+                const newStateModel = lgv
+                    .actions(self => ({
+                    activateBookmarkWidget() {
+                        const session = getSession(self);
+                        if (isSessionModelWithWidgets(session)) {
+                            let bookmarkWidget = session.widgets.get('GridBookmark');
+                            if (!bookmarkWidget) {
+                                bookmarkWidget = session.addWidget('GridBookmarkWidget', 'GridBookmark');
+                            }
+                            session.showWidget(bookmarkWidget);
+                            return session.widgets.get('GridBookmark');
+                        }
+                        throw new Error('Could not open bookmark widget');
+                    },
+                }))
+                    .actions(self => ({
+                    navigateNewestBookmark() {
+                        const session = getSession(self);
+                        const bookmarkWidget = self.activateBookmarkWidget();
+                        const regions = bookmarkWidget.bookmarks;
+                        if (regions === null || regions === void 0 ? void 0 : regions.length) {
+                            self.navTo(regions.at(-1));
+                        }
+                        else {
+                            session.notify('There are no recent bookmarks to navigate to.', 'info');
+                        }
+                    },
+                    bookmarkCurrentRegion() {
+                        if (self.id === getSession(self).focusedViewId) {
+                            const selectedRegions = self.getSelectedRegions(undefined, undefined);
+                            const bookmarkWidget = self.activateBookmarkWidget();
+                            bookmarkWidget.addBookmark(selectedRegions[0]);
+                        }
+                    },
+                }))
+                    .views(self => {
                     const superMenuItems = self.menuItems;
                     const superRubberBandMenuItems = self.rubberBandMenuItems;
                     return {
-                        actions: {
-                            activateBookmarkWidget() {
-                                const session = getSession(self);
-                                if (isSessionModelWithWidgets(session)) {
-                                    let bookmarkWidget = session.widgets.get('GridBookmark');
-                                    if (!bookmarkWidget) {
-                                        bookmarkWidget = session.addWidget('GridBookmarkWidget', 'GridBookmark', { view: self });
-                                    }
-                                    session.showWidget(bookmarkWidget);
-                                    return bookmarkWidget;
-                                }
-                                throw new Error('Could not open bookmark widget');
-                            },
-                            bookmarkCurrentRegion() {
-                                const selectedRegions = self.getSelectedRegions(self.leftOffset, self.rightOffset);
-                                const firstRegion = selectedRegions[0];
-                                const session = getSession(self);
-                                if (isSessionModelWithWidgets(session)) {
-                                    const { widgets } = session;
-                                    let bookmarkWidget = widgets.get('GridBookmark');
-                                    if (!bookmarkWidget) {
-                                        this.activateBookmarkWidget();
-                                        bookmarkWidget = widgets.get('GridBookmark');
-                                    }
-                                    // @ts-expect-error
-                                    bookmarkWidget.addBookmark(firstRegion);
-                                }
-                            },
+                        menuItems() {
+                            return [
+                                ...superMenuItems(),
+                                { type: 'divider' },
+                                {
+                                    label: 'Open bookmark widget',
+                                    icon: BookmarksIcon,
+                                    onClick: () => self.activateBookmarkWidget(),
+                                },
+                                {
+                                    label: 'Bookmark current region',
+                                    icon: BookmarkIcon,
+                                    onClick: () => self.bookmarkCurrentRegion(),
+                                },
+                            ];
                         },
-                        views: {
-                            menuItems() {
-                                return [
-                                    ...superMenuItems(),
-                                    { type: 'divider' },
-                                    {
-                                        label: 'Open bookmark widget',
-                                        icon: BookmarksIcon,
-                                        // @ts-expect-error
-                                        onClick: self.activateBookmarkWidget,
+                        rubberBandMenuItems() {
+                            return [
+                                ...superRubberBandMenuItems(),
+                                {
+                                    label: 'Bookmark region',
+                                    icon: BookmarkIcon,
+                                    onClick: () => {
+                                        const { leftOffset, rightOffset } = self;
+                                        const selectedRegions = self.getSelectedRegions(leftOffset, rightOffset);
+                                        const bookmarkWidget = self.activateBookmarkWidget();
+                                        bookmarkWidget.addBookmark(selectedRegions[0]);
                                     },
-                                    {
-                                        label: 'Bookmark current region',
-                                        icon: BookmarkIcon,
-                                        // @ts-expect-error
-                                        onClick: self.bookmarkCurrentRegion,
-                                    },
-                                ];
-                            },
-                            rubberBandMenuItems() {
-                                return [
-                                    ...superRubberBandMenuItems(),
-                                    {
-                                        label: 'Bookmark region',
-                                        icon: BookmarkIcon,
-                                        onClick: () => {
-                                            const { leftOffset, rightOffset } = self;
-                                            const selectedRegions = self.getSelectedRegions(leftOffset, rightOffset);
-                                            const firstRegion = selectedRegions[0];
-                                            const session = getSession(self);
-                                            if (isSessionModelWithWidgets(session)) {
-                                                const { widgets } = session;
-                                                let bookmarkWidget = widgets.get('GridBookmark');
-                                                if (!bookmarkWidget) {
-                                                    // @ts-expect-error
-                                                    self.activateBookmarkWidget();
-                                                    bookmarkWidget = widgets.get('GridBookmark');
-                                                }
-                                                // @ts-expect-error
-                                                bookmarkWidget.addBookmark(firstRegion);
-                                            }
-                                        },
-                                    },
-                                ];
-                            },
+                                },
+                            ];
                         },
                     };
-                });
+                })
+                    .actions(self => ({
+                    afterCreate() {
+                        document.addEventListener('keydown', e => {
+                            const activationSequence = (e.ctrlKey || e.metaKey) && e.shiftKey;
+                            // ctrl+shift+d or cmd+shift+d
+                            if (activationSequence && e.code === 'KeyD') {
+                                e.preventDefault();
+                                self.activateBookmarkWidget();
+                                self.bookmarkCurrentRegion();
+                                getSession(self).notify('Bookmark created.', 'success');
+                            }
+                            // ctrl+shift+m or cmd+shift+m
+                            if (activationSequence && e.code === 'KeyM') {
+                                e.preventDefault();
+                                self.navigateNewestBookmark();
+                            }
+                        });
+                    },
+                }));
                 pluggableElement.stateModel = newStateModel;
             }
             return pluggableElement;
         });
     }
-    configure(_pluginManager) { }
+    configure(pluginManager) {
+        if (isAbstractMenuManager(pluginManager.rootModel)) {
+            pluginManager.rootModel.appendToMenu('Tools', {
+                label: 'Bookmarks',
+                icon: BookmarksIcon,
+                onClick: (session) => {
+                    let bookmarkWidget = session.widgets.get('GridBookmark');
+                    if (!bookmarkWidget) {
+                        bookmarkWidget = session.addWidget('GridBookmarkWidget', 'GridBookmark');
+                    }
+                    session.showWidget(bookmarkWidget);
+                },
+            });
+        }
+    }
 }