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

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';
@@ -38,7 +38,7 @@ 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.
@@ -554,6 +554,9 @@ export const exportPlugin = {
                 .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;
                 return {
@@ -864,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;
@@ -891,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);
@@ -921,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);
     }
 };
 /**
@@ -1097,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;
             }
@@ -1113,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');
@@ -1612,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);
                     }
                 })
@@ -1676,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);
     });
@@ -1932,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 = {
@@ -1941,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(() => {
@@ -1953,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
@@ -1965,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(() => {
@@ -2073,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);
         });
@@ -2363,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) {
@@ -2378,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')
+                    }
+                }
             }
         }
     });