@theia/notebook 1.51.0 → 1.53.0-next.4

package/src/browser/view-model/notebook-cell-model.ts

@@ -32,6 +32,8 @@ import { NotebookCellOutputModel } from './notebook-cell-output-model';
 import { PreferenceService } from '@theia/core/lib/browser';
 import { NotebookPreferences } from '../contributions/notebook-preferences';
 import { LanguageService } from '@theia/core/lib/browser/language-service';
+import { NotebookEditorFindMatch, NotebookEditorFindMatchOptions } from '../view/notebook-find-widget';
+import { Range } from '@theia/core/shared/vscode-languageserver-protocol';
 
 export const NotebookCellModelFactory = Symbol('NotebookModelFactory');
 export type NotebookCellModelFactory = (props: NotebookCellModelProps) => NotebookCellModel;
@@ -86,22 +88,22 @@ export interface NotebookCellModelProps {
 export class NotebookCellModel implements NotebookCell, Disposable {
 
     protected readonly onDidChangeOutputsEmitter = new Emitter<NotebookCellOutputsSplice>();
-    readonly onDidChangeOutputs: Event<NotebookCellOutputsSplice> = this.onDidChangeOutputsEmitter.event;
+    readonly onDidChangeOutputs = this.onDidChangeOutputsEmitter.event;
 
     protected readonly onDidChangeOutputItemsEmitter = new Emitter<CellOutput>();
-    readonly onDidChangeOutputItems: Event<CellOutput> = this.onDidChangeOutputItemsEmitter.event;
+    readonly onDidChangeOutputItems = this.onDidChangeOutputItemsEmitter.event;
 
     protected readonly onDidChangeContentEmitter = new Emitter<'content' | 'language' | 'mime'>();
-    readonly onDidChangeContent: Event<'content' | 'language' | 'mime'> = this.onDidChangeContentEmitter.event;
+    readonly onDidChangeContent = this.onDidChangeContentEmitter.event;
 
     protected readonly onDidChangeMetadataEmitter = new Emitter<void>();
-    readonly onDidChangeMetadata: Event<void> = this.onDidChangeMetadataEmitter.event;
+    readonly onDidChangeMetadata = this.onDidChangeMetadataEmitter.event;
 
     protected readonly onDidChangeInternalMetadataEmitter = new Emitter<CellInternalMetadataChangedEvent>();
-    readonly onDidChangeInternalMetadata: Event<CellInternalMetadataChangedEvent> = this.onDidChangeInternalMetadataEmitter.event;
+    readonly onDidChangeInternalMetadata = this.onDidChangeInternalMetadataEmitter.event;
 
     protected readonly onDidChangeLanguageEmitter = new Emitter<string>();
-    readonly onDidChangeLanguage: Event<string> = this.onDidChangeLanguageEmitter.event;
+    readonly onDidChangeLanguage = this.onDidChangeLanguageEmitter.event;
 
     protected readonly onDidRequestCellEditChangeEmitter = new Emitter<boolean>();
     readonly onDidRequestCellEditChange = this.onDidRequestCellEditChangeEmitter.event;
@@ -113,10 +115,16 @@ export class NotebookCellModel implements NotebookCell, Disposable {
     readonly onWillBlurCellEditor = this.onWillBlurCellEditorEmitter.event;
 
     protected readonly onDidChangeEditorOptionsEmitter = new Emitter<MonacoEditor.IOptions>();
-    readonly onDidChangeEditorOptions: Event<MonacoEditor.IOptions> = this.onDidChangeEditorOptionsEmitter.event;
+    readonly onDidChangeEditorOptions = this.onDidChangeEditorOptionsEmitter.event;
 
     protected readonly outputVisibilityChangeEmitter = new Emitter<boolean>();
-    readonly onDidChangeOutputVisibility: Event<boolean> = this.outputVisibilityChangeEmitter.event;
+    readonly onDidChangeOutputVisibility = this.outputVisibilityChangeEmitter.event;
+
+    protected readonly onDidFindMatchesEmitter = new Emitter<NotebookCodeEditorFindMatch[]>();
+    readonly onDidFindMatches: Event<NotebookCodeEditorFindMatch[]> = this.onDidFindMatchesEmitter.event;
+
+    protected readonly onDidSelectFindMatchEmitter = new Emitter<NotebookCodeEditorFindMatch>();
+    readonly onDidSelectFindMatch: Event<NotebookCodeEditorFindMatch> = this.onDidSelectFindMatchEmitter.event;
 
     @inject(NotebookCellModelProps)
     protected readonly props: NotebookCellModelProps;
@@ -175,10 +183,12 @@ export class NotebookCellModel implements NotebookCell, Disposable {
     get source(): string {
         return this.props.source;
     }
+
     set source(source: string) {
         this.props.source = source;
         this.textModel?.textEditorModel.setValue(source);
     }
+
     get language(): string {
         return this.props.language;
     }
@@ -368,6 +378,82 @@ export class NotebookCellModel implements NotebookCell, Disposable {
             this.onDidChangeOutputItemsEmitter.fire(output);
         }
     }
+
+    onMarkdownFind: ((options: NotebookEditorFindMatchOptions) => NotebookEditorFindMatch[]) | undefined;
+
+    showMatch(selected: NotebookCodeEditorFindMatch): void {
+        this.onDidSelectFindMatchEmitter.fire(selected);
+    }
+
+    findMatches(options: NotebookEditorFindMatchOptions): NotebookEditorFindMatch[] {
+        if (this.cellKind === CellKind.Markup && !this.editing) {
+            return this.onMarkdownFind?.(options) ?? [];
+        }
+        if (!this.textModel) {
+            return [];
+        }
+        const matches = options.search ? this.textModel.findMatches({
+            searchString: options.search,
+            isRegex: options.regex,
+            matchCase: options.matchCase,
+            matchWholeWord: options.wholeWord
+        }) : [];
+        const editorFindMatches = matches.map(match => new NotebookCodeEditorFindMatch(this, match.range, this.textModel!));
+        this.onDidFindMatchesEmitter.fire(editorFindMatches);
+        return editorFindMatches;
+    }
+
+    replaceAll(matches: NotebookCodeEditorFindMatch[], value: string): void {
+        const editOperations = matches.map(match => ({
+            range: {
+                startColumn: match.range.start.character,
+                startLineNumber: match.range.start.line,
+                endColumn: match.range.end.character,
+                endLineNumber: match.range.end.line
+            },
+            text: value
+        }));
+        this.textModel?.textEditorModel.pushEditOperations(
+            // eslint-disable-next-line no-null/no-null
+            null,
+            editOperations,
+            // eslint-disable-next-line no-null/no-null
+            () => null);
+    }
+}
+
+export interface NotebookCellFindMatches {
+    matches: NotebookEditorFindMatch[];
+    selected: NotebookEditorFindMatch;
+}
+
+export class NotebookCodeEditorFindMatch implements NotebookEditorFindMatch {
+
+    selected = false;
+
+    constructor(readonly cell: NotebookCellModel, readonly range: Range, readonly textModel: MonacoEditorModel) {
+    }
+
+    show(): void {
+        this.cell.showMatch(this);
+    }
+    replace(value: string): void {
+        this.textModel.textEditorModel.pushEditOperations(
+            // eslint-disable-next-line no-null/no-null
+            null,
+            [{
+                range: {
+                    startColumn: this.range.start.character,
+                    startLineNumber: this.range.start.line,
+                    endColumn: this.range.end.character,
+                    endLineNumber: this.range.end.line
+                },
+                text: value
+            }],
+            // eslint-disable-next-line no-null/no-null
+            () => null);
+    }
+
 }
 
 function computeRunStartTimeAdjustment(oldMetadata: NotebookCellInternalMetadata, newMetadata: NotebookCellInternalMetadata): number | undefined {

package/src/browser/view-model/notebook-model.ts

@@ -29,12 +29,13 @@ import {
 } from '../notebook-types';
 import { NotebookSerializer } from '../service/notebook-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { NotebookCellModel, NotebookCellModelFactory } from './notebook-cell-model';
+import { NotebookCellModel, NotebookCellModelFactory, NotebookCodeEditorFindMatch } from './notebook-cell-model';
 import { inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
 import { UndoRedoService } from '@theia/editor/lib/browser/undo-redo-service';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import type { NotebookModelResolverService } from '../service/notebook-model-resolver-service';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { NotebookEditorFindMatch, NotebookEditorFindMatchOptions } from '../view/notebook-find-widget';
 
 export const NotebookModelFactory = Symbol('NotebookModelFactory');
 
@@ -125,6 +126,16 @@ export class NotebookModel implements Saveable, Disposable {
         return this.props.resource.readOnly ?? false;
     }
 
+    protected _selectedText = '';
+
+    set selectedText(value: string) {
+        this._selectedText = value;
+    }
+
+    get selectedText(): string {
+        return this._selectedText;
+    }
+
     selectedCell?: NotebookCellModel;
     protected dirtyCells: NotebookCellModel[] = [];
 
@@ -227,12 +238,15 @@ export class NotebookModel implements Saveable, Disposable {
         }
 
         this.dirty = this.dirtyCells.length > 0;
+        // Only fire `onContentChangedEmitter` here, because `onDidChangeContentEmitter` is used for model level changes only
+        // However, this event indicates that the content of a cell has changed
+        this.onContentChangedEmitter.fire();
     }
 
     setData(data: NotebookData, markDirty = true): void {
         // Replace all cells in the model
         this.dirtyCells = [];
-        this.replaceCells(0, this.cells.length, data.cells, false);
+        this.replaceCells(0, this.cells.length, data.cells, false, false);
         this.metadata = data.metadata;
         this.dirty = markDirty;
         this.onDidChangeContentEmitter.fire();
@@ -246,13 +260,15 @@ export class NotebookModel implements Saveable, Disposable {
     }
 
     undo(): void {
-        // TODO we probably need to check if a monaco editor is focused and if so, not undo
-        this.undoRedoService.undo(this.uri);
+        if (!this.readOnly) {
+            this.undoRedoService.undo(this.uri);
+        }
     }
 
     redo(): void {
-        // TODO see undo
-        this.undoRedoService.redo(this.uri);
+        if (!this.readOnly) {
+            this.undoRedoService.redo(this.uri);
+        }
     }
 
     setSelectedCell(cell: NotebookCellModel, scrollIntoView?: boolean): void {
@@ -267,6 +283,9 @@ export class NotebookModel implements Saveable, Disposable {
             cell.onDidChangeOutputs(() => {
                 this.dirty = true;
             });
+            cell.onDidRequestCellEditChange(() => {
+                this.onContentChangedEmitter.fire();
+            });
         }
     }
 
@@ -298,7 +317,7 @@ export class NotebookModel implements Saveable, Disposable {
             let scrollIntoView = true;
             switch (edit.editType) {
                 case CellEditType.Replace:
-                    this.replaceCells(edit.index, edit.count, edit.cells, computeUndoRedo);
+                    this.replaceCells(edit.index, edit.count, edit.cells, computeUndoRedo, true);
                     scrollIntoView = edit.cells.length > 0;
                     break;
                 case CellEditType.Output: {
@@ -321,10 +340,10 @@ export class NotebookModel implements Saveable, Disposable {
 
                     break;
                 case CellEditType.Metadata:
-                    this.changeCellMetadata(this.cells[cellIndex], edit.metadata, computeUndoRedo);
+                    this.changeCellMetadata(this.cells[cellIndex], edit.metadata, false);
                     break;
                 case CellEditType.PartialMetadata:
-                    this.changeCellMetadataPartial(this.cells[cellIndex], edit.metadata, computeUndoRedo);
+                    this.changeCellMetadataPartial(this.cells[cellIndex], edit.metadata, false);
                     break;
                 case CellEditType.PartialInternalMetadata:
                     this.changeCellInternalMetadataPartial(this.cells[cellIndex], edit.internalMetadata);
@@ -333,7 +352,7 @@ export class NotebookModel implements Saveable, Disposable {
                     this.changeCellLanguage(this.cells[cellIndex], edit.language, computeUndoRedo);
                     break;
                 case CellEditType.DocumentMetadata:
-                    this.updateNotebookMetadata(edit.metadata, computeUndoRedo);
+                    this.updateNotebookMetadata(edit.metadata, false);
                     break;
                 case CellEditType.Move:
                     this.moveCellToIndex(cellIndex, edit.length, edit.newIdx, computeUndoRedo);
@@ -346,11 +365,15 @@ export class NotebookModel implements Saveable, Disposable {
             }
         }
 
+        this.fireContentChange();
+    }
+
+    protected fireContentChange(): void {
         this.onDidChangeContentEmitter.fire();
         this.onContentChangedEmitter.fire();
     }
 
-    protected replaceCells(start: number, deleteCount: number, newCells: CellData[], computeUndoRedo: boolean): void {
+    protected replaceCells(start: number, deleteCount: number, newCells: CellData[], computeUndoRedo: boolean, requestEdit: boolean): void {
         const cells = newCells.map(cell => {
             const handle = this.nextHandle++;
             return this.cellModelFactory({
@@ -377,13 +400,20 @@ export class NotebookModel implements Saveable, Disposable {
 
         if (computeUndoRedo) {
             this.undoRedoService.pushElement(this.uri,
-                async () => this.replaceCells(start, newCells.length, deletedCells.map(cell => cell.getData()), false),
-                async () => this.replaceCells(start, deleteCount, newCells, false));
+                async () => {
+                    this.replaceCells(start, newCells.length, deletedCells.map(cell => cell.getData()), false, false);
+                    this.fireContentChange();
+                },
+                async () => {
+                    this.replaceCells(start, deleteCount, newCells, false, false);
+                    this.fireContentChange();
+                }
+            );
         }
 
         this.onDidAddOrRemoveCellEmitter.fire({ rawEvent: { kind: NotebookCellsChangeType.ModelChange, changes }, newCellIds: cells.map(cell => cell.handle) });
         this.onDidChangeContentEmitter.queue({ kind: NotebookCellsChangeType.ModelChange, changes });
-        if (cells.length > 0) {
+        if (cells.length > 0 && requestEdit) {
             this.setSelectedCell(cells[cells.length - 1]);
             cells[cells.length - 1].requestEdit();
         }
@@ -461,8 +491,14 @@ export class NotebookModel implements Saveable, Disposable {
     protected moveCellToIndex(fromIndex: number, length: number, toIndex: number, computeUndoRedo: boolean): boolean {
         if (computeUndoRedo) {
             this.undoRedoService.pushElement(this.uri,
-                async () => { this.moveCellToIndex(toIndex, length, fromIndex, false); },
-                async () => { this.moveCellToIndex(fromIndex, length, toIndex, false); }
+                async () => {
+                    this.moveCellToIndex(toIndex, length, fromIndex, false);
+                    this.fireContentChange();
+                },
+                async () => {
+                    this.moveCellToIndex(fromIndex, length, toIndex, false);
+                    this.fireContentChange();
+                }
             );
         }
 
@@ -478,11 +514,9 @@ export class NotebookModel implements Saveable, Disposable {
     }
 
     protected isCellMetadataChanged(a: NotebookCellMetadata, b: NotebookCellMetadata): boolean {
-        const keys = new Set([...Object.keys(a || {}), ...Object.keys(b || {})]);
+        const keys = new Set<keyof NotebookCellMetadata>([...Object.keys(a || {}), ...Object.keys(b || {})]);
         for (const key of keys) {
-            if (
-                (a[key as keyof NotebookCellMetadata] !== b[key as keyof NotebookCellMetadata])
-            ) {
+            if (a[key] !== b[key]) {
                 return true;
             }
         }
@@ -490,4 +524,27 @@ export class NotebookModel implements Saveable, Disposable {
         return false;
     }
 
+    findMatches(options: NotebookEditorFindMatchOptions): NotebookEditorFindMatch[] {
+        const matches: NotebookEditorFindMatch[] = [];
+        for (const cell of this.cells) {
+            matches.push(...cell.findMatches(options));
+        }
+        return matches;
+    }
+
+    replaceAll(matches: NotebookEditorFindMatch[], text: string): void {
+        const matchMap = new Map<NotebookCellModel, NotebookCodeEditorFindMatch[]>();
+        for (const match of matches) {
+            if (match instanceof NotebookCodeEditorFindMatch) {
+                if (!matchMap.has(match.cell)) {
+                    matchMap.set(match.cell, []);
+                }
+                matchMap.get(match.cell)?.push(match);
+            }
+        }
+        for (const [cell, cellMatches] of matchMap) {
+            cell.replaceAll(cellMatches, text);
+        }
+    }
+
 }