@datalayer/jupyter-react 0.19.3 → 0.19.5

package/lib/components/notebook/NotebookCommands.js

@@ -3,6 +3,7 @@
  *
  * MIT License
  */
+import { DisposableSet } from '@lumino/disposable';
 import { SessionContextDialogs } from '@jupyterlab/apputils';
 import { NotebookActions, NotebookSearchProvider, } from '@jupyterlab/notebook';
 import { SearchDocumentModel, SearchDocumentView, } from '@jupyterlab/documentsearch';
@@ -11,7 +12,7 @@ import { nullTranslator } from '@jupyterlab/translation';
 /**
  * The map of command ids used by the notebook.
  */
-export const cmdIds = {
+export const NotebookCommandIds = {
     changeCellType: 'notebook-cell:change-cell-type',
     changeCellTypeToCode: 'notebook-cell:change-cell-to-code',
     changeCellTypeToMarkdown: 'notebook-cell:change-cell-to-markdown',
@@ -46,87 +47,105 @@ export const cmdIds = {
     switchKernel: 'notebook:switch-kernel',
     undo: 'notebook-cells:undo',
 };
-export const NotebookCommands = (commandRegistry, notebookPanel, completerHandler, tracker, path) => {
+/**
+ * Register notebook commands.
+ *
+ * @param commands Command registry
+ * @param completerHandler Completion handler
+ * @param tracker Notebook tracker
+ * @param path Notebook path
+ * @returns Commands disposer
+ */
+export function addNotebookCommands(commands, completerHandler, tracker, path) {
+    const allCommands = new DisposableSet();
+    // Add commands.
     if (path) {
-        commandRegistry.addCommand(cmdIds.save, {
+        allCommands.add(commands.addCommand(NotebookCommandIds.save, {
             label: 'Save',
-            execute: () => notebookPanel.context.save(),
-        });
-        commandRegistry.addKeyBinding({
+            execute: () => {
+                tracker.currentWidget?.context.save();
+            },
+        }));
+        allCommands.add(commands.addKeyBinding({
             selector: '.jp-Notebook',
             keys: ['Accel S'],
-            command: cmdIds.save,
-        });
+            command: NotebookCommandIds.save,
+        }));
     }
-    // Add commands.
-    commandRegistry.addCommand(cmdIds.invoke, {
+    allCommands.add(commands.addCommand(NotebookCommandIds.invoke, {
         label: 'Completer: Invoke',
         execute: () => completerHandler.invoke(),
-    });
-    commandRegistry.addCommand(cmdIds.select, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.select, {
         label: 'Completer: Select',
         execute: () => completerHandler.completer.selectActive(),
-    });
-    commandRegistry.addCommand(cmdIds.invokeNotebook, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.invokeNotebook, {
         label: 'Invoke Notebook',
         execute: () => {
-            if (notebookPanel.content.activeCell?.model.type === 'code') {
-                return commandRegistry.execute(cmdIds.invoke);
+            if (tracker.currentWidget?.content.activeCell?.model.type === 'code') {
+                return commands.execute(NotebookCommandIds.invoke);
             }
         },
-    });
-    commandRegistry.addCommand(cmdIds.selectNotebook, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.selectNotebook, {
         label: 'Select Notebook',
         execute: () => {
-            if (notebookPanel.content.activeCell?.model.type === 'code') {
-                return commandRegistry.execute(cmdIds.select);
+            if (tracker.currentWidget?.content.activeCell?.model.type === 'code') {
+                return commands.execute(NotebookCommandIds.select);
             }
         },
-    });
+    }));
     let searchInstance;
-    commandRegistry.addCommand(cmdIds.startSearch, {
+    allCommands.add(commands.addCommand(NotebookCommandIds.startSearch, {
         label: 'Find…',
         execute: () => {
-            if (!searchInstance) {
-                const provider = new NotebookSearchProvider(notebookPanel, nullTranslator);
+            if (!tracker.currentWidget) {
+                searchInstance = undefined;
+            }
+            else if (!searchInstance) {
+                const provider = new NotebookSearchProvider(tracker.currentWidget, nullTranslator);
                 const searchModel = new SearchDocumentModel(provider, 500);
                 searchInstance = new SearchDocumentView(searchModel);
                 /**
                  * Activate the target widget when the search panel is closing
                  */
                 searchInstance.closed.connect(() => {
-                    if (!notebookPanel.isDisposed) {
-                        notebookPanel.activate();
+                    if (!tracker.currentWidget?.isDisposed) {
+                        tracker.currentWidget?.activate();
                     }
                 });
                 searchInstance.disposed.connect(() => {
-                    if (!notebookPanel.isDisposed) {
-                        notebookPanel.activate();
+                    if (!tracker.currentWidget?.isDisposed) {
+                        tracker.currentWidget?.activate();
                     }
                     // find next and previous are now disabled
-                    commandRegistry.notifyCommandChanged();
+                    commands.notifyCommandChanged();
                 });
                 /**
                  * Dispose resources when the widget is disposed.
                  */
-                notebookPanel.disposed.connect(() => {
+                tracker.currentWidget?.disposed.connect(() => {
                     searchInstance?.dispose();
                     searchModel.dispose();
                     provider.dispose();
                 });
             }
-            if (!searchInstance.isAttached) {
-                Widget.attach(searchInstance, notebookPanel.node);
-                searchInstance.node.style.top = `${notebookPanel.toolbar.node.getBoundingClientRect().height +
-                    notebookPanel.contentHeader.node.getBoundingClientRect().height}px`;
+            if (searchInstance &&
+                tracker.currentWidget &&
+                !searchInstance.isAttached) {
+                Widget.attach(searchInstance, tracker.currentWidget?.node);
+                searchInstance.node.style.top = `${tracker.currentWidget?.toolbar.node.getBoundingClientRect().height +
+                    tracker.currentWidget?.contentHeader.node.getBoundingClientRect()
+                        .height}px`;
                 if (searchInstance.model.searchExpression) {
                     searchInstance.model.refresh();
                 }
             }
-            searchInstance.focusSearchInput();
+            searchInstance?.focusSearchInput();
         },
-    });
-    commandRegistry.addCommand(cmdIds.findNext, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.findNext, {
         label: 'Find Next',
         isEnabled: () => !!searchInstance,
         execute: async () => {
@@ -135,8 +154,8 @@ export const NotebookCommands = (commandRegistry, notebookPanel, completerHandle
             }
             await searchInstance.model.highlightNext();
         },
-    });
-    commandRegistry.addCommand(cmdIds.findPrevious, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.findPrevious, {
         label: 'Find Previous',
         isEnabled: () => !!searchInstance,
         execute: async () => {
@@ -145,153 +164,207 @@ export const NotebookCommands = (commandRegistry, notebookPanel, completerHandle
             }
             await searchInstance.model.highlightPrevious();
         },
-    });
-    commandRegistry.addCommand(cmdIds.interrupt, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.interrupt, {
         label: 'Interrupt',
-        execute: async () => notebookPanel.context.sessionContext.session?.kernel?.interrupt(),
-    });
+        execute: async () => tracker.currentWidget?.context.sessionContext.session?.kernel?.interrupt(),
+    }));
     const sessionContextDialogs = new SessionContextDialogs();
-    commandRegistry.addCommand(cmdIds.restart, {
+    allCommands.add(commands.addCommand(NotebookCommandIds.restart, {
         label: 'Restart Kernel',
-        execute: () => sessionContextDialogs.restart(notebookPanel.context.sessionContext),
-    });
-    commandRegistry.addCommand(cmdIds.switchKernel, {
+        execute: () => {
+            if (tracker.currentWidget) {
+                sessionContextDialogs.restart(tracker.currentWidget.context.sessionContext);
+            }
+        },
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.switchKernel, {
         label: 'Switch Kernel',
-        execute: () => sessionContextDialogs.selectKernel(notebookPanel.context.sessionContext),
-    });
-    commandRegistry.addCommand(cmdIds.runAndAdvance, {
+        execute: () => {
+            if (tracker.currentWidget) {
+                sessionContextDialogs.selectKernel(tracker.currentWidget.context.sessionContext);
+            }
+        },
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.runAndAdvance, {
         label: 'Run and Advance',
         execute: () => {
-            return NotebookActions.runAndAdvance(notebookPanel.content, notebookPanel.context.sessionContext);
+            return tracker.currentWidget
+                ? NotebookActions.runAndAdvance(tracker.currentWidget.content, tracker.currentWidget.context.sessionContext)
+                : undefined;
         },
-    });
-    commandRegistry.addCommand(cmdIds.run, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.run, {
         label: 'Run',
         execute: () => {
-            return NotebookActions.run(notebookPanel.content, notebookPanel.context.sessionContext);
+            return tracker.currentWidget
+                ? NotebookActions.run(tracker.currentWidget.content, tracker.currentWidget.context.sessionContext)
+                : undefined;
         },
-    });
-    commandRegistry.addCommand(cmdIds.runAll, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.runAll, {
         label: 'Run all',
         execute: () => {
-            return NotebookActions.runAll(notebookPanel.content, notebookPanel.context.sessionContext);
+            return tracker.currentWidget
+                ? NotebookActions.runAll(tracker.currentWidget.content, tracker.currentWidget.context.sessionContext)
+                : undefined;
         },
-    });
-    commandRegistry.addCommand(cmdIds.deleteCells, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.deleteCells, {
         label: 'Delete Cells',
         execute: () => {
-            return NotebookActions.deleteCells(notebookPanel.content);
+            return tracker.currentWidget
+                ? NotebookActions.deleteCells(tracker.currentWidget.content)
+                : undefined;
         },
-    });
-    commandRegistry.addCommand(cmdIds.insertAbove, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.insertAbove, {
         label: 'Insert Above',
-        execute: () => {
-            return NotebookActions.insertAbove(notebookPanel.content);
+        execute: args => {
+            const { cellType } = (args ?? {});
+            const notebook = tracker.currentWidget?.content;
+            if (notebook) {
+                NotebookActions.insertAbove(notebook);
+                if (cellType) {
+                    NotebookActions.changeCellType(notebook, cellType);
+                }
+            }
         },
-    });
-    commandRegistry.addCommand(cmdIds.insertBelow, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.insertBelow, {
         label: 'Insert Below',
-        execute: () => {
-            return NotebookActions.insertBelow(notebookPanel.content);
+        execute: args => {
+            const { cellType } = (args ?? {});
+            const notebook = tracker.currentWidget?.content;
+            if (notebook) {
+                NotebookActions.insertBelow(notebook);
+                if (cellType) {
+                    NotebookActions.changeCellType(notebook, cellType);
+                }
+            }
         },
-    });
-    commandRegistry.addCommand(cmdIds.editMode, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.editMode, {
         label: 'Edit Mode',
         execute: () => {
-            notebookPanel.content.mode = 'edit';
+            if (tracker.currentWidget) {
+                tracker.currentWidget.content.mode = 'edit';
+            }
         },
-    });
-    commandRegistry.addCommand(cmdIds.commandMode, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.commandMode, {
         label: 'Command Mode',
         execute: () => {
-            notebookPanel.content.mode = 'command';
+            if (tracker.currentWidget) {
+                tracker.currentWidget.content.mode = 'command';
+            }
         },
-    });
-    commandRegistry.addCommand(cmdIds.selectBelow, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.selectBelow, {
         label: 'Select Below',
-        execute: () => NotebookActions.selectBelow(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.selectAbove, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.selectBelow(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.selectAbove, {
         label: 'Select Above',
-        execute: () => NotebookActions.selectAbove(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.extendAbove, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.selectAbove(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.extendAbove, {
         label: 'Extend Above',
-        execute: () => NotebookActions.extendSelectionAbove(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.extendTop, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.extendSelectionAbove(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.extendTop, {
         label: 'Extend to Top',
-        execute: () => NotebookActions.extendSelectionAbove(notebookPanel.content, true),
-    });
-    commandRegistry.addCommand(cmdIds.extendBelow, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.extendSelectionAbove(tracker.currentWidget.content, true)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.extendBelow, {
         label: 'Extend Below',
-        execute: () => NotebookActions.extendSelectionBelow(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.extendBottom, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.extendSelectionBelow(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.extendBottom, {
         label: 'Extend to Bottom',
-        execute: () => NotebookActions.extendSelectionBelow(notebookPanel.content, true),
-    });
-    commandRegistry.addCommand(cmdIds.merge, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.extendSelectionBelow(tracker.currentWidget.content, true)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.merge, {
         label: 'Merge Cells',
-        execute: () => NotebookActions.mergeCells(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.split, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.mergeCells(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.split, {
         label: 'Split Cell',
-        execute: () => NotebookActions.splitCell(notebookPanel.content),
-    });
-    commandRegistry.addCommand(cmdIds.undo, {
+        execute: () => tracker.currentWidget
+            ? NotebookActions.splitCell(tracker.currentWidget.content)
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.undo, {
         label: 'Undo',
         execute: () => {
-            const activeCell = notebookPanel.content.activeCell;
+            const activeCell = tracker.currentWidget?.content.activeCell;
             if (activeCell) {
-                const sharedModel = activeCell.model
-                    .sharedModel;
+                const sharedModel = activeCell.model.sharedModel;
                 if (sharedModel.undoManager) {
                     sharedModel.undoManager.undo();
                 }
                 else {
                     // Fallback to default undo if Yjs undo manager is not available
-                    NotebookActions.undo(notebookPanel.content);
+                    NotebookActions.undo(tracker.currentWidget.content);
                 }
             }
         },
-    });
-    commandRegistry.addCommand(cmdIds.redo, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.redo, {
         label: 'Redo',
         execute: () => {
-            const activeCell = notebookPanel.content.activeCell;
+            const activeCell = tracker.currentWidget?.content.activeCell;
             if (activeCell) {
-                const sharedModel = activeCell.model
-                    .sharedModel;
+                const sharedModel = activeCell.model.sharedModel;
                 if (sharedModel.undoManager) {
                     sharedModel.undoManager.redo();
                 }
                 else {
                     // Fallback to default redo if Yjs undo manager is not available
-                    NotebookActions.redo(notebookPanel.content);
+                    NotebookActions.redo(tracker.currentWidget.content);
                 }
             }
         },
-    });
-    commandRegistry.addCommand(cmdIds.changeCellTypeToCode, {
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.changeCellTypeToCode, {
         label: 'Change Cell Type to Code',
-        execute: args => NotebookActions.changeCellType(notebookPanel.content, 'code'),
-    });
-    commandRegistry.addCommand(cmdIds.changeCellTypeToMarkdown, {
+        execute: args => tracker.currentWidget
+            ? NotebookActions.changeCellType(tracker.currentWidget.content, 'code')
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.changeCellTypeToMarkdown, {
         label: 'Change Cell Type to Markdown',
-        execute: args => NotebookActions.changeCellType(notebookPanel.content, 'markdown'),
-    });
-    commandRegistry.addCommand(cmdIds.changeCellTypeToRaw, {
+        execute: args => tracker.currentWidget
+            ? NotebookActions.changeCellType(tracker.currentWidget.content, 'markdown')
+            : undefined,
+    }));
+    allCommands.add(commands.addCommand(NotebookCommandIds.changeCellTypeToRaw, {
         label: 'Change Cell Type to Raw',
-        execute: args => NotebookActions.changeCellType(notebookPanel.content, 'raw'),
-    });
+        execute: args => tracker.currentWidget
+            ? NotebookActions.changeCellType(tracker.currentWidget.content, 'raw')
+            : undefined,
+    }));
     function getCurrent(args) {
         return tracker.currentWidget;
     }
     function isEnabled() {
         return tracker.currentWidget !== null;
     }
-    commandRegistry.addCommand('run-selected-codecell', {
+    allCommands.add(commands.addCommand('run-selected-codecell', {
         label: 'Run Cell',
         execute: args => {
             const current = getCurrent(args);
@@ -301,145 +374,146 @@ export const NotebookCommands = (commandRegistry, notebookPanel, completerHandle
             }
         },
         isEnabled,
-    });
+    }));
     const bindings = [
         {
             selector: '.jp-Notebook.jp-mod-editMode .jp-mod-completer-enabled',
             keys: ['Tab'],
-            command: cmdIds.invokeNotebook,
+            command: NotebookCommandIds.invokeNotebook,
         },
         {
             selector: '.jp-mod-completer-active',
             keys: ['Enter'],
-            command: cmdIds.selectNotebook,
+            command: NotebookCommandIds.selectNotebook,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Ctrl Enter'],
-            command: cmdIds.run,
+            command: NotebookCommandIds.run,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Shift Enter'],
-            command: cmdIds.runAndAdvance,
+            command: NotebookCommandIds.runAndAdvance,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Accel F'],
-            command: cmdIds.startSearch,
+            command: NotebookCommandIds.startSearch,
         },
         {
-            selector: '.jp-Notebook:focus',
+            selector: '.jp-Notebook.jp-mod-commandMode :focus',
             keys: ['D', 'D'],
-            command: cmdIds.deleteCells,
+            command: NotebookCommandIds.deleteCells,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Accel G'],
-            command: cmdIds.findNext,
+            command: NotebookCommandIds.findNext,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Accel Shift G'],
-            command: cmdIds.findPrevious,
+            command: NotebookCommandIds.findPrevious,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['I', 'I'],
-            command: cmdIds.interrupt,
+            command: NotebookCommandIds.interrupt,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['0', '0'],
-            command: cmdIds.restart,
+            command: NotebookCommandIds.restart,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['Enter'],
-            command: cmdIds.editMode,
+            command: NotebookCommandIds.editMode,
         },
         {
             selector: '.jp-Notebook.jp-mod-editMode',
             keys: ['Escape'],
-            command: cmdIds.commandMode,
+            command: NotebookCommandIds.commandMode,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['Shift M'],
-            command: cmdIds.merge,
+            command: NotebookCommandIds.merge,
         },
         {
             selector: '.jp-Notebook.jp-mod-editMode',
             keys: ['Ctrl Shift -'],
-            command: cmdIds.split,
+            command: NotebookCommandIds.split,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['J'],
-            command: cmdIds.selectBelow,
+            command: NotebookCommandIds.selectBelow,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['ArrowDown'],
-            command: cmdIds.selectBelow,
+            command: NotebookCommandIds.selectBelow,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['A'],
-            command: cmdIds.insertAbove,
+            command: NotebookCommandIds.insertAbove,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['B'],
-            command: cmdIds.insertBelow,
+            command: NotebookCommandIds.insertBelow,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['K'],
-            command: cmdIds.selectAbove,
+            command: NotebookCommandIds.selectAbove,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['ArrowUp'],
-            command: cmdIds.selectAbove,
+            command: NotebookCommandIds.selectAbove,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['Shift K'],
-            command: cmdIds.extendAbove,
+            command: NotebookCommandIds.extendAbove,
         },
         {
             selector: '.jp-Notebook.jp-mod-commandMode :focus:not(:read-write)',
             keys: ['Shift J'],
-            command: cmdIds.extendBelow,
+            command: NotebookCommandIds.extendBelow,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Ctrl Z'],
-            command: cmdIds.undo,
+            command: NotebookCommandIds.undo,
         },
         {
             selector: '.jp-Notebook',
             keys: ['Ctrl Y'],
-            command: cmdIds.redo,
+            command: NotebookCommandIds.redo,
         },
         {
-            selector: '.jp-Notebook:focus',
+            selector: '.jp-Notebook.jp-mod-commandMode :focus',
             keys: ['M'],
-            command: cmdIds.changeCellTypeToMarkdown,
+            command: NotebookCommandIds.changeCellTypeToMarkdown,
         },
         {
-            selector: '.jp-Notebook:focus',
+            selector: '.jp-Notebook.jp-mod-commandMode :focus',
             keys: ['R'],
-            command: cmdIds.changeCellTypeToRaw,
+            command: NotebookCommandIds.changeCellTypeToRaw,
         },
         {
-            selector: '.jp-Notebook:focus',
+            selector: '.jp-Notebook.jp-mod-commandMode :focus',
             keys: ['Y'],
-            command: cmdIds.changeCellTypeToCode,
+            command: NotebookCommandIds.changeCellTypeToCode,
         },
     ];
-    bindings.map(binding => commandRegistry.addKeyBinding(binding));
-};
-export default NotebookCommands;
+    bindings.forEach(binding => allCommands.add(commands.addKeyBinding(binding)));
+    return allCommands;
+}
+export default addNotebookCommands;
 //# sourceMappingURL=NotebookCommands.js.map