@jupyterlab/debugger 4.0.0-alpha.9 → 4.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyterlab/debugger",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.0",
   "description": "JupyterLab - Debugger Extension",
   "keywords": [
     "jupyter",
@@ -34,67 +34,59 @@
     "schema/*.json",
     "style/**/*.css",
     "style/**/*.svg",
-    "style/index.js"
+    "style/index.js",
+    "src/**/*.{ts,tsx}"
   ],
   "scripts": {
     "build": "tsc -b",
     "build:test": "tsc --build tsconfig.test.json",
     "clean": "rimraf lib && rimraf tsconfig.tsbuildinfo && rimraf tsconfig.test.tsbuildinfo && rimraf tests/build",
     "docs": "typedoc --options tdoptions.json --theme ../../typedoc-theme src",
-    "test": "jest",
-    "test:cov": "jest --collect-coverage",
+    "test": "jest -i",
+    "test:cov": "jest -i --collect-coverage",
     "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
     "test:debug:watch": "node --inspect-brk node_modules/.bin/jest --runInBand --watch",
     "watch": "tsc -b --watch"
   },
   "dependencies": {
-    "@jupyterlab/application": "^4.0.0-alpha.9",
-    "@jupyterlab/apputils": "^4.0.0-alpha.9",
-    "@jupyterlab/cells": "^4.0.0-alpha.9",
-    "@jupyterlab/codeeditor": "^4.0.0-alpha.9",
-    "@jupyterlab/codemirror": "^4.0.0-alpha.9",
-    "@jupyterlab/console": "^4.0.0-alpha.9",
-    "@jupyterlab/coreutils": "^6.0.0-alpha.9",
-    "@jupyterlab/docregistry": "^4.0.0-alpha.9",
-    "@jupyterlab/fileeditor": "^4.0.0-alpha.9",
-    "@jupyterlab/notebook": "^4.0.0-alpha.9",
-    "@jupyterlab/observables": "^5.0.0-alpha.9",
-    "@jupyterlab/rendermime": "^4.0.0-alpha.9",
-    "@jupyterlab/services": "^7.0.0-alpha.9",
-    "@jupyterlab/translation": "^4.0.0-alpha.9",
-    "@jupyterlab/ui-components": "^4.0.0-alpha.24",
-    "@lumino/algorithm": "^1.9.1",
-    "@lumino/commands": "^1.20.0",
-    "@lumino/coreutils": "^1.12.0",
-    "@lumino/datagrid": "^0.35.1",
-    "@lumino/disposable": "^1.10.1",
-    "@lumino/messaging": "^1.10.1",
-    "@lumino/polling": "^1.10.0",
-    "@lumino/signaling": "^1.10.1",
-    "@lumino/widgets": "^1.31.1",
+    "@codemirror/state": "^6.2.0",
+    "@codemirror/view": "^6.7.0",
+    "@jupyter/ydoc": "^0.3.4",
+    "@jupyterlab/application": "^4.0.0-beta.0",
+    "@jupyterlab/apputils": "^4.0.0-beta.0",
+    "@jupyterlab/cells": "^4.0.0-beta.0",
+    "@jupyterlab/codeeditor": "^4.0.0-beta.0",
+    "@jupyterlab/codemirror": "^4.0.0-beta.0",
+    "@jupyterlab/console": "^4.0.0-beta.0",
+    "@jupyterlab/coreutils": "^6.0.0-beta.0",
+    "@jupyterlab/docregistry": "^4.0.0-beta.0",
+    "@jupyterlab/fileeditor": "^4.0.0-beta.0",
+    "@jupyterlab/notebook": "^4.0.0-beta.0",
+    "@jupyterlab/observables": "^5.0.0-beta.0",
+    "@jupyterlab/rendermime": "^4.0.0-beta.0",
+    "@jupyterlab/services": "^7.0.0-beta.0",
+    "@jupyterlab/translation": "^4.0.0-beta.0",
+    "@jupyterlab/ui-components": "^4.0.0-beta.0",
+    "@lumino/algorithm": "^2.0.0",
+    "@lumino/commands": "^2.0.0",
+    "@lumino/coreutils": "^2.0.0",
+    "@lumino/datagrid": "^2.0.0",
+    "@lumino/disposable": "^2.0.0",
+    "@lumino/messaging": "^2.0.0",
+    "@lumino/polling": "^2.0.0",
+    "@lumino/signaling": "^2.0.0",
+    "@lumino/widgets": "^2.0.0",
     "@vscode/debugprotocol": "^1.51.0",
-    "codemirror": "~5.61.0",
-    "react": "^17.0.1"
+    "react": "^18.2.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.10.2",
-    "@babel/preset-env": "^7.10.2",
-    "@jupyterlab/testutils": "^4.0.0-alpha.9",
-    "@types/codemirror": "^0.0.109",
-    "@types/jest": "^26.0.10",
-    "@types/react-dom": "^17.0.0",
-    "@types/text-encoding": "^0.0.35",
+    "@jupyterlab/testing": "^4.0.0-beta.0",
+    "@types/jest": "^29.2.0",
     "canvas": "^2.9.1",
-    "jest": "^26.4.2",
-    "jest-junit": "^11.1.0",
-    "jest-raw-loader": "^1.0.1",
-    "jest-summary-reporter": "^0.0.2",
+    "jest": "^29.2.0",
     "rimraf": "~3.0.0",
-    "shell-quote": "^1.7.2",
-    "text-encoding": "^0.7.0",
-    "ts-jest": "^26.3.0",
-    "typedoc": "~0.22.10",
-    "typescript": "~4.6.3"
+    "typedoc": "~0.23.25",
+    "typescript": "~5.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/config.ts

@@ -0,0 +1,78 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { murmur2 } from './hash';
+
+import { IDebugger } from './tokens';
+
+/**
+ * A class that holds debugger configuration for all kernels.
+ */
+export class DebuggerConfig implements IDebugger.IConfig {
+  /**
+   * Returns an id based on the given code.
+   *
+   * @param code The source code.
+   * @param kernel The kernel name from current session.
+   */
+  getCodeId(code: string, kernel: string): string {
+    const fileParams = this._fileParams.get(kernel);
+
+    if (!fileParams) {
+      throw new Error(`Kernel (${kernel}) has no tmp file params.`);
+    }
+
+    const hash = this._hashMethods.get(kernel);
+
+    if (!hash) {
+      throw new Error(`Kernel (${kernel}) has no hashing params.`);
+    }
+
+    const { prefix, suffix } = fileParams;
+    return `${prefix}${hash(code)}${suffix}`;
+  }
+
+  /**
+   * Sets the hash parameters for a kernel.
+   *
+   * @param params - Hashing parameters for a kernel.
+   */
+  setHashParams(params: IDebugger.IConfig.HashParams): void {
+    const { kernel, method, seed } = params;
+    if (!kernel) {
+      throw new TypeError(`Kernel name is not defined.`);
+    }
+    switch (method) {
+      case 'Murmur2':
+        this._hashMethods.set(kernel, code => murmur2(code, seed).toString());
+        break;
+      default:
+        throw new Error(`Hash method (${method}) is not supported.`);
+    }
+  }
+
+  /**
+   * Sets the parameters used by the kernel to create temp files (e.g. cells).
+   *
+   * @param params - Temporary file prefix and suffix for a kernel.
+   */
+  setTmpFileParams(params: IDebugger.IConfig.FileParams): void {
+    const { kernel, prefix, suffix } = params;
+    if (!kernel) {
+      throw new TypeError(`Kernel name is not defined.`);
+    }
+    this._fileParams.set(kernel, { kernel, prefix, suffix });
+  }
+
+  /**
+   * Gets the parameters used for the temp files (e.e. cells) for a kernel.
+   *
+   * @param kernel - The kernel name from current session.
+   */
+  getTmpFileParams(kernel: string): IDebugger.IConfig.FileParams {
+    return this._fileParams.get(kernel)!;
+  }
+
+  private _fileParams = new Map<string, IDebugger.IConfig.FileParams>();
+  private _hashMethods = new Map<string, (code: string) => string>();
+}

package/src/debugger.ts

@@ -0,0 +1,154 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { codeIcon, runIcon, stopIcon } from '@jupyterlab/ui-components';
+
+import { DebuggerConfig } from './config';
+
+import { DebuggerEvaluateDialog } from './dialogs/evaluate';
+
+import { ReadOnlyEditorFactory as EditorFactory } from './factory';
+
+import { DebuggerHandler } from './handler';
+
+import { EditorHandler as DebuggerEditorHandler } from './handlers/editor';
+
+import {
+  closeAllIcon as closeAll,
+  pauseIcon as pause,
+  stepIntoIcon as stepInto,
+  stepOutIcon as stepOut,
+  stepOverIcon as stepOver,
+  variableIcon as variable,
+  viewBreakpointIcon as viewBreakpoint
+} from './icons';
+
+import { DebuggerModel } from './model';
+
+import { VariablesBodyGrid } from './panels/variables/grid';
+
+import { VariableMimeRenderer } from './panels/variables/mimerenderer';
+
+import { DebuggerService } from './service';
+
+import { DebuggerSession } from './session';
+
+import { DebuggerSidebar } from './sidebar';
+
+import { DebuggerSources } from './sources';
+
+/**
+ * A namespace for `Debugger` statics.
+ */
+export namespace Debugger {
+  /**
+   * Debugger configuration for all kernels.
+   */
+  export class Config extends DebuggerConfig {}
+
+  /**
+   * A handler for a CodeEditor.IEditor.
+   */
+  export class EditorHandler extends DebuggerEditorHandler {}
+
+  /**
+   * A handler for debugging a widget.
+   */
+  export class Handler extends DebuggerHandler {}
+
+  /**
+   * A model for a debugger.
+   */
+  export class Model extends DebuggerModel {}
+
+  /**
+   * A widget factory for read only editors.
+   */
+  export class ReadOnlyEditorFactory extends EditorFactory {}
+
+  /**
+   * The main IDebugger implementation.
+   */
+  export class Service extends DebuggerService {}
+
+  /**
+   * A concrete implementation of IDebugger.ISession.
+   */
+  export class Session extends DebuggerSession {}
+
+  /**
+   * The debugger sidebar UI.
+   */
+  export class Sidebar extends DebuggerSidebar {}
+
+  /**
+   * The source and editor manager for a debugger instance.
+   */
+  export class Sources extends DebuggerSources {}
+
+  /**
+   * A data grid that displays variables in a debugger session.
+   */
+  export class VariablesGrid extends VariablesBodyGrid {}
+
+  /**
+   * A widget to display data according to its mime type
+   */
+  export class VariableRenderer extends VariableMimeRenderer {}
+
+  /**
+   * The command IDs used by the debugger plugin.
+   */
+  export namespace CommandIDs {
+    export const debugContinue = 'debugger:continue';
+
+    export const terminate = 'debugger:terminate';
+
+    export const next = 'debugger:next';
+
+    export const showPanel = 'debugger:show-panel';
+
+    export const stepIn = 'debugger:stepIn';
+
+    export const stepOut = 'debugger:stepOut';
+
+    export const inspectVariable = 'debugger:inspect-variable';
+
+    export const renderMimeVariable = 'debugger:render-mime-variable';
+
+    export const evaluate = 'debugger:evaluate';
+
+    export const restartDebug = 'debugger:restart-debug';
+
+    export const pauseOnExceptions = 'debugger:pause-on-exceptions';
+
+    export const copyToClipboard = 'debugger:copy-to-clipboard';
+  }
+
+  /**
+   * The debugger user interface icons.
+   */
+  export namespace Icons {
+    export const closeAllIcon = closeAll;
+    export const evaluateIcon = codeIcon;
+    export const continueIcon = runIcon;
+    export const pauseIcon = pause;
+    export const stepIntoIcon = stepInto;
+    export const stepOutIcon = stepOut;
+    export const stepOverIcon = stepOver;
+    export const terminateIcon = stopIcon;
+    export const variableIcon = variable;
+    export const viewBreakpointIcon = viewBreakpoint;
+    export const pauseOnExceptionsIcon = pause;
+  }
+
+  /**
+   * The debugger dialog helpers.
+   */
+  export namespace Dialogs {
+    /**
+     * Open a code prompt in a dialog.
+     */
+    export const getCode = DebuggerEvaluateDialog.getCode;
+  }
+}

package/src/dialogs/evaluate.ts

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { Dialog } from '@jupyterlab/apputils';
+
+import { Cell, CodeCell, CodeCellModel } from '@jupyterlab/cells';
+
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+
+import { Message } from '@lumino/messaging';
+
+import { Widget } from '@lumino/widgets';
+
+/**
+ * A namespace for DebuggerEvaluateDialog statics.
+ */
+export namespace DebuggerEvaluateDialog {
+  /**
+   * Instantiation options for the evaluate dialog.
+   */
+  export interface IOptions {
+    /**
+     * The top level text for the dialog. Defaults to an empty string.
+     */
+    title: string;
+
+    /**
+     * Cell content factory.
+     */
+    contentFactory: Cell.IContentFactory;
+
+    /**
+     * The mime renderer for the cell widget.
+     */
+    rendermime: IRenderMimeRegistry;
+
+    /**
+     * The mime type for the cell widget content.
+     */
+    mimeType?: string;
+
+    /**
+     * Label for ok button.
+     */
+    okLabel?: string;
+
+    /**
+     * Label for cancel button.
+     */
+    cancelLabel?: string;
+  }
+
+  /**
+   * Create and show a dialog to prompt user for code.
+   *
+   * @param options - The dialog setup options.
+   *
+   * @returns A promise that resolves with whether the dialog was accepted
+   */
+  export function getCode(options: IOptions): Promise<Dialog.IResult<string>> {
+    const dialog = new EvaluateDialog({
+      ...options,
+      body: new EvaluateDialogBody(options),
+      buttons: [
+        Dialog.cancelButton({ label: options.cancelLabel }),
+        Dialog.okButton({ label: options.okLabel })
+      ]
+    });
+    return dialog.launch();
+  }
+}
+
+/**
+ * A dialog to prompt users for code to evaluate.
+ */
+class EvaluateDialog extends Dialog<string> {
+  /**
+   * Handle the DOM events for the Evaluate dialog.
+   *
+   * @param event The DOM event sent to the dialog widget
+   */
+  handleEvent(event: Event): void {
+    if (event.type === 'keydown') {
+      const keyboardEvent = event as KeyboardEvent;
+      const { code, shiftKey } = keyboardEvent;
+      if (shiftKey && code === 'Enter') {
+        return this.resolve();
+      }
+      if (code === 'Enter') {
+        return;
+      }
+    }
+    super.handleEvent(event);
+  }
+}
+
+/**
+ * Widget body with a code cell prompt in a dialog
+ */
+class EvaluateDialogBody extends Widget implements Dialog.IBodyWidget<string> {
+  /**
+   * CodePromptDialog constructor
+   *
+   * @param options Constructor options
+   */
+  constructor(options: DebuggerEvaluateDialog.IOptions) {
+    super();
+
+    const { contentFactory, rendermime, mimeType } = options;
+
+    const model = new CodeCellModel();
+    model.mimeType = mimeType ?? '';
+    this._prompt = new CodeCell({
+      contentFactory,
+      rendermime,
+      model,
+      placeholder: false
+    }).initializeState();
+
+    // explicitly remove the prompt in front of the input area
+    this._prompt.inputArea!.promptNode.remove();
+
+    this.node.appendChild(this._prompt.node);
+  }
+
+  /**
+   * Get the text specified by the user
+   */
+  getValue(): string {
+    return this._prompt.model.sharedModel.getSource();
+  }
+
+  /**
+   *  A message handler invoked on an `'after-attach'` message.
+   */
+  protected onAfterAttach(msg: Message): void {
+    super.onAfterAttach(msg);
+    this._prompt.activate();
+  }
+
+  private _prompt: CodeCell;
+}

package/src/factory.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import {
+  CodeEditor,
+  CodeEditorWrapper,
+  IEditorServices
+} from '@jupyterlab/codeeditor';
+import { IDebugger } from './tokens';
+
+/**
+ * A widget factory for read only editors.
+ */
+export class ReadOnlyEditorFactory {
+  /**
+   * Construct a new editor widget factory.
+   *
+   * @param options The instantiation options for a ReadOnlyEditorFactory.
+   */
+  constructor(options: ReadOnlyEditorFactory.IOptions) {
+    this._services = options.editorServices;
+  }
+
+  /**
+   * Create a new CodeEditorWrapper given a Source.
+   *
+   * @param source The source to create a new editor for.
+   */
+  createNewEditor(source: IDebugger.Source): CodeEditorWrapper {
+    const { content, mimeType, path } = source;
+    const factory = this._services.factoryService.newInlineEditor;
+    const mimeTypeService = this._services.mimeTypeService;
+    const model = new CodeEditor.Model({
+      mimeType: mimeType || mimeTypeService.getMimeTypeByFilePath(path)
+    });
+    model.sharedModel.source = content;
+    const editor = new CodeEditorWrapper({
+      editorOptions: {
+        config: {
+          readOnly: true,
+          lineNumbers: true
+        }
+      },
+      model,
+      factory
+    });
+    editor.node.setAttribute('data-jp-debugger', 'true');
+
+    editor.disposed.connect(() => {
+      model.dispose();
+    });
+
+    return editor;
+  }
+
+  private _services: IEditorServices;
+}
+
+/**
+ * The namespace for `ReadOnlyEditorFactory` class statics.
+ */
+export namespace ReadOnlyEditorFactory {
+  /**
+   * The options used to create a read only editor widget factory.
+   */
+  export interface IOptions {
+    /**
+     * The editor services used by the factory.
+     */
+    editorServices: IEditorServices;
+  }
+}