@jupyter/chat 0.4.0 → 0.5.0

package/src/selection-watcher.ts

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { DocumentWidget } from '@jupyterlab/docregistry';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { Notebook } from '@jupyterlab/notebook';
+
+import { find } from '@lumino/algorithm';
+import { Widget } from '@lumino/widgets';
+import { ISignal, Signal } from '@lumino/signaling';
+
+import { getCellIndex, getEditor } from './utils';
+
+/**
+ * The selection watcher namespace.
+ */
+export namespace SelectionWatcher {
+  /**
+   * The constructor options.
+   */
+  export interface IOptions {
+    /**
+     * The current shell of the application.
+     */
+    shell: JupyterFrontEnd.IShell;
+  }
+
+  /**
+   * The selection type.
+   */
+  export type Selection = CodeEditor.ITextSelection & {
+    /**
+     * The text within the selection as a string.
+     */
+    text: string;
+    /**
+     * Number of lines contained by the text selection.
+     */
+    numLines: number;
+    /**
+     * The ID of the document widget in which the selection was made.
+     */
+    widgetId: string;
+    /**
+     * The ID of the cell in which the selection was made, if the original widget
+     * was a notebook.
+     */
+    cellId?: string;
+  };
+}
+
+/**
+ * The selection watcher interface.
+ */
+export interface ISelectionWatcher {
+  readonly selection: SelectionWatcher.Selection | null;
+  readonly selectionChanged: ISignal<
+    ISelectionWatcher,
+    SelectionWatcher.Selection | null
+  >;
+  replaceSelection(selection: SelectionWatcher.Selection): void;
+}
+
+/**
+ * The selection watcher, read/write selected text in a DocumentWidget.
+ */
+export class SelectionWatcher {
+  constructor(options: SelectionWatcher.IOptions) {
+    this._shell = options.shell;
+    this._shell.currentChanged?.connect((sender, args) => {
+      // Do not change the main area widget if the new one has no editor, for example
+      // a chat panel. However, the selected text is only available if the main area
+      // widget is visible. (to avoid confusion in inclusion/replacement).
+      const widget = args.newValue;
+
+      // if there is no main area widget, set it to null.
+      if (widget === null) {
+        this._mainAreaDocumentWidget = null;
+        return;
+      }
+
+      const editor = getEditor(widget);
+      if (
+        widget instanceof DocumentWidget &&
+        (editor || widget.content instanceof Notebook)
+      ) {
+        // if the new widget is a DocumentWidget and has an editor, set it.
+        // NOTE: special case for notebook which do not has an active cell at that stage,
+        // and so the editor can't be retrieved too.
+        this._mainAreaDocumentWidget = widget;
+      } else if (this._mainAreaDocumentWidget?.isDisposed) {
+        // if the previous document widget has been closed, set it to null.
+        this._mainAreaDocumentWidget = null;
+      }
+    });
+
+    setInterval(this._poll.bind(this), 200);
+  }
+
+  get selection(): SelectionWatcher.Selection | null {
+    return this._selection;
+  }
+
+  get selectionChanged(): ISignal<this, SelectionWatcher.Selection | null> {
+    return this._selectionChanged;
+  }
+
+  replaceSelection(selection: SelectionWatcher.Selection): void {
+    // unfortunately shell.currentWidget doesn't update synchronously after
+    // shell.activateById(), which is why we have to get a reference to the
+    // widget manually.
+    const widget = find(
+      this._shell.widgets(),
+      widget => widget.id === selection.widgetId
+    );
+    // Do not allow replacement on non visible widget (to avoid confusion).
+    if (!widget?.isVisible || !(widget instanceof DocumentWidget)) {
+      return;
+    }
+
+    // activate the widget if not already active
+    this._shell.activateById(selection.widgetId);
+
+    // activate notebook cell if specified
+    if (widget.content instanceof Notebook && selection.cellId) {
+      const cellIndex = getCellIndex(widget.content, selection.cellId);
+      if (cellIndex !== -1) {
+        widget.content.activeCellIndex = cellIndex;
+      }
+    }
+
+    // get editor instance
+    const editor = getEditor(widget);
+    if (!editor) {
+      return;
+    }
+
+    editor.model.sharedModel.updateSource(
+      editor.getOffsetAt(selection.start),
+      editor.getOffsetAt(selection.end),
+      selection.text
+    );
+    const newPosition = editor.getPositionAt(
+      editor.getOffsetAt(selection.start) + selection.text.length
+    );
+    editor.setSelection({ start: newPosition, end: newPosition });
+  }
+
+  protected _poll(): void {
+    let currSelection: SelectionWatcher.Selection | null = null;
+    const prevSelection = this._selection;
+    // Do not return selected text if the main area widget is hidden.
+    if (this._mainAreaDocumentWidget?.isVisible) {
+      currSelection = getTextSelection(this._mainAreaDocumentWidget);
+    }
+    if (prevSelection?.text !== currSelection?.text) {
+      this._selection = currSelection;
+      this._selectionChanged.emit(currSelection);
+    }
+  }
+
+  protected _shell: JupyterFrontEnd.IShell;
+  protected _mainAreaDocumentWidget: Widget | null = null;
+  protected _selection: SelectionWatcher.Selection | null = null;
+  protected _selectionChanged = new Signal<
+    this,
+    SelectionWatcher.Selection | null
+  >(this);
+}
+
+/**
+ * Gets a Selection object from a document widget. Returns `null` if unable.
+ */
+function getTextSelection(
+  widget: Widget | null
+): SelectionWatcher.Selection | null {
+  const editor = getEditor(widget);
+  // widget type check is redundant but hints the type to TypeScript
+  if (!editor || !(widget instanceof DocumentWidget)) {
+    return null;
+  }
+
+  let cellId: string | undefined = undefined;
+  if (widget.content instanceof Notebook) {
+    cellId = widget.content.activeCell?.model.id;
+  }
+
+  const selectionObj = editor.getSelection();
+  let { start, end } = selectionObj;
+  const startOffset = editor.getOffsetAt(start);
+  const endOffset = editor.getOffsetAt(end);
+  const text = editor.model.sharedModel
+    .getSource()
+    .substring(startOffset, endOffset);
+
+  // Do not return a Selection object if no text is selected
+  if (!text) {
+    return null;
+  }
+
+  // ensure start <= end
+  // required for editor.model.sharedModel.updateSource()
+  if (startOffset > endOffset) {
+    [start, end] = [end, start];
+  }
+
+  return {
+    ...selectionObj,
+    start,
+    end,
+    text,
+    numLines: text.split('\n').length,
+    widgetId: widget.id,
+    ...(cellId && {
+      cellId
+    })
+  };
+}

package/src/types.ts

@@ -39,6 +39,10 @@ export interface IConfig {
    * Whether to enable or not the code toolbar.
    */
   enableCodeToolbar?: boolean;
+  /**
+   * Whether to send typing notification.
+   */
+  sendTypingNotification?: boolean;
 }
 
 /**
@@ -83,6 +87,27 @@ export type AutocompleteCommand = {
   label: string;
 };
 
+/**
+ * Representation of a selected text.
+ */
+export type TextSelection = {
+  type: 'text';
+  source: string;
+};
+
+/**
+ * Representation of a selected cell.
+ */
+export type CellSelection = {
+  type: 'cell';
+  source: string;
+};
+
+/**
+ * Selection object (text or cell).
+ */
+export type Selection = TextSelection | CellSelection;
+
 /**
  * The properties of the autocompletion.
  *

package/src/utils.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { CodeMirrorEditor } from '@jupyterlab/codemirror';
+import { DocumentWidget } from '@jupyterlab/docregistry';
+import { FileEditor } from '@jupyterlab/fileeditor';
+import { Notebook } from '@jupyterlab/notebook';
+import { Widget } from '@lumino/widgets';
+
+/**
+ * Gets the editor instance used by a document widget. Returns `null` if unable.
+ */
+export function getEditor(
+  widget: Widget | null
+): CodeMirrorEditor | null | undefined {
+  if (!(widget instanceof DocumentWidget)) {
+    return null;
+  }
+
+  let editor: CodeEditor.IEditor | null | undefined;
+  const { content } = widget;
+
+  if (content instanceof FileEditor) {
+    editor = content.editor;
+  } else if (content instanceof Notebook) {
+    editor = content.activeCell?.editor;
+  }
+
+  if (!(editor instanceof CodeMirrorEditor)) {
+    return undefined;
+  }
+
+  return editor;
+}
+
+/**
+ * Gets the index of the cell associated with `cellId`.
+ */
+export function getCellIndex(notebook: Notebook, cellId: string): number {
+  const idx = notebook.model?.sharedModel.cells.findIndex(
+    cell => cell.getId() === cellId
+  );
+  return idx === undefined ? -1 : idx;
+}

package/style/chat.css

@@ -63,6 +63,19 @@
   margin-top: 0px;
 }
 
+.jp-chat-writers {
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.jp-chat-writers > div {
+  display: flex;
+  align-items: center;
+  gap: 0.2em;
+  white-space: pre;
+  padding-left: 0.5em;
+}
+
 .jp-chat-navigation {
   position: absolute;
   right: 10px;

package/style/icons/include-selection.svg

@@ -0,0 +1,5 @@
+<svg width="18" height="9" viewBox="0 0 18 9" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M-0.0018417 1.33824L0.837379 0.499023L1.35717 1.01871C1.35741 1.01862 1.35764 1.01853 1.35787 1.01845L3.411 3.07158H3.41049L4.83909 4.49987L3.41011 5.92872H3.41075L1.35769 7.98178C1.35749 7.98171 1.35729 7.98164 1.35709 7.98156L0.837023 8.50158L-0.00219727 7.66236L3.1547 4.49987L-0.0018417 1.33824ZM2.6821 8.07158H16.143C16.932 8.07158 17.5716 7.43201 17.5716 6.64301V2.35729C17.5716 1.56832 16.932 0.928721 16.143 0.928721H2.68236L4.82522 3.07158H15.4287V5.92872H4.82496L2.6821 8.07158ZM1.74238 4.50002L0.428719 5.81655V3.18349L1.74238 4.50002Z"
+        fill="#757575" />
+</svg>