@theia/notebook 1.67.0-next.3 → 1.67.0-next.59

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

@@ -0,0 +1,138 @@
+// *****************************************************************************
+// Copyright (C) 2025 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { NotebookCellModel } from './notebook-cell-model';
+import { Disposable, Emitter } from '@theia/core';
+import { NotebookModel } from './notebook-model';
+
+export interface SelectedCellChangeEvent {
+    cell: NotebookCellModel | undefined;
+    scrollIntoView: boolean;
+}
+
+export type CellEditorFocusRequest = number | 'lastLine' | undefined;
+
+/**
+ * Model containing the editor state/view information of a notebook editor. The actual notebook data can be found in the {@link NotebookModel}.
+ */
+@injectable()
+export class NotebookViewModel implements Disposable {
+
+    protected readonly onDidChangeSelectedCellEmitter = new Emitter<SelectedCellChangeEvent>();
+    readonly onDidChangeSelectedCell = this.onDidChangeSelectedCellEmitter.event;
+
+    selectedCell?: NotebookCellModel;
+    get selectedCellViewModel(): CellViewModel | undefined {
+        if (this.selectedCell) {
+            return this.cellViewModels.get(this.selectedCell.handle);
+        }
+    }
+
+    // Cell handle to CellViewModel mapping
+    readonly cellViewModels: Map<number, CellViewModel> = new Map();
+
+    initDataModel(model: NotebookModel): void {
+        model.onDidAddOrRemoveCell(e => {
+
+            for (const cellId of e.newCellIds || []) {
+                const cell = model.getCellByHandle(cellId);
+                if (cell) {
+                    this.cellViewModels.set(cell.handle, new CellViewModel(cell, () => {
+                        this.cellViewModels.delete(cell.handle);
+                    }));
+                }
+            }
+
+            if (e.newCellIds && e.newCellIds?.length > 0 && e.externalEvent) {
+                const lastNewCellHandle = e.newCellIds[e.newCellIds.length - 1];
+                const newSelectedCell = model.getCellByHandle(lastNewCellHandle)!;
+                this.setSelectedCell(newSelectedCell, true);
+                this.cellViewModels.get(newSelectedCell.handle)?.requestEdit();
+            } else if (this.selectedCell && !model.getCellByHandle(this.selectedCell.handle)) {
+                const newSelectedIndex = e.rawEvent.changes[e.rawEvent.changes.length - 1].start;
+                const newSelectedCell = model.cells[Math.min(newSelectedIndex, model.cells.length - 1)];
+                this.setSelectedCell(newSelectedCell, false);
+            }
+        });
+
+        for (const cell of model.cells) {
+            this.cellViewModels.set(cell.handle, new CellViewModel(cell, () => {
+                this.cellViewModels.delete(cell.handle);
+            }));
+        }
+    }
+
+    setSelectedCell(cell: NotebookCellModel, scrollIntoView: boolean = true): void {
+        if (this.selectedCell !== cell) {
+            this.selectedCell = cell;
+            this.onDidChangeSelectedCellEmitter.fire({ cell, scrollIntoView });
+        }
+    }
+
+    dispose(): void {
+        this.onDidChangeSelectedCellEmitter.dispose();
+    }
+
+}
+
+export class CellViewModel implements Disposable {
+
+    protected readonly onDidRequestCellEditChangeEmitter = new Emitter<boolean>();
+    readonly onDidRequestCellEditChange = this.onDidRequestCellEditChangeEmitter.event;
+
+    protected readonly onWillFocusCellEditorEmitter = new Emitter<CellEditorFocusRequest>();
+    readonly onWillFocusCellEditor = this.onWillFocusCellEditorEmitter.event;
+
+    protected readonly onWillBlurCellEditorEmitter = new Emitter<void>();
+    readonly onWillBlurCellEditor = this.onWillBlurCellEditorEmitter.event;
+
+    protected _editing: boolean = false;
+    get editing(): boolean {
+        return this._editing;
+    }
+
+    constructor(protected readonly cell: NotebookCellModel, protected onDispose: () => void) {
+        cell.toDispose.push(this);
+    }
+
+    requestEdit(): void {
+        if (this.cell.isTextModelWritable) {
+            this._editing = true;
+            this.onDidRequestCellEditChangeEmitter.fire(true);
+        }
+    }
+
+    requestStopEdit(): void {
+        this._editing = false;
+        this.onDidRequestCellEditChangeEmitter.fire(false);
+    }
+
+    requestFocusEditor(focusRequest?: CellEditorFocusRequest): void {
+        this.requestEdit();
+        this.onWillFocusCellEditorEmitter.fire(focusRequest);
+    }
+
+    requestBlurEditor(): void {
+        this.requestStopEdit();
+        this.onWillBlurCellEditorEmitter.fire();
+    }
+
+    dispose(): void {
+        this.onDispose();
+        this.onDidRequestCellEditChangeEmitter.dispose();
+    }
+}