@jupyterlab/notebook-extension 4.7.0-alpha.0 → 4.7.0-alpha.2

package/lib/index.d.ts

@@ -3,6 +3,20 @@
  * @module notebook-extension
  */
 import type { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { Token } from '@lumino/coreutils';
+/**
+ * An interface describing how export guidance is presented to users.
+ */
+export interface INotebookExportGuidance {
+    /**
+     * Show guidance for enabling notebook exports.
+     */
+    showExportHelp(): Promise<void>;
+}
+/**
+ * A token describing a service for showing notebook export guidance.
+ */
+export declare const INotebookExportGuidance: Token<INotebookExportGuidance>;
 /**
  * A plugin providing a CommandEdit status item.
  */
@@ -19,6 +33,10 @@ export declare const executionIndicator: JupyterFrontEndPlugin<void>;
  * A plugin providing export commands in the main menu and command palette
  */
 export declare const exportPlugin: JupyterFrontEndPlugin<void>;
+/**
+ * A plugin providing the default notebook export guidance service.
+ */
+export declare const exportGuidanceDialogPlugin: JupyterFrontEndPlugin<INotebookExportGuidance>;
 /**
  * A plugin that adds a notebook trust status item to the status bar.
  */

package/lib/index.js

@@ -6,7 +6,7 @@
  * @module notebook-extension
  */
 import { ILabShell, ILayoutRestorer, IRouter } from '@jupyterlab/application';
-import { Clipboard, createToolbarFactory, Dialog, ICommandPalette, IKernelStatusModel, InputDialog, ISanitizer, ISessionContextDialogs, IToolbarWidgetRegistry, MainAreaWidget, Sanitizer, SemanticCommand, SessionContextDialogs, showDialog, Toolbar, WidgetTracker } from '@jupyterlab/apputils';
+import { Clipboard, CommandLinker, createToolbarFactory, Dialog, ICommandPalette, IKernelStatusModel, InputDialog, ISanitizer, ISessionContextDialogs, IToolbarWidgetRegistry, MainAreaWidget, Sanitizer, SemanticCommand, SessionContextDialogs, showDialog, Toolbar, WidgetTracker } from '@jupyterlab/apputils';
 import { MarkdownCell } from '@jupyterlab/cells';
 import { IEditorServices, IPositionModel } from '@jupyterlab/codeeditor';
 import { compareVersions, PageConfig } from '@jupyterlab/coreutils';
@@ -31,14 +31,14 @@ import { ITableOfContentsRegistry } from '@jupyterlab/toc';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { addAboveIcon, addBelowIcon, buildIcon, copyIcon, cutIcon, duplicateIcon, fastForwardIcon, IFormRendererRegistry, infoIcon, moveDownIcon, moveUpIcon, notebookIcon, pasteIcon, refreshIcon, runIcon, stopIcon } from '@jupyterlab/ui-components';
 import { ArrayExt } from '@lumino/algorithm';
-import { JSONExt, UUID } from '@lumino/coreutils';
+import { JSONExt, Token, UUID } from '@lumino/coreutils';
 import { DisposableSet } from '@lumino/disposable';
 import { MessageLoop } from '@lumino/messaging';
 import { Panel } from '@lumino/widgets';
 import { CellBarExtension } from '@jupyterlab/cell-toolbar';
 import { cellExecutor } from './cellexecutor';
 import { logNotebookOutput } from './nboutput';
-import { ActiveCellTool } from './tool-widgets/activeCellToolWidget';
+import { ActiveCellTool, CellIdField } from './tool-widgets/activeCellToolWidget';
 import { CellMetadataField, NotebookMetadataField } from './tool-widgets/metadataEditorFields';
 /**
  * The command IDs used by the notebook plugin.
@@ -62,6 +62,7 @@ var CommandIDs;
     CommandIDs.closeAndShutdown = 'notebook:close-and-shutdown';
     CommandIDs.trust = 'notebook:trust';
     CommandIDs.exportToFormat = 'notebook:export-to-format';
+    CommandIDs.showExportGuidance = 'notebook:show-export-guidance';
     CommandIDs.run = 'notebook:run-cell';
     CommandIDs.runAndAdvance = 'notebook:run-cell-and-select-next';
     CommandIDs.runAndInsert = 'notebook:run-cell-and-insert-below';
@@ -156,6 +157,14 @@ const FACTORY = 'Notebook';
  * (returned from nbconvert's export list)
  */
 const FORMAT_EXCLUDE = ['notebook', 'python', 'custom'];
+/**
+ * Documentation page describing notebook export support.
+ */
+const NOTEBOOK_EXPORT_DOCS_URL = 'https://jupyterlab.readthedocs.io/en/stable/user/export.html';
+/**
+ * A token describing a service for showing notebook export guidance.
+ */
+export const INotebookExportGuidance = new Token('@jupyterlab/notebook-extension:INotebookExportGuidance', 'A service for showing notebook export guidance.');
 /**
  * Setting Id storing the customized toolbar definition.
  */
@@ -378,9 +387,8 @@ export const exportPlugin = {
     description: 'Adds the export notebook commands.',
     autoStart: true,
     requires: [ITranslator, INotebookTracker],
-    optional: [IMainMenu, ICommandPalette],
-    activate: (app, translator, tracker, mainMenu, palette) => {
-        var _a;
+    optional: [IMainMenu, ICommandPalette, INotebookExportGuidance],
+    activate: (app, translator, tracker, mainMenu, palette, exportGuidance) => {
         const trans = translator.load('jupyterlab');
         const { commands, shell } = app;
         const services = app.serviceManager;
@@ -455,63 +463,156 @@ export const exportPlugin = {
                 }
             }
         });
+        commands.addCommand(CommandIDs.showExportGuidance, {
+            label: trans.__('Enable notebook exports'),
+            execute: () => {
+                if (exportGuidance) {
+                    return exportGuidance.showExportHelp();
+                }
+                window.open(NOTEBOOK_EXPORT_DOCS_URL, '_blank', 'noopener,noreferrer');
+                return undefined;
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {}
+                }
+            }
+        });
         // Add a notebook group to the File menu.
-        let exportTo;
-        if (mainMenu) {
-            exportTo = (_a = mainMenu.fileMenu.items.find(item => {
+        const fileMenu = mainMenu === null || mainMenu === void 0 ? void 0 : mainMenu.fileMenu;
+        const getExportMenu = () => {
+            var _a, _b;
+            return ((_b = (_a = fileMenu === null || fileMenu === void 0 ? void 0 : fileMenu.items.find(item => {
                 var _a;
                 return item.type === 'submenu' &&
                     ((_a = item.submenu) === null || _a === void 0 ? void 0 : _a.id) === 'jp-mainmenu-file-notebookexport';
-            })) === null || _a === void 0 ? void 0 : _a.submenu;
-        }
+            })) === null || _a === void 0 ? void 0 : _a.submenu) !== null && _b !== void 0 ? _b : undefined);
+        };
         let formatsInitialized = false;
+        let paletteInitialized = false;
+        let exportFormats = null;
+        const updateExportMenu = () => {
+            const exportTo = getExportMenu();
+            if (!exportTo || !exportFormats) {
+                return;
+            }
+            exportTo.clearItems();
+            if (exportFormats.length === 0) {
+                exportTo.addItem({
+                    command: CommandIDs.showExportGuidance
+                });
+                return;
+            }
+            exportFormats.forEach(({ format, label }) => {
+                exportTo.addItem({
+                    command: CommandIDs.exportToFormat,
+                    args: {
+                        format,
+                        label,
+                        isPalette: false
+                    }
+                });
+            });
+            if (palette && !paletteInitialized) {
+                const category = trans.__('Notebook Operations');
+                exportFormats.forEach(({ format, label }) => {
+                    palette.addItem({
+                        command: CommandIDs.exportToFormat,
+                        category,
+                        args: {
+                            format,
+                            label,
+                            isPalette: true
+                        }
+                    });
+                });
+                paletteInitialized = true;
+            }
+        };
         /** Request formats only when a notebook might use them. */
         const maybeInitializeFormats = async () => {
             if (formatsInitialized) {
+                updateExportMenu();
+                return;
+            }
+            if (tracker.size === 0) {
                 return;
             }
             tracker.widgetAdded.disconnect(maybeInitializeFormats);
             formatsInitialized = true;
-            const response = await services.nbconvert.getExportFormats(false);
-            if (!response) {
-                return;
+            let response = null;
+            try {
+                response = await services.nbconvert.getExportFormats(false);
+            }
+            catch (_a) {
+                // Ignore fetch errors and fallback to export guidance.
             }
             const formatLabels = Private.getFormatLabels(translator);
-            // Convert export list to palette and menu items.
-            const formatList = Object.keys(response);
-            formatList.forEach(function (key) {
+            // Convert export list to menu and palette items.
+            exportFormats = Object.keys(response !== null && response !== void 0 ? response : {})
+                .filter(key => !FORMAT_EXCLUDE.includes(key))
+                .map(key => {
                 const formattedKey = key[0].toLocaleUpperCase() + key.slice(1);
+                // Fallback for export formats the server offers but `formatLabels`
+                // does not know about, so there is no literal to extract.
+                // eslint-disable-next-line jupyter/no-dynamic-translation
                 const capCaseKey = trans.__(formattedKey);
                 const labelStr = formatLabels[key] ? formatLabels[key] : capCaseKey;
-                let args = {
+                return {
                     format: key,
-                    label: labelStr,
-                    isPalette: false
+                    label: labelStr
                 };
-                if (FORMAT_EXCLUDE.indexOf(key) === -1) {
-                    if (exportTo) {
-                        exportTo.addItem({
-                            command: CommandIDs.exportToFormat,
-                            args: args
-                        });
-                    }
-                    if (palette) {
-                        args = {
-                            format: key,
-                            label: labelStr,
-                            isPalette: true
-                        };
-                        const category = trans.__('Notebook Operations');
-                        palette.addItem({
-                            command: CommandIDs.exportToFormat,
-                            category,
-                            args
-                        });
-                    }
-                }
             });
+            updateExportMenu();
         };
         tracker.widgetAdded.connect(maybeInitializeFormats);
+        if (tracker.size > 0) {
+            void maybeInitializeFormats();
+        }
+        void app.restored.then(() => {
+            void maybeInitializeFormats();
+        });
+    }
+};
+/**
+ * A plugin providing the default notebook export guidance service.
+ */
+export const exportGuidanceDialogPlugin = {
+    id: '@jupyterlab/notebook-extension:export-guidance-dialog',
+    description: 'Provides the default notebook export guidance shown when no exporters are available.',
+    provides: INotebookExportGuidance,
+    autoStart: true,
+    requires: [ITranslator],
+    activate: (app, translator) => {
+        const trans = translator.load('jupyterlab');
+        const { commands } = app;
+        const openExportDocs = (url, docsLabel) => {
+            if (commands.hasCommand('help:open')) {
+                return commands.execute('help:open', {
+                    url,
+                    text: docsLabel,
+                    newBrowserTab: true
+                });
+            }
+            window.open(url, '_blank', 'noopener,noreferrer');
+            return undefined;
+        };
+        return {
+            showExportHelp: async () => {
+                const result = await showDialog({
+                    title: trans.__('Notebook exports are unavailable'),
+                    body: trans.__('No notebook export formats are currently available. To enable exports, install nbconvert in the server environment or use another exporter supported by your deployment.'),
+                    buttons: [
+                        Dialog.cancelButton({ label: trans.__('Close') }),
+                        Dialog.okButton({ label: trans.__('Open Documentation') })
+                    ]
+                });
+                if (result.button.accept) {
+                    void openExportDocs(NOTEBOOK_EXPORT_DOCS_URL, trans.__('Notebook Export Documentation'));
+                }
+            }
+        };
     }
 };
 /**
@@ -766,6 +867,9 @@ const updateRawMimetype = {
                 const mimetypeExists = ((_a = properties.oneOf) === null || _a === void 0 ? void 0 : _a.filter(value => value.const === key).length) > 0;
                 if (!mimetypeExists) {
                     const formattedKey = key[0].toLocaleUpperCase() + key.slice(1);
+                    // Fallback for export formats the server offers but `formatLabels`
+                    // does not know about, so there is no literal to extract.
+                    // eslint-disable-next-line jupyter/no-dynamic-translation
                     const altOption = trans.__(formattedKey);
                     const option = formatLabels[key] ? formatLabels[key] : altOption;
                     const mimeTypeValue = response[key].output_mimetype;
@@ -793,26 +897,32 @@ const customMetadataEditorFields = {
     optional: [ITranslator],
     activate: (app, tracker, editorServices, formRegistry, translator) => {
         const editorFactory = options => editorServices.factoryService.newInlineEditor(options);
-        // Register the custom fields.
+        // Register the custom fields. As with the active cell tool below, the
+        // field renderers are used by rjsf as React components, so they run on
+        // every rebuild of the metadata form. Each field is created once and
+        // reused: constructing one per render abandons an editor, its host node
+        // and its listeners on every keystroke that rebuilds the form.
+        const cellMetadataField = new CellMetadataField({
+            editorFactory,
+            tracker,
+            label: 'Cell metadata',
+            translator: translator
+        });
         const cellComponent = {
             fieldRenderer: (props) => {
-                return new CellMetadataField({
-                    editorFactory,
-                    tracker,
-                    label: 'Cell metadata',
-                    translator: translator
-                }).render(props);
+                return cellMetadataField.render(props);
             }
         };
         formRegistry.addRenderer('@jupyterlab/notebook-extension:metadata-editor.cell-metadata', cellComponent);
+        const notebookMetadataField = new NotebookMetadataField({
+            editorFactory,
+            tracker,
+            label: 'Notebook metadata',
+            translator: translator
+        });
         const notebookComponent = {
             fieldRenderer: (props) => {
-                return new NotebookMetadataField({
-                    editorFactory,
-                    tracker,
-                    label: 'Notebook metadata',
-                    translator: translator
-                }).render(props);
+                return notebookMetadataField.render(props);
             }
         };
         formRegistry.addRenderer('@jupyterlab/notebook-extension:metadata-editor.notebook-metadata', notebookComponent);
@@ -823,21 +933,38 @@ const customMetadataEditorFields = {
  */
 const activeCellTool = {
     id: '@jupyterlab/notebook-extension:active-cell-tool',
-    description: 'Adds active cell field in the metadata editor tab.',
+    description: 'Adds active cell fields in the metadata editor tab.',
     autoStart: true,
     requires: [INotebookTracker, IFormRendererRegistry, IEditorLanguageRegistry],
+    optional: [ITranslator],
     activate: (
     // Register the custom field.
-    app, tracker, formRegistry, languages) => {
+    app, tracker, formRegistry, languages, translator) => {
+        // The field renderer is used by rjsf as a React component, so it runs on
+        // every rebuild of the metadata form. The tool is created once and reused:
+        // constructing one per render would rebuild the prompt and the preview from
+        // scratch (showing them empty until the next update) and would leave a
+        // connection to the cell model behind for every abandoned instance.
+        const tool = new ActiveCellTool({
+            tracker,
+            languages
+        });
         const component = {
             fieldRenderer: (props) => {
-                return new ActiveCellTool({
-                    tracker,
-                    languages
-                }).render(props);
+                return tool.render(props);
             }
         };
         formRegistry.addRenderer('@jupyterlab/notebook-extension:active-cell-tool.renderer', component);
+        const cellIdComponent = {
+            fieldRenderer: (props) => {
+                return CellIdField({
+                    ...props,
+                    tracker,
+                    translator
+                });
+            }
+        };
+        formRegistry.addRenderer('@jupyterlab/notebook-extension:active-cell-tool.cell-id', cellIdComponent);
     }
 };
 /**
@@ -902,6 +1029,7 @@ const plugins = [
     trackerPlugin,
     pageHandlerPlugin,
     executionIndicator,
+    exportGuidanceDialogPlugin,
     exportPlugin,
     tools,
     cellCounterItem,
@@ -998,7 +1126,8 @@ function activatePageHandler(app, rendermime, settingRegistry, translator_) {
             }
             const mimeData = data;
             const metadata = ((_a = payload['metadata']) !== null && _a !== void 0 ? _a : {});
-            const mimeType = rendermime.preferredMimeType(mimeData, 'any');
+            const trusted = false;
+            const mimeType = rendermime.preferredMimeType(mimeData, 'ensure');
             if (!mimeType) {
                 return false;
             }
@@ -1014,7 +1143,7 @@ function activatePageHandler(app, rendermime, settingRegistry, translator_) {
             const content = helpWidget.content;
             content.widgets.forEach(widget => widget.dispose());
             const renderer = rendermime.createRenderer(mimeType);
-            void renderer.renderModel(new MimeModel({ data: mimeData, metadata, trusted: true }));
+            void renderer.renderModel(new MimeModel({ data: mimeData, metadata, trusted }));
             content.addWidget(renderer);
             if (!helpWidget.isAttached) {
                 app.shell.add(helpWidget, 'down');
@@ -1513,8 +1642,10 @@ function activateNotebookHandler(app, factory, extensions, executor, palette, de
                     value: settings.get('sideBySideOutputRatio').composite
                 })
                     .then(result => {
-                    setSideBySideOutputRatio(result.value);
-                    if (result.value) {
+                    if (result.value !== null &&
+                        Number.isFinite(result.value) &&
+                        result.value >= 0) {
+                        setSideBySideOutputRatio(result.value);
                         void settings.set('sideBySideOutputRatio', result.value);
                     }
                 })
@@ -1577,10 +1708,13 @@ function activateNotebookHandler(app, factory, extensions, executor, palette, de
         widget.title.iconClass = (_a = ft === null || ft === void 0 ? void 0 : ft.iconClass) !== null && _a !== void 0 ? _a : '';
         widget.title.iconLabel = (_b = ft === null || ft === void 0 ? void 0 : ft.iconLabel) !== null && _b !== void 0 ? _b : '';
         widget.content.scrollbar = (_c = factory.notebookConfig.showMinimap) !== null && _c !== void 0 ? _c : false;
-        // Notify the widget tracker if restore data needs to update.
+        // Notify the widget tracker if restore data needs to update. The context
+        // outlives this panel when other views of the document stay open, so the
+        // connection is made with the panel as receiver: `Widget.dispose()` calls
+        // `Signal.clearData(this)`, which removes it when the panel is closed.
         widget.context.pathChanged.connect(() => {
             void tracker.save(widget);
-        });
+        }, widget);
         // Add the notebook panel to the tracker.
         void tracker.add(widget);
     });
@@ -1643,13 +1777,17 @@ function activateNotebookHandler(app, factory, extensions, executor, palette, de
         setSideBySideOutputRatio(factory.notebookConfig.sideBySideOutputRatio);
         const sideBySideMarginStyle = `.jp-mod-sideBySide.jp-Notebook .jp-Notebook-cell {
       margin-left: ${factory.notebookConfig.sideBySideLeftMarginOverride} !important;
-      margin-right: ${factory.notebookConfig.sideBySideRightMarginOverride} !important;`;
+      margin-right: ${factory.notebookConfig.sideBySideRightMarginOverride} !important;
+    }`;
         const sideBySideMarginTag = document.getElementById(SIDE_BY_SIDE_STYLE_ID);
         if (sideBySideMarginTag) {
-            sideBySideMarginTag.innerText = sideBySideMarginStyle;
+            sideBySideMarginTag.textContent = sideBySideMarginStyle;
         }
         else {
-            document.head.insertAdjacentHTML('beforeend', `<style id="${SIDE_BY_SIDE_STYLE_ID}">${sideBySideMarginStyle}}</style>`);
+            const style = document.createElement('style');
+            style.id = SIDE_BY_SIDE_STYLE_ID;
+            style.textContent = sideBySideMarginStyle;
+            document.head.appendChild(style);
         }
         factory.autoStartDefault = settings.get('autoStartDefaultKernel')
             .composite;
@@ -1829,6 +1967,7 @@ function activateNotebookCompleterService(app, notebooks, manager, translator, a
         keys: ['Enter'],
         selector: '.jp-Notebook .jp-mod-completer-active'
     });
+    const completerConnected = new WeakSet();
     const updateCompleter = async (_, notebook) => {
         var _a, _b;
         const completerContext = {
@@ -1838,6 +1977,15 @@ function activateNotebookCompleterService(app, notebooks, manager, translator, a
             sanitizer: sanitizer
         };
         await manager.updateCompleter(completerContext);
+        // `updateCompleter` also runs for every panel on `activeProvidersChanged`
+        // below; connect the listeners only on the first call for a panel so
+        // they do not accumulate per settings change. The disposal check covers
+        // a panel closed while `updateCompleter` was pending: connections made
+        // then would outlive the disposal cleanup that has already run.
+        if (notebook.isDisposed || completerConnected.has(notebook)) {
+            return;
+        }
+        completerConnected.add(notebook);
         notebook.content.activeCellChanged.connect((_, cell) => {
             // Ensure the editor will exist on the cell before adding the completer
             cell === null || cell === void 0 ? void 0 : cell.ready.then(() => {
@@ -1850,6 +1998,10 @@ function activateNotebookCompleterService(app, notebooks, manager, translator, a
                 return manager.updateCompleter(newCompleterContext);
             }).catch(console.error);
         });
+        // The session context outlives this panel when other views of the
+        // document stay open, so the connection is made with the panel as
+        // receiver: `Widget.dispose()` calls `Signal.clearData(this)`, which
+        // removes it when the panel is closed.
         notebook.sessionContext.sessionChanged.connect(() => {
             var _a;
             // Ensure the editor will exist on the cell before adding the completer
@@ -1862,7 +2014,7 @@ function activateNotebookCompleterService(app, notebooks, manager, translator, a
                 };
                 return manager.updateCompleter(newCompleterContext);
             }).catch(console.error);
-        });
+        }, notebook);
     };
     notebooks.widgetAdded.connect(updateCompleter);
     manager.activeProvidersChanged.connect(() => {
@@ -1970,17 +2122,26 @@ function addCommands(app, tracker, translator, sessionDialogs, settings, isEnabl
             NotebookActions.paste(notebook, mode, { stripOutputs });
         }
     };
-    // Set up signal handler to keep the collapse state consistent
+    // Set up signal handler to keep the collapse state consistent. The
+    // connections are made once per panel: `currentChanged` fires repeatedly
+    // for the same panel, and reconnecting each time would pile up duplicate
+    // handlers for as long as the panel lives.
+    const collapseSynchronized = new WeakSet();
     tracker.currentChanged.connect((sender, panel) => {
         var _a, _b;
-        if (!((_b = (_a = panel === null || panel === void 0 ? void 0 : panel.content) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.cells)) {
+        if (!((_b = (_a = panel === null || panel === void 0 ? void 0 : panel.content) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.cells) || collapseSynchronized.has(panel)) {
             return;
         }
+        collapseSynchronized.add(panel);
+        // The cell list belongs to the model, which outlives this view when
+        // other views of the document stay open, so the connection is made
+        // with the notebook as receiver: `Widget.dispose()` calls
+        // `Signal.clearData(this)`, which removes it when the view is closed.
         panel.content.model.cells.changed.connect((list, args) => {
             // Might be overkill to refresh this every time, but
             // it helps to keep the collapse state consistent.
             refreshCellCollapsed(panel.content);
-        });
+        }, panel.content);
         panel.content.activeCellChanged.connect((notebook, cell) => {
             NotebookActions.expandParent(cell, notebook);
         });
@@ -2260,8 +2421,12 @@ function addCommands(app, tracker, translator, sessionDialogs, settings, isEnabl
     commands.addCommand(CommandIDs.trust, {
         label: () => trans.__('Trust Notebook'),
         execute: async (args) => {
-            const current = getCurrent(tracker, shell, args);
-            if (current) {
+            var _a;
+            const trustBoundaryId = args[CommandLinker.TRUST_BOUNDARY_ID_ARG];
+            const current = typeof trustBoundaryId === 'string'
+                ? ((_a = tracker.find(widget => widget.content.node.id === trustBoundaryId)) !== null && _a !== void 0 ? _a : null)
+                : getCurrent(tracker, shell, args);
+            if (current && !current.isDisposed) {
                 const { context, content } = current;
                 const trustResult = await NotebookActions.trust(content);
                 if (trustResult.trusted) {
@@ -2275,7 +2440,12 @@ function addCommands(app, tracker, translator, sessionDialogs, settings, isEnabl
         describedBy: {
             args: {
                 type: 'object',
-                properties: {}
+                properties: {
+                    [CommandLinker.TRUST_BOUNDARY_ID_ARG]: {
+                        type: 'string',
+                        description: trans.__('The notebook trust boundary ID')
+                    }
+                }
             }
         }
     });