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

package/src/index.ts

@@ -16,6 +16,7 @@ import { ILabShell, ILayoutRestorer, IRouter } from '@jupyterlab/application';
 import type { ISessionContext } from '@jupyterlab/apputils';
 import {
   Clipboard,
+  CommandLinker,
   createToolbarFactory,
   Dialog,
   ICommandPalette,
@@ -145,7 +146,10 @@ 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
@@ -878,6 +882,9 @@ export const exportPlugin: JupyterFrontEndPlugin<void> = {
         .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 {
@@ -1279,6 +1286,9 @@ const updateRawMimetype: JupyterFrontEndPlugin<void> = {
           ).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;
@@ -1316,15 +1326,20 @@ const customMetadataEditorFields: JupyterFrontEndPlugin<void> = {
   ) => {
     const editorFactory: CodeEditor.Factory = 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: IFormRenderer = {
       fieldRenderer: (props: FieldProps) => {
-        return new CellMetadataField({
-          editorFactory,
-          tracker,
-          label: 'Cell metadata',
-          translator: translator
-        }).render(props);
+        return cellMetadataField.render(props);
       }
     };
     formRegistry.addRenderer(
@@ -1332,14 +1347,15 @@ const customMetadataEditorFields: JupyterFrontEndPlugin<void> = {
       cellComponent
     );
 
+    const notebookMetadataField = new NotebookMetadataField({
+      editorFactory,
+      tracker,
+      label: 'Notebook metadata',
+      translator: translator
+    });
     const notebookComponent: IFormRenderer = {
       fieldRenderer: (props: FieldProps) => {
-        return new NotebookMetadataField({
-          editorFactory,
-          tracker,
-          label: 'Notebook metadata',
-          translator: translator
-        }).render(props);
+        return notebookMetadataField.render(props);
       }
     };
     formRegistry.addRenderer(
@@ -1354,28 +1370,50 @@ const customMetadataEditorFields: JupyterFrontEndPlugin<void> = {
  */
 const activeCellTool: JupyterFrontEndPlugin<void> = {
   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: JupyterFrontEnd,
     tracker: INotebookTracker,
     formRegistry: IFormRendererRegistry,
-    languages: IEditorLanguageRegistry
+    languages: IEditorLanguageRegistry,
+    translator?: ITranslator
   ) => {
+    // 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: IFormRenderer = {
       fieldRenderer: (props: FieldProps) => {
-        return new ActiveCellTool({
-          tracker,
-          languages
-        }).render(props);
+        return tool.render(props);
       }
     };
     formRegistry.addRenderer(
       '@jupyterlab/notebook-extension:active-cell-tool.renderer',
       component
     );
+
+    const cellIdComponent: IFormRenderer = {
+      fieldRenderer: (props: FieldProps) => {
+        return CellIdField({
+          ...props,
+          tracker,
+          translator
+        });
+      }
+    };
+    formRegistry.addRenderer(
+      '@jupyterlab/notebook-extension:active-cell-tool.cell-id',
+      cellIdComponent
+    );
   }
 };
 
@@ -1577,7 +1615,8 @@ function activatePageHandler(
 
       const mimeData = data as nbformat.IMimeBundle;
       const metadata = (payload['metadata'] ?? {}) as ReadonlyJSONObject;
-      const mimeType = rendermime.preferredMimeType(mimeData, 'any');
+      const trusted = false;
+      const mimeType = rendermime.preferredMimeType(mimeData, 'ensure');
       if (!mimeType) {
         return false;
       }
@@ -1597,7 +1636,7 @@ function activatePageHandler(
 
       const renderer = rendermime.createRenderer(mimeType);
       void renderer.renderModel(
-        new MimeModel({ data: mimeData, metadata, trusted: true })
+        new MimeModel({ data: mimeData, metadata, trusted })
       );
       content.addWidget(renderer);
 
@@ -2273,8 +2312,12 @@ function activateNotebookHandler(
             value: settings.get('sideBySideOutputRatio').composite as number
           })
             .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);
               }
             })
@@ -2365,10 +2408,13 @@ function activateNotebookHandler(
     widget.title.iconLabel = ft?.iconLabel ?? '';
     widget.content.scrollbar = factory.notebookConfig.showMinimap ?? 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);
   });
@@ -2674,6 +2720,7 @@ function activateNotebookCompleterService(
     keys: ['Enter'],
     selector: '.jp-Notebook .jp-mod-completer-active'
   });
+  const completerConnected = new WeakSet<NotebookPanel>();
   const updateCompleter = async (
     _: INotebookTracker | undefined,
     notebook: NotebookPanel
@@ -2685,6 +2732,15 @@ function activateNotebookCompleterService(
       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?.ready
@@ -2699,6 +2755,10 @@ function activateNotebookCompleterService(
         })
         .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(() => {
       // Ensure the editor will exist on the cell before adding the completer
       notebook.content.activeCell?.ready
@@ -2711,7 +2771,7 @@ function activateNotebookCompleterService(
           return manager.updateCompleter(newCompleterContext);
         })
         .catch(console.error);
-    });
+    }, notebook);
   };
   notebooks.widgetAdded.connect(updateCompleter);
   manager.activeProvidersChanged.connect(() => {
@@ -2851,18 +2911,28 @@ function addCommands(
     }
   };
 
-  // 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<NotebookPanel>();
   tracker.currentChanged.connect(
     (sender: INotebookTracker, panel: NotebookPanel) => {
-      if (!panel?.content?.model?.cells) {
+      if (!panel?.content?.model?.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: any, args: IObservableList.IChangedArgs<ICellModel>) => {
           // 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: Notebook, cell: Cell) => {
@@ -3219,8 +3289,14 @@ function addCommands(
   commands.addCommand(CommandIDs.trust, {
     label: () => trans.__('Trust Notebook'),
     execute: async args => {
-      const current = getCurrent(tracker, shell, args);
-      if (current) {
+      const trustBoundaryId = args[CommandLinker.TRUST_BOUNDARY_ID_ARG];
+      const current =
+        typeof trustBoundaryId === 'string'
+          ? (tracker.find(
+              widget => widget.content.node.id === trustBoundaryId
+            ) ?? null)
+          : getCurrent(tracker, shell, args);
+      if (current && !current.isDisposed) {
         const { context, content } = current;
         const trustResult = await NotebookActions.trust(content);
         if (trustResult.trusted) {
@@ -3234,7 +3310,12 @@ function addCommands(
     describedBy: {
       args: {
         type: 'object',
-        properties: {}
+        properties: {
+          [CommandLinker.TRUST_BOUNDARY_ID_ARG]: {
+            type: 'string',
+            description: trans.__('The notebook trust boundary ID')
+          }
+        }
       }
     }
   });

package/src/nboutput.ts

@@ -65,12 +65,19 @@ function activateNBOutput(
     // There is overlap here since unhandled messages are also emitted in the
     // iopubMessage signal. However, unhandled messages warrant a higher log
     // severity, so we'll accept that they are logged twice.
+    //
+    // The session context outlives this panel when other views of the
+    // document stay open, so the connections are made with the panel as
+    // receiver: `Widget.dispose()` calls `Signal.clearData(this)`, which
+    // removes them when the panel is closed.
     nb.context.sessionContext.iopubMessage.connect(
-      (_, msg: KernelMessage.IIOPubMessage) => logOutput(msg, 'info', 'info')
+      (_, msg: KernelMessage.IIOPubMessage) => logOutput(msg, 'info', 'info'),
+      nb
     );
     nb.context.sessionContext.unhandledMessage.connect(
       (_, msg: KernelMessage.IIOPubMessage) =>
-        logOutput(msg, 'warning', 'error')
+        logOutput(msg, 'warning', 'error'),
+      nb
     );
   }
   nbtracker.forEach(nb => registerNB(nb));