@jupyter-notebook/notebook-extension 7.0.0-alpha.1

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Export the plugins as default.
+ */
+declare const plugins: JupyterFrontEndPlugin<any>[];
+export default plugins;

package/lib/index.js

@@ -0,0 +1,294 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+import { DOMUtils } from '@jupyterlab/apputils';
+import { Text, Time } from '@jupyterlab/coreutils';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { IMainMenu } from '@jupyterlab/mainmenu';
+import { NotebookPanel, INotebookTracker } from '@jupyterlab/notebook';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator } from '@jupyterlab/translation';
+import { INotebookShell } from '@jupyter-notebook/application';
+import { Poll } from '@lumino/polling';
+import { Menu, Widget } from '@lumino/widgets';
+/**
+ * The class for kernel status errors.
+ */
+const KERNEL_STATUS_ERROR_CLASS = 'jp-NotebookKernelStatus-error';
+/**
+ * The class for kernel status warnings.
+ */
+const KERNEL_STATUS_WARN_CLASS = 'jp-NotebookKernelStatus-warn';
+/**
+ * The class for kernel status infos.
+ */
+const KERNEL_STATUS_INFO_CLASS = 'jp-NotebookKernelStatus-info';
+/**
+ * The class to fade out the kernel status.
+ */
+const KERNEL_STATUS_FADE_OUT_CLASS = 'jp-NotebookKernelStatus-fade';
+/**
+ * The class for scrolled outputs
+ */
+const SCROLLED_OUTPUTS_CLASS = 'jp-mod-outputsScrolled';
+/**
+ * A plugin for the checkpoint indicator
+ */
+const checkpoints = {
+    id: '@jupyter-notebook/notebook-extension:checkpoints',
+    autoStart: true,
+    requires: [IDocumentManager, ITranslator],
+    optional: [INotebookShell],
+    activate: (app, docManager, translator, notebookShell) => {
+        const { shell } = app;
+        const trans = translator.load('notebook');
+        const widget = new Widget();
+        widget.id = DOMUtils.createDomID();
+        widget.addClass('jp-NotebookCheckpoint');
+        app.shell.add(widget, 'top', { rank: 100 });
+        const onChange = async () => {
+            const current = shell.currentWidget;
+            if (!current) {
+                return;
+            }
+            const context = docManager.contextForWidget(current);
+            context === null || context === void 0 ? void 0 : context.fileChanged.disconnect(onChange);
+            context === null || context === void 0 ? void 0 : context.fileChanged.connect(onChange);
+            const checkpoints = await (context === null || context === void 0 ? void 0 : context.listCheckpoints());
+            if (!checkpoints) {
+                return;
+            }
+            const checkpoint = checkpoints[checkpoints.length - 1];
+            widget.node.textContent = trans.__('Last Checkpoint: %1', Time.formatHuman(new Date(checkpoint.last_modified)));
+        };
+        if (notebookShell) {
+            notebookShell.currentChanged.connect(onChange);
+        }
+        new Poll({
+            auto: true,
+            factory: () => onChange(),
+            frequency: {
+                interval: 2000,
+                backoff: false
+            },
+            standby: 'when-hidden'
+        });
+    }
+};
+/**
+ * The kernel logo plugin.
+ */
+const kernelLogo = {
+    id: '@jupyter-notebook/notebook-extension:kernel-logo',
+    autoStart: true,
+    requires: [INotebookShell],
+    activate: (app, shell) => {
+        const { serviceManager } = app;
+        let widget;
+        const onChange = async () => {
+            var _a, _b, _c, _d, _e;
+            if (widget) {
+                widget.dispose();
+                widget.parent = null;
+            }
+            const current = shell.currentWidget;
+            if (!(current instanceof NotebookPanel)) {
+                return;
+            }
+            await current.sessionContext.ready;
+            current.sessionContext.kernelChanged.disconnect(onChange);
+            current.sessionContext.kernelChanged.connect(onChange);
+            const name = (_c = (_b = (_a = current.sessionContext.session) === null || _a === void 0 ? void 0 : _a.kernel) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '';
+            const spec = (_e = (_d = serviceManager.kernelspecs) === null || _d === void 0 ? void 0 : _d.specs) === null || _e === void 0 ? void 0 : _e.kernelspecs[name];
+            if (!spec) {
+                return;
+            }
+            const kernelIconUrl = spec.resources['logo-64x64'];
+            if (!kernelIconUrl) {
+                return;
+            }
+            const node = document.createElement('div');
+            const img = document.createElement('img');
+            img.src = kernelIconUrl;
+            img.title = spec.display_name;
+            node.appendChild(img);
+            widget = new Widget({ node });
+            widget.addClass('jp-NotebookKernelLogo');
+            app.shell.add(widget, 'top', { rank: 10010 });
+        };
+        app.started.then(() => {
+            shell.currentChanged.connect(onChange);
+        });
+    }
+};
+/**
+ * A plugin to display the kernel status;
+ */
+const kernelStatus = {
+    id: '@jupyter-notebook/notebook-extension:kernel-status',
+    autoStart: true,
+    requires: [INotebookShell, ITranslator],
+    activate: (app, shell, translator) => {
+        const trans = translator.load('notebook');
+        const widget = new Widget();
+        widget.addClass('jp-NotebookKernelStatus');
+        app.shell.add(widget, 'menu', { rank: 10010 });
+        const removeClasses = () => {
+            widget.removeClass(KERNEL_STATUS_ERROR_CLASS);
+            widget.removeClass(KERNEL_STATUS_WARN_CLASS);
+            widget.removeClass(KERNEL_STATUS_INFO_CLASS);
+            widget.removeClass(KERNEL_STATUS_FADE_OUT_CLASS);
+        };
+        const onStatusChanged = (sessionContext) => {
+            const status = sessionContext.kernelDisplayStatus;
+            let text = `Kernel ${Text.titleCase(status)}`;
+            removeClasses();
+            switch (status) {
+                case 'busy':
+                case 'idle':
+                    text = '';
+                    widget.addClass(KERNEL_STATUS_FADE_OUT_CLASS);
+                    break;
+                case 'dead':
+                case 'terminating':
+                    widget.addClass(KERNEL_STATUS_ERROR_CLASS);
+                    break;
+                case 'unknown':
+                    widget.addClass(KERNEL_STATUS_WARN_CLASS);
+                    break;
+                default:
+                    widget.addClass(KERNEL_STATUS_INFO_CLASS);
+                    widget.addClass(KERNEL_STATUS_FADE_OUT_CLASS);
+                    break;
+            }
+            widget.node.textContent = trans.__(text);
+        };
+        const onChange = async () => {
+            const current = shell.currentWidget;
+            if (!(current instanceof NotebookPanel)) {
+                return;
+            }
+            const sessionContext = current.sessionContext;
+            sessionContext.statusChanged.connect(onStatusChanged);
+        };
+        shell.currentChanged.connect(onChange);
+    }
+};
+/**
+ * A plugin to customize notebook related menu entries
+ * TODO: switch to settings define menus when fixed upstream: https://github.com/jupyterlab/jupyterlab/issues/11754
+ */
+const menuPlugin = {
+    id: '@jupyter-notebook/notebook-extension:menu-plugin',
+    autoStart: true,
+    requires: [IMainMenu, ITranslator],
+    activate: (app, mainMenu, translator) => {
+        const { commands } = app;
+        const trans = translator.load('notebook');
+        const cellTypeSubmenu = new Menu({ commands });
+        cellTypeSubmenu.title.label = trans._p('menu', 'Cell Type');
+        [
+            'notebook:change-cell-to-code',
+            'notebook:change-cell-to-markdown',
+            'notebook:change-cell-to-raw'
+        ].forEach(command => {
+            cellTypeSubmenu.addItem({
+                command
+            });
+        });
+        mainMenu.runMenu.addItem({ type: 'separator', rank: 1000 });
+        mainMenu.runMenu.addItem({
+            type: 'submenu',
+            submenu: cellTypeSubmenu,
+            rank: 1010
+        });
+    }
+};
+/**
+ * A plugin to enable scrolling for outputs by default.
+ * Mimic the logic from the classic notebook, as found here:
+ * https://github.com/jupyter/notebook/blob/a9a31c096eeffe1bff4e9164c6a0442e0e13cdb3/notebook/static/notebook/js/outputarea.js#L96-L120
+ */
+const scrollOutput = {
+    id: '@jupyter-notebook/notebook-extension:scroll-output',
+    autoStart: true,
+    requires: [INotebookTracker],
+    optional: [ISettingRegistry],
+    activate: async (app, tracker, settingRegistry) => {
+        const autoScrollThreshold = 100;
+        let autoScrollOutputs = true;
+        // decide whether to scroll the output of the cell based on some heuristics
+        const autoScroll = (cell) => {
+            if (!autoScrollOutputs) {
+                // bail if disabled via the settings
+                return;
+            }
+            const { outputArea } = cell;
+            // respect cells with an explicit scrolled state
+            const scrolled = cell.model.metadata.get('scrolled');
+            if (scrolled !== undefined) {
+                return;
+            }
+            const { node } = outputArea;
+            const height = node.scrollHeight;
+            const fontSize = parseFloat(node.style.fontSize.replace('px', ''));
+            const lineHeight = (fontSize || 14) * 1.3;
+            // do not set via cell.outputScrolled = true, as this would
+            // otherwise synchronize the scrolled state to the notebook metadata
+            const scroll = height > lineHeight * autoScrollThreshold;
+            cell.toggleClass(SCROLLED_OUTPUTS_CLASS, scroll);
+        };
+        tracker.widgetAdded.connect((sender, notebook) => {
+            var _a;
+            (_a = notebook.model) === null || _a === void 0 ? void 0 : _a.cells.changed.connect((sender, changed) => {
+                // process new cells only
+                if (!(changed.type === 'add')) {
+                    return;
+                }
+                const [cellModel] = changed.newValues;
+                notebook.content.widgets.forEach(cell => {
+                    if (cell.model.id === cellModel.id && cell.model.type === 'code') {
+                        const codeCell = cell;
+                        codeCell.outputArea.model.changed.connect(() => autoScroll(codeCell));
+                    }
+                });
+            });
+            // when the notebook widget is created, process all the cells
+            // TODO: investigate why notebook.content.fullyRendered is not enough
+            notebook.sessionContext.ready.then(() => {
+                notebook.content.widgets.forEach(cell => {
+                    if (cell.model.type === 'code') {
+                        autoScroll(cell);
+                    }
+                });
+            });
+        });
+        if (settingRegistry) {
+            const loadSettings = settingRegistry.load(scrollOutput.id);
+            const updateSettings = (settings) => {
+                autoScrollOutputs = settings.get('autoScrollOutputs')
+                    .composite;
+            };
+            Promise.all([loadSettings, app.restored])
+                .then(([settings]) => {
+                updateSettings(settings);
+                settings.changed.connect(settings => {
+                    updateSettings(settings);
+                });
+            })
+                .catch((reason) => {
+                console.error(reason.message);
+            });
+        }
+    }
+};
+/**
+ * Export the plugins as default.
+ */
+const plugins = [
+    checkpoints,
+    kernelLogo,
+    kernelStatus,
+    menuPlugin,
+    scrollOutput
+];
+export default plugins;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@jupyter-notebook/notebook-extension",
+  "version": "7.0.0-alpha.1",
+  "description": "Jupyter Notebook - Notebook Extension",
+  "homepage": "https://github.com/jupyter/notebook",
+  "bugs": {
+    "url": "https://github.com/jupyter/notebook/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jupyter/notebook.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "Project Jupyter",
+  "sideEffects": [
+    "style/**/*.css",
+    "style/index.js"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "style/index.css",
+  "directories": {
+    "lib": "lib/"
+  },
+  "files": [
+    "lib/*.d.ts",
+    "lib/*.js.map",
+    "lib/*.js",
+    "schema/*.json",
+    "style/**/*.css",
+    "style/index.js"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "build:prod": "tsc -b",
+    "clean": "rimraf lib && rimraf tsconfig.tsbuildinfo",
+    "docs": "typedoc src",
+    "prepublishOnly": "npm run build",
+    "watch": "tsc -b --watch"
+  },
+  "dependencies": {
+    "@jupyter-notebook/application": "^7.0.0-alpha.1",
+    "@jupyterlab/application": "^4.0.0-alpha.5",
+    "@jupyterlab/apputils": "^4.0.0-alpha.5",
+    "@jupyterlab/cells": "^4.0.0-alpha.5",
+    "@jupyterlab/docmanager": "^4.0.0-alpha.5",
+    "@jupyterlab/notebook": "^4.0.0-alpha.5",
+    "@jupyterlab/settingregistry": "^4.0.0-alpha.5",
+    "@jupyterlab/translation": "^4.0.0-alpha.4",
+    "@lumino/polling": "^1.10.0",
+    "@lumino/widgets": "^1.31.1"
+  },
+  "devDependencies": {
+    "rimraf": "~3.0.0",
+    "typescript": "~4.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "extension": true,
+    "schemaDir": "schema"
+  },
+  "styleModule": "style/index.js"
+}

package/schema/scroll-output.json

@@ -0,0 +1,16 @@
+{
+  "jupyter.lab.setting-icon": "notebook-ui-components:jupyter",
+  "jupyter.lab.setting-icon-label": "Jupyter Notebook Notebook",
+  "title": "Jupyter Notebook Notebook",
+  "description": "Jupyter Notebook Notebook settings",
+  "properties": {
+    "autoScrollOutputs": {
+      "type": "boolean",
+      "title": "Auto Scroll Outputs",
+      "description": "Whether to auto scroll the output area when the outputs become too long",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "type": "object"
+}

package/style/base.css

@@ -0,0 +1,138 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+|
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+@import './variables.css';
+
+/* Document oriented look for the notebook (scrollbar to the right of the page) */
+
+body[data-notebook='notebooks'] .jp-NotebookPanel-toolbar {
+  padding-left: calc(calc(100% - var(--jp-notebook-max-width)) * 0.5);
+  padding-right: calc(calc(100% - var(--jp-notebook-max-width)) * 0.5);
+}
+
+body[data-notebook='notebooks'] .jp-Notebook > * {
+  background: var(--jp-layout-color0);
+  padding: var(--jp-notebook-padding);
+}
+
+body[data-notebook='notebooks']
+  .jp-Notebook.jp-mod-commandMode
+  .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) {
+  background: var(--jp-layout-color0) !important;
+}
+
+body[data-notebook='notebooks'] .jp-Notebook > *:first-child {
+  padding-top: var(--jp-notebook-padding-offset);
+  margin-top: var(--jp-notebook-toolbar-margin-bottom);
+}
+
+body[data-notebook='notebooks'] .jp-Notebook {
+  padding-top: unset;
+  padding-bottom: unset;
+  padding-left: calc(calc(100% - var(--jp-notebook-max-width)) * 0.5);
+  padding-right: calc(
+    calc(
+        100% - var(--jp-notebook-max-width) - var(--jp-notebook-padding-offset)
+      ) * 0.5
+  );
+  background: var(--jp-layout-color2);
+}
+
+body[data-notebook='notebooks'] .jp-Notebook.jp-mod-scrollPastEnd::after {
+  background: var(--jp-layout-color0);
+}
+
+/* ---- */
+
+.jp-NotebookKernelLogo {
+  flex: 0 0 auto;
+  display: flex;
+  align-items: center;
+  text-align: center;
+  margin-right: 8px;
+}
+
+.jp-NotebookKernelLogo img {
+  max-width: 28px;
+  max-height: 28px;
+  display: flex;
+}
+
+.jp-NotebookKernelStatus {
+  margin: 0;
+  font-weight: normal;
+  font-size: var(--jp-ui-font-size1);
+  color: var(--jp-ui-font-color0);
+  font-family: var(--jp-ui-font-family);
+  line-height: var(--jp-private-title-panel-height);
+  padding-left: var(--jp-kernel-status-padding);
+  padding-right: var(--jp-kernel-status-padding);
+}
+
+.jp-NotebookKernelStatus-error {
+  background-color: var(--jp-error-color0);
+}
+
+.jp-NotebookKernelStatus-warn {
+  background-color: var(--jp-warn-color0);
+}
+
+.jp-NotebookKernelStatus-info {
+  background-color: var(--jp-info-color0);
+}
+
+.jp-NotebookKernelStatus-fade {
+  animation: 0.5s fade-out forwards;
+}
+
+@keyframes fade-out {
+  0% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+
+#jp-title h1 {
+  cursor: pointer;
+  font-size: 18px;
+  margin: 0;
+  font-weight: normal;
+  color: var(--jp-ui-font-color0);
+  font-family: var(--jp-ui-font-family);
+  line-height: calc(1.5 * var(--jp-private-title-panel-height));
+  text-overflow: ellipsis;
+  overflow: hidden;
+  white-space: nowrap;
+}
+
+#jp-title h1:hover {
+  background: var(--jp-layout-color2);
+}
+
+.jp-NotebookCheckpoint {
+  font-size: 14px;
+  margin-left: 5px;
+  margin-right: 5px;
+  font-weight: normal;
+  color: var(--jp-ui-font-color0);
+  font-family: var(--jp-ui-font-family);
+  line-height: calc(1.5 * var(--jp-private-title-panel-height));
+  text-overflow: ellipsis;
+  overflow: hidden;
+  white-space: nowrap;
+}
+
+/* Mobile View */
+
+body[data-format='mobile'] .jp-NotebookCheckpoint {
+  display: none;
+}
+
+body[data-format='mobile'] .jp-Notebook > *:first-child {
+  margin-top: 0;
+}

package/style/index.css

@@ -0,0 +1 @@
+@import url('./base.css');

package/style/index.js

@@ -0,0 +1 @@
+import './base.css';

package/style/variables.css

@@ -0,0 +1,6 @@
+:root {
+  --jp-notebook-toolbar-margin-bottom: 20px;
+  --jp-notebook-padding-offset: 20px;
+
+  --jp-kernel-status-padding: 5px;
+}