@codingame/monaco-vscode-api 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellContextKeys.js

@@ -1,183 +0,0 @@
-
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
-import '../../../../../../base/common/observableInternal/index.js';
-import { IContextKeyService } from '../../../../../../platform/contextkey/common/contextkey.service.js';
-import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
-import { CellFocusMode, CellEditState } from '../../notebookBrowser.js';
-import { CellContentPart } from '../cellPart.js';
-import { CodeCellViewModel } from '../../viewModel/codeCellViewModel.js';
-import { MarkupCellViewModel } from '../../viewModel/markupCellViewModel.js';
-import { NotebookCellExecutionState } from '../../../common/notebookCommon.js';
-import { NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_EDITOR_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_EXECUTION_STATE, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_INPUT_COLLAPSED, NOTEBOOK_CELL_OUTPUT_COLLAPSED, NOTEBOOK_CELL_LINE_NUMBERS, NOTEBOOK_CELL_RESOURCE, NOTEBOOK_CELL_HAS_ERROR_DIAGNOSTICS } from '../../../common/notebookContextKeys.js';
-import { NotebookExecutionType } from '../../../common/notebookExecutionStateService.js';
-import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.service.js';
-import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
-
-let CellContextKeyPart = class CellContextKeyPart extends CellContentPart {
-    constructor(notebookEditor, instantiationService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.cellContextKeyManager = this._register(
-            this.instantiationService.createInstance(CellContextKeyManager, notebookEditor, undefined)
-        );
-    }
-    didRenderCell(element) {
-        this.cellContextKeyManager.updateForElement(element);
-    }
-};
-CellContextKeyPart = ( __decorate([( __param(1, IInstantiationService))], CellContextKeyPart));
-let CellContextKeyManager = class CellContextKeyManager extends Disposable {
-    constructor(
-        notebookEditor,
-        element,
-        _contextKeyService,
-        _notebookExecutionStateService
-    ) {
-        super();
-        this.notebookEditor = notebookEditor;
-        this.element = element;
-        this._contextKeyService = _contextKeyService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this.elementDisposables = this._register(( new DisposableStore()));
-        this._contextKeyService.bufferChangeEvents(() => {
-            this.cellType = NOTEBOOK_CELL_TYPE.bindTo(this._contextKeyService);
-            this.cellEditable = NOTEBOOK_CELL_EDITABLE.bindTo(this._contextKeyService);
-            this.cellFocused = NOTEBOOK_CELL_FOCUSED.bindTo(this._contextKeyService);
-            this.cellEditorFocused = NOTEBOOK_CELL_EDITOR_FOCUSED.bindTo(this._contextKeyService);
-            this.markdownEditMode = NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.bindTo(this._contextKeyService);
-            this.cellRunState = NOTEBOOK_CELL_EXECUTION_STATE.bindTo(this._contextKeyService);
-            this.cellExecuting = NOTEBOOK_CELL_EXECUTING.bindTo(this._contextKeyService);
-            this.cellHasOutputs = NOTEBOOK_CELL_HAS_OUTPUTS.bindTo(this._contextKeyService);
-            this.cellContentCollapsed = NOTEBOOK_CELL_INPUT_COLLAPSED.bindTo(this._contextKeyService);
-            this.cellOutputCollapsed = NOTEBOOK_CELL_OUTPUT_COLLAPSED.bindTo(this._contextKeyService);
-            this.cellLineNumbers = NOTEBOOK_CELL_LINE_NUMBERS.bindTo(this._contextKeyService);
-            this.cellResource = NOTEBOOK_CELL_RESOURCE.bindTo(this._contextKeyService);
-            this.cellHasErrorDiagnostics = NOTEBOOK_CELL_HAS_ERROR_DIAGNOSTICS.bindTo(this._contextKeyService);
-            if (element) {
-                this.updateForElement(element);
-            }
-        });
-        this._register(this._notebookExecutionStateService.onDidChangeExecution(e => {
-            if (e.type === NotebookExecutionType.cell && this.element && e.affectsCell(this.element.uri)) {
-                this.updateForExecutionState();
-            }
-        }));
-    }
-    updateForElement(element) {
-        this.elementDisposables.clear();
-        this.element = element;
-        if (!element) {
-            return;
-        }
-        this.elementDisposables.add(element.onDidChangeState(e => this.onDidChangeState(e)));
-        if (element instanceof CodeCellViewModel) {
-            this.elementDisposables.add(element.onDidChangeOutputs(() => this.updateForOutputs()));
-            this.elementDisposables.add(autorun(reader => {
-                this.cellHasErrorDiagnostics.set(!!reader.readObservable(element.executionErrorDiagnostic));
-            }));
-        }
-        this.elementDisposables.add(
-            this.notebookEditor.onDidChangeActiveCell(() => this.updateForFocusState())
-        );
-        if (this.element instanceof MarkupCellViewModel) {
-            this.cellType.set("markup");
-        } else if (this.element instanceof CodeCellViewModel) {
-            this.cellType.set("code");
-        }
-        this._contextKeyService.bufferChangeEvents(() => {
-            this.updateForFocusState();
-            this.updateForExecutionState();
-            this.updateForEditState();
-            this.updateForCollapseState();
-            this.updateForOutputs();
-            this.cellLineNumbers.set(this.element.lineNumbers);
-            this.cellResource.set(( this.element.uri.toString()));
-        });
-    }
-    onDidChangeState(e) {
-        this._contextKeyService.bufferChangeEvents(() => {
-            if (e.internalMetadataChanged) {
-                this.updateForExecutionState();
-            }
-            if (e.editStateChanged) {
-                this.updateForEditState();
-            }
-            if (e.focusModeChanged) {
-                this.updateForFocusState();
-            }
-            if (e.cellLineNumberChanged) {
-                this.cellLineNumbers.set(this.element.lineNumbers);
-            }
-            if (e.inputCollapsedChanged || e.outputCollapsedChanged) {
-                this.updateForCollapseState();
-            }
-        });
-    }
-    updateForFocusState() {
-        if (!this.element) {
-            return;
-        }
-        const activeCell = this.notebookEditor.getActiveCell();
-        this.cellFocused.set(this.notebookEditor.getActiveCell() === this.element);
-        if (activeCell === this.element) {
-            this.cellEditorFocused.set(this.element.focusMode === CellFocusMode.Editor);
-        } else {
-            this.cellEditorFocused.set(false);
-        }
-    }
-    updateForExecutionState() {
-        if (!this.element) {
-            return;
-        }
-        const internalMetadata = this.element.internalMetadata;
-        this.cellEditable.set(!this.notebookEditor.isReadOnly);
-        const exeState = this._notebookExecutionStateService.getCellExecution(this.element.uri);
-        if (this.element instanceof MarkupCellViewModel) {
-            this.cellRunState.reset();
-            this.cellExecuting.reset();
-        } else if (exeState?.state === NotebookCellExecutionState.Executing) {
-            this.cellRunState.set("executing");
-            this.cellExecuting.set(true);
-        } else if (exeState?.state === NotebookCellExecutionState.Pending || exeState?.state === NotebookCellExecutionState.Unconfirmed) {
-            this.cellRunState.set("pending");
-            this.cellExecuting.set(true);
-        } else if (internalMetadata.lastRunSuccess === true) {
-            this.cellRunState.set("succeeded");
-            this.cellExecuting.set(false);
-        } else if (internalMetadata.lastRunSuccess === false) {
-            this.cellRunState.set("failed");
-            this.cellExecuting.set(false);
-        } else {
-            this.cellRunState.set("idle");
-            this.cellExecuting.set(false);
-        }
-    }
-    updateForEditState() {
-        if (!this.element) {
-            return;
-        }
-        if (this.element instanceof MarkupCellViewModel) {
-            this.markdownEditMode.set(this.element.getEditState() === CellEditState.Editing);
-        } else {
-            this.markdownEditMode.set(false);
-        }
-    }
-    updateForCollapseState() {
-        if (!this.element) {
-            return;
-        }
-        this.cellContentCollapsed.set(!!this.element.isInputCollapsed);
-        this.cellOutputCollapsed.set(!!this.element.isOutputCollapsed);
-    }
-    updateForOutputs() {
-        if (this.element instanceof CodeCellViewModel) {
-            this.cellHasOutputs.set(this.element.outputsViewModels.length > 0);
-        } else {
-            this.cellHasOutputs.set(false);
-        }
-    }
-};
-CellContextKeyManager = ( __decorate([( __param(2, IContextKeyService)), ( __param(3, INotebookExecutionStateService))], CellContextKeyManager));
-
-export { CellContextKeyManager, CellContextKeyPart };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDecorations.d.ts

@@ -1,10 +0,0 @@
-import { ICellViewModel, INotebookEditorDelegate } from "../../notebookBrowser.js";
-import { CellContentPart } from "../cellPart.js";
-export declare class CellDecorations extends CellContentPart {
-    readonly notebookEditor: INotebookEditorDelegate;
-    readonly rootContainer: HTMLElement;
-    readonly decorationContainer: HTMLElement;
-    constructor(notebookEditor: INotebookEditorDelegate, rootContainer: HTMLElement, decorationContainer: HTMLElement);
-    didRenderCell(element: ICellViewModel): void;
-    private registerDecorations;
-}

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDecorations.js

@@ -1,66 +0,0 @@
-
-import { $ } from '../../../../../../base/browser/dom.js';
-import { CellContentPart } from '../cellPart.js';
-
-class CellDecorations extends CellContentPart {
-    constructor(notebookEditor, rootContainer, decorationContainer) {
-        super();
-        this.notebookEditor = notebookEditor;
-        this.rootContainer = rootContainer;
-        this.decorationContainer = decorationContainer;
-    }
-    didRenderCell(element) {
-        const removedClassNames = [];
-        this.rootContainer.classList.forEach(className => {
-            if (/^nb\-.*$/.test(className)) {
-                removedClassNames.push(className);
-            }
-        });
-        removedClassNames.forEach(className => {
-            this.rootContainer.classList.remove(className);
-        });
-        this.decorationContainer.innerText = '';
-        const generateCellTopDecorations = () => {
-            this.decorationContainer.innerText = '';
-            element.getCellDecorations().filter(options => options.topClassName !== undefined).forEach(options => {
-                this.decorationContainer.append($(`.${options.topClassName}`));
-            });
-        };
-        this.cellDisposables.add(element.onCellDecorationsChanged((e) => {
-            const modified = e.added.find(e => e.topClassName) || e.removed.find(e => e.topClassName);
-            if (modified) {
-                generateCellTopDecorations();
-            }
-        }));
-        generateCellTopDecorations();
-        this.registerDecorations();
-    }
-    registerDecorations() {
-        if (!this.currentCell) {
-            return;
-        }
-        this.cellDisposables.add(this.currentCell.onCellDecorationsChanged((e) => {
-            e.added.forEach(options => {
-                if (options.className && this.currentCell) {
-                    this.rootContainer.classList.add(options.className);
-                }
-            });
-            e.removed.forEach(options => {
-                if (options.className && this.currentCell) {
-                    this.rootContainer.classList.remove(options.className);
-                }
-            });
-        }));
-        this.currentCell.getCellDecorations().forEach(options => {
-            if (options.className && this.currentCell) {
-                this.rootContainer.classList.add(options.className);
-                this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.className], [], this.currentCell.cellKind);
-            }
-            if (options.outputClassName && this.currentCell) {
-                this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.outputClassName], [], this.currentCell.cellKind);
-            }
-        });
-    }
-}
-
-export { CellDecorations };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellDnd.d.ts

@@ -1,52 +0,0 @@
-import { Disposable } from "../../../../../../base/common/lifecycle.js";
-import { ICellViewModel, INotebookEditorDelegate } from "../../notebookBrowser.js";
-import { CellViewModelStateChangeEvent } from "../../notebookViewEvents.js";
-import { CellContentPart } from "../cellPart.js";
-import { BaseCellRenderTemplate, INotebookCellList } from "../notebookRenderingCommon.js";
-type DragImageProvider = () => HTMLElement;
-export declare class CellDragAndDropPart extends CellContentPart {
-    private readonly container;
-    constructor(container: HTMLElement);
-    didRenderCell(element: ICellViewModel): void;
-    updateState(element: ICellViewModel, e: CellViewModelStateChangeEvent): void;
-    private update;
-}
-export declare class CellDragAndDropController extends Disposable {
-    private notebookEditor;
-    private readonly notebookListContainer;
-    private currentDraggedCell;
-    private draggedCells;
-    private listInsertionIndicator;
-    private list;
-    private isScrolling;
-    private readonly scrollingDelayer;
-    private readonly listOnWillScrollListener;
-    constructor(notebookEditor: INotebookEditorDelegate, notebookListContainer: HTMLElement);
-    setList(value: INotebookCellList): void;
-    private setInsertIndicatorVisibility;
-    private toCellDragEvent;
-    clearGlobalDragState(): void;
-    private onGlobalDragStart;
-    private onGlobalDragEnd;
-    private onCellDragover;
-    private updateInsertIndicator;
-    private getDropInsertDirection;
-    private onCellDrop;
-    private getCellRangeAroundDragTarget;
-    private _dropImpl;
-    private onCellDragLeave;
-    private dragCleanup;
-    registerDragHandle(templateData: BaseCellRenderTemplate, cellRoot: HTMLElement, dragHandles: HTMLElement[], dragImageProvider: DragImageProvider): void;
-    startExplicitDrag(cell: ICellViewModel, _dragOffsetY: number): void;
-    explicitDrag(cell: ICellViewModel, dragOffsetY: number): void;
-    endExplicitDrag(_cell: ICellViewModel): void;
-    explicitDrop(cell: ICellViewModel, ctx: {
-        dragOffsetY: number;
-        ctrlKey: boolean;
-        altKey: boolean;
-    }): void;
-    private getExplicitDragDropDirection;
-    dispose(): void;
-}
-export declare function performCellDropEdits(editor: INotebookEditorDelegate, draggedCell: ICellViewModel, dropDirection: "above" | "below", draggedOverCell: ICellViewModel): void;
-export {};