@jupyterlab/debugger 4.0.0-alpha.2 → 4.0.0-alpha.20

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;
+  }
+}