@codingame/monaco-vscode-api 37.1.0 → 37.2.0

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

@@ -1,59 +0,0 @@
-import { IRange } from "../../../../../base/common/range.js";
-import { ListView } from "../../../../../base/browser/ui/list/listView.js";
-import { IItem, IRangeMap } from "../../../../../base/browser/ui/list/rangeMap.js";
-import { ConstantTimePrefixSumComputer } from "../../../../../editor/common/model/prefixSumComputer.js";
-export interface IWhitespace {
-    id: string;
-    /**
-     * To insert whitespace before the first item, use afterPosition 0.
-     * In other cases, afterPosition is 1-based.
-     */
-    afterPosition: number;
-    size: number;
-    priority: number;
-}
-export declare class NotebookCellsLayout implements IRangeMap {
-    private _items;
-    private _whitespace;
-    protected _prefixSumComputer: ConstantTimePrefixSumComputer;
-    private _size;
-    private _paddingTop;
-    get paddingTop(): number;
-    set paddingTop(paddingTop: number);
-    get count(): number;
-    /**
-     * Returns the sum of the sizes of all items in the range map.
-     */
-    get size(): number;
-    constructor(topPadding?: number);
-    getWhitespaces(): IWhitespace[];
-    restoreWhitespace(items: IWhitespace[]): void;
-    /**
-     */
-    splice(index: number, deleteCount: number, items?: IItem[] | undefined): void;
-    insertWhitespace(id: string, afterPosition: number, size: number): void;
-    changeOneWhitespace(id: string, afterPosition: number, size: number): void;
-    removeWhitespace(id: string): void;
-    /**
-     * find position of whitespace
-     * @param id: id of the whitespace
-     * @returns: position in the list view
-     */
-    getWhitespacePosition(id: string): number;
-    indexAt(position: number): number;
-    indexAfter(position: number): number;
-    positionAt(index: number): number;
-}
-export declare class NotebookCellListView<T> extends ListView<T> {
-    private _lastWhitespaceId;
-    private _renderingStack;
-    get inRenderingTransaction(): boolean;
-    get notebookRangeMap(): NotebookCellsLayout;
-    protected render(previousRenderRange: IRange, renderTop: number, renderHeight: number, renderLeft: number | undefined, scrollWidth: number | undefined, updateItemsInDOM?: boolean): void;
-    protected _rerender(renderTop: number, renderHeight: number, inSmoothScrolling?: boolean | undefined): void;
-    protected createRangeMap(paddingTop: number): IRangeMap;
-    insertWhitespace(afterPosition: number, size: number): string;
-    changeOneWhitespace(id: string, newAfterPosition: number, newSize: number): void;
-    removeWhitespace(id: string): void;
-    getWhitespacePosition(id: string): number;
-}

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

@@ -1,287 +0,0 @@
-
-import { ListView } from '../../../../../base/browser/ui/list/listView.js';
-import { ConstantTimePrefixSumComputer } from '../../../../../editor/common/model/prefixSumComputer.js';
-
-class NotebookCellsLayout {
-    get paddingTop() {
-        return this._paddingTop;
-    }
-    set paddingTop(paddingTop) {
-        this._size = this._size + paddingTop - this._paddingTop;
-        this._paddingTop = paddingTop;
-    }
-    get count() {
-        return this._items.length;
-    }
-    get size() {
-        return this._size;
-    }
-    constructor(topPadding) {
-        this._items = [];
-        this._whitespace = [];
-        this._prefixSumComputer = ( new ConstantTimePrefixSumComputer([]));
-        this._size = 0;
-        this._paddingTop = 0;
-        this._paddingTop = topPadding ?? 0;
-        this._size = this._paddingTop;
-    }
-    getWhitespaces() {
-        return this._whitespace;
-    }
-    restoreWhitespace(items) {
-        this._whitespace = items;
-        this._size = this._paddingTop + this._items.reduce((total, item) => total + item.size, 0) + this._whitespace.reduce((total, ws) => total + ws.size, 0);
-    }
-    splice(index, deleteCount, items) {
-        const inserts = items ?? [];
-        this._items.splice(index, deleteCount, ...inserts);
-        this._size = this._paddingTop + this._items.reduce((total, item) => total + item.size, 0) + this._whitespace.reduce((total, ws) => total + ws.size, 0);
-        this._prefixSumComputer.removeValues(index, deleteCount);
-        const newSizes = [];
-        for (let i = 0; i < inserts.length; i++) {
-            const insertIndex = i + index;
-            const existingWhitespaces = this._whitespace.filter(ws => ws.afterPosition === insertIndex + 1);
-            if (existingWhitespaces.length > 0) {
-                newSizes.push(
-                    inserts[i].size + existingWhitespaces.reduce((acc, ws) => acc + ws.size, 0)
-                );
-            } else {
-                newSizes.push(inserts[i].size);
-            }
-        }
-        this._prefixSumComputer.insertValues(index, newSizes);
-        for (let i = index; i < this._items.length; i++) {
-            const existingWhitespaces = this._whitespace.filter(ws => ws.afterPosition === i + 1);
-            if (existingWhitespaces.length > 0) {
-                this._prefixSumComputer.setValue(
-                    i,
-                    this._items[i].size + existingWhitespaces.reduce((acc, ws) => acc + ws.size, 0)
-                );
-            } else {
-                this._prefixSumComputer.setValue(i, this._items[i].size);
-            }
-        }
-    }
-    insertWhitespace(id, afterPosition, size) {
-        let priority = 0;
-        const existingWhitespaces = this._whitespace.filter(ws => ws.afterPosition === afterPosition);
-        if (existingWhitespaces.length > 0) {
-            priority = Math.max(...( existingWhitespaces.map(ws => ws.priority))) + 1;
-        }
-        this._whitespace.push({
-            id,
-            afterPosition: afterPosition,
-            size,
-            priority
-        });
-        this._size += size;
-        this._whitespace.sort((a, b) => {
-            if (a.afterPosition === b.afterPosition) {
-                return a.priority - b.priority;
-            }
-            return a.afterPosition - b.afterPosition;
-        });
-        if (afterPosition > 0) {
-            const index = afterPosition - 1;
-            const itemSize = this._items[index].size;
-            const accSize = itemSize + size;
-            this._prefixSumComputer.setValue(index, accSize);
-        }
-    }
-    changeOneWhitespace(id, afterPosition, size) {
-        const whitespaceIndex = this._whitespace.findIndex(ws => ws.id === id);
-        if (whitespaceIndex !== -1) {
-            const whitespace = this._whitespace[whitespaceIndex];
-            const oldAfterPosition = whitespace.afterPosition;
-            whitespace.afterPosition = afterPosition;
-            const oldSize = whitespace.size;
-            const delta = size - oldSize;
-            whitespace.size = size;
-            this._size += delta;
-            if (oldAfterPosition > 0 && oldAfterPosition <= this._items.length) {
-                const index = oldAfterPosition - 1;
-                const itemSize = this._items[index].size;
-                const accSize = itemSize;
-                this._prefixSumComputer.setValue(index, accSize);
-            }
-            if (afterPosition > 0 && afterPosition <= this._items.length) {
-                const index = afterPosition - 1;
-                const itemSize = this._items[index].size;
-                const accSize = itemSize + size;
-                this._prefixSumComputer.setValue(index, accSize);
-            }
-        }
-    }
-    removeWhitespace(id) {
-        const whitespaceIndex = this._whitespace.findIndex(ws => ws.id === id);
-        if (whitespaceIndex !== -1) {
-            const whitespace = this._whitespace[whitespaceIndex];
-            this._whitespace.splice(whitespaceIndex, 1);
-            this._size -= whitespace.size;
-            if (whitespace.afterPosition > 0) {
-                const index = whitespace.afterPosition - 1;
-                const itemSize = this._items[index].size;
-                const remainingWhitespaces = this._whitespace.filter(ws => ws.afterPosition === whitespace.afterPosition);
-                const accSize = itemSize + remainingWhitespaces.reduce((acc, ws) => acc + ws.size, 0);
-                this._prefixSumComputer.setValue(index, accSize);
-            }
-        }
-    }
-    getWhitespacePosition(id) {
-        const whitespace = this._whitespace.find(ws => ws.id === id);
-        if (!whitespace) {
-            throw ( new Error("Whitespace not found"));
-        }
-        const afterPosition = whitespace.afterPosition;
-        if (afterPosition === 0) {
-            const whitespaces = this._whitespace.filter(
-                ws => ws.afterPosition === afterPosition && ws.priority < whitespace.priority
-            );
-            return whitespaces.reduce((acc, ws) => acc + ws.size, 0) + this.paddingTop;
-        }
-        const whitespaceBeforeFirstItem = this._whitespace.filter(ws => ws.afterPosition === 0).reduce((acc, ws) => acc + ws.size, 0);
-        const index = afterPosition - 1;
-        const previousItemPosition = this._prefixSumComputer.getPrefixSum(index);
-        const previousItemSize = this._items[index].size;
-        return previousItemPosition + previousItemSize + whitespaceBeforeFirstItem + this.paddingTop;
-    }
-    indexAt(position) {
-        if (position < 0) {
-            return -1;
-        }
-        const whitespaceBeforeFirstItem = this._whitespace.filter(ws => ws.afterPosition === 0).reduce((acc, ws) => acc + ws.size, 0);
-        const offset = position - (this._paddingTop + whitespaceBeforeFirstItem);
-        if (offset <= 0) {
-            return 0;
-        }
-        if (offset >= (this._size - this._paddingTop - whitespaceBeforeFirstItem)) {
-            return this.count;
-        }
-        return this._prefixSumComputer.getIndexOf(Math.trunc(offset)).index;
-    }
-    indexAfter(position) {
-        const index = this.indexAt(position);
-        return Math.min(index + 1, this._items.length);
-    }
-    positionAt(index) {
-        if (index < 0) {
-            return -1;
-        }
-        if (this.count === 0) {
-            return -1;
-        }
-        if (index >= this.count) {
-            return -1;
-        }
-        const whitespaceBeforeFirstItem = this._whitespace.filter(ws => ws.afterPosition === 0).reduce((acc, ws) => acc + ws.size, 0);
-        return this._prefixSumComputer.getPrefixSum(index ) + this._paddingTop + whitespaceBeforeFirstItem;
-    }
-}
-class NotebookCellListView extends ListView {
-    constructor() {
-        super(...arguments);
-        this._lastWhitespaceId = 0;
-        this._renderingStack = 0;
-    }
-    get inRenderingTransaction() {
-        return this._renderingStack > 0;
-    }
-    get notebookRangeMap() {
-        return this.rangeMap;
-    }
-    render(
-        previousRenderRange,
-        renderTop,
-        renderHeight,
-        renderLeft,
-        scrollWidth,
-        updateItemsInDOM
-    ) {
-        this._renderingStack++;
-        super.render(
-            previousRenderRange,
-            renderTop,
-            renderHeight,
-            renderLeft,
-            scrollWidth,
-            updateItemsInDOM
-        );
-        this._renderingStack--;
-    }
-    _rerender(renderTop, renderHeight, inSmoothScrolling) {
-        this._renderingStack++;
-        super._rerender(renderTop, renderHeight, inSmoothScrolling);
-        this._renderingStack--;
-    }
-    createRangeMap(paddingTop) {
-        const existingMap = this.rangeMap;
-        if (existingMap) {
-            const layout = ( new NotebookCellsLayout(paddingTop));
-            layout.restoreWhitespace(existingMap.getWhitespaces());
-            return layout;
-        } else {
-            return ( new NotebookCellsLayout(paddingTop));
-        }
-    }
-    insertWhitespace(afterPosition, size) {
-        const scrollTop = this.scrollTop;
-        const id = `${++this._lastWhitespaceId}`;
-        const previousRenderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
-        const elementPosition = this.elementTop(afterPosition);
-        const aboveScrollTop = scrollTop > elementPosition;
-        this.notebookRangeMap.insertWhitespace(id, afterPosition, size);
-        const newScrolltop = aboveScrollTop ? scrollTop + size : scrollTop;
-        this.render(
-            previousRenderRange,
-            newScrolltop,
-            this.lastRenderHeight,
-            undefined,
-            undefined,
-            false
-        );
-        this._rerender(newScrolltop, this.renderHeight, false);
-        this.eventuallyUpdateScrollDimensions();
-        return id;
-    }
-    changeOneWhitespace(id, newAfterPosition, newSize) {
-        const scrollTop = this.scrollTop;
-        const previousRenderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
-        const currentPosition = this.notebookRangeMap.getWhitespacePosition(id);
-        if (currentPosition > scrollTop) {
-            this.notebookRangeMap.changeOneWhitespace(id, newAfterPosition, newSize);
-            this.render(
-                previousRenderRange,
-                scrollTop,
-                this.lastRenderHeight,
-                undefined,
-                undefined,
-                false
-            );
-            this._rerender(scrollTop, this.renderHeight, false);
-            this.eventuallyUpdateScrollDimensions();
-        } else {
-            this.notebookRangeMap.changeOneWhitespace(id, newAfterPosition, newSize);
-            this.eventuallyUpdateScrollDimensions();
-        }
-    }
-    removeWhitespace(id) {
-        const scrollTop = this.scrollTop;
-        const previousRenderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
-        this.notebookRangeMap.removeWhitespace(id);
-        this.render(
-            previousRenderRange,
-            scrollTop,
-            this.lastRenderHeight,
-            undefined,
-            undefined,
-            false
-        );
-        this._rerender(scrollTop, this.renderHeight, false);
-        this.eventuallyUpdateScrollDimensions();
-    }
-    getWhitespacePosition(id) {
-        return this.notebookRangeMap.getWhitespacePosition(id);
-    }
-}
-
-export { NotebookCellListView, NotebookCellsLayout };

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

@@ -1,117 +0,0 @@
-import { FastDomNode } from "../../../../../base/browser/fastDomNode.js";
-import { IMouseWheelEvent } from "../../../../../base/browser/mouseEvent.js";
-import { IListContextMenuEvent, IListEvent, IListMouseEvent } from "../../../../../base/browser/ui/list/list.js";
-import { IListStyles } from "../../../../../base/browser/ui/list/listWidget.js";
-import { Event } from "../../../../../base/common/event.js";
-import { DisposableStore } from "../../../../../base/common/lifecycle.js";
-import { ScrollEvent } from "../../../../../base/common/scrollable.js";
-import { ICodeEditor } from "../../../../../editor/browser/editorBrowser.js";
-import { Range } from "../../../../../editor/common/core/range.js";
-import { Selection } from "../../../../../editor/common/core/selection.js";
-import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
-import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
-import { IWorkbenchListOptionsUpdate } from "../../../../../platform/list/browser/listService.js";
-import { CellRevealRangeType, CellRevealType, ICellOutputViewModel, ICellViewModel, INotebookCellOverlayChangeAccessor, INotebookViewZoneChangeAccessor } from "../notebookBrowser.js";
-import { CellPartsCollection } from "./cellPart.js";
-import { CellViewModel, NotebookViewModel } from "../viewModel/notebookViewModelImpl.js";
-import { ICellRange } from "../../common/notebookRange.js";
-export interface INotebookCellList extends ICoordinatesConverter {
-    isDisposed: boolean;
-    inRenderingTransaction: boolean;
-    viewModel: NotebookViewModel | null;
-    webviewElement: FastDomNode<HTMLElement> | null;
-    readonly contextKeyService: IContextKeyService;
-    element(index: number): ICellViewModel | undefined;
-    elementAt(position: number): ICellViewModel | undefined;
-    elementHeight(element: ICellViewModel): number;
-    readonly onWillScroll: Event<ScrollEvent>;
-    readonly onDidScroll: Event<ScrollEvent>;
-    readonly onDidChangeFocus: Event<IListEvent<ICellViewModel>>;
-    readonly onDidChangeContentHeight: Event<number>;
-    readonly onDidChangeVisibleRanges: Event<void>;
-    visibleRanges: ICellRange[];
-    scrollTop: number;
-    scrollHeight: number;
-    scrollLeft: number;
-    length: number;
-    rowsContainer: HTMLElement;
-    scrollableElement: HTMLElement;
-    ariaLabel: string;
-    readonly onDidRemoveOutputs: Event<readonly ICellOutputViewModel[]>;
-    readonly onDidHideOutputs: Event<readonly ICellOutputViewModel[]>;
-    readonly onDidRemoveCellsFromView: Event<readonly ICellViewModel[]>;
-    readonly onMouseUp: Event<IListMouseEvent<CellViewModel>>;
-    readonly onMouseDown: Event<IListMouseEvent<CellViewModel>>;
-    readonly onContextMenu: Event<IListContextMenuEvent<CellViewModel>>;
-    detachViewModel(): void;
-    attachViewModel(viewModel: NotebookViewModel): void;
-    attachWebview(element: HTMLElement): void;
-    clear(): void;
-    focusElement(element: ICellViewModel): void;
-    selectElements(elements: ICellViewModel[]): void;
-    getFocusedElements(): ICellViewModel[];
-    getSelectedElements(): ICellViewModel[];
-    scrollToBottom(): void;
-    revealCell(cell: ICellViewModel, revealType: CellRevealType): Promise<void>;
-    revealCells(range: ICellRange): void;
-    revealRangeInCell(cell: ICellViewModel, range: Selection | Range, revealType: CellRevealRangeType): Promise<void>;
-    revealCellOffsetInCenter(element: ICellViewModel, offset: number): void;
-    revealOffsetInCenterIfOutsideViewport(offset: number): void;
-    setHiddenAreas(_ranges: ICellRange[], triggerViewUpdate: boolean): boolean;
-    changeViewZones(callback: (accessor: INotebookViewZoneChangeAccessor) => void): void;
-    changeCellOverlays(callback: (accessor: INotebookCellOverlayChangeAccessor) => void): void;
-    getViewZoneLayoutInfo(viewZoneId: string): {
-        height: number;
-        top: number;
-    } | null;
-    domElementOfElement(element: ICellViewModel): HTMLElement | null;
-    focusView(): void;
-    triggerScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
-    updateElementHeight2(element: ICellViewModel, size: number, anchorElementIndex?: number | null): void;
-    domFocus(): void;
-    focusContainer(clearSelection: boolean): void;
-    setCellEditorSelection(element: ICellViewModel, range: Range): void;
-    style(styles: IListStyles): void;
-    getRenderHeight(): number;
-    getScrollHeight(): number;
-    updateOptions(options: IWorkbenchListOptionsUpdate): void;
-    layout(height?: number, width?: number): void;
-    dispose(): void;
-}
-export interface BaseCellRenderTemplate {
-    readonly rootContainer: HTMLElement;
-    readonly editorPart: HTMLElement;
-    readonly cellInputCollapsedContainer: HTMLElement;
-    readonly instantiationService: IInstantiationService;
-    readonly container: HTMLElement;
-    readonly cellContainer: HTMLElement;
-    readonly templateDisposables: DisposableStore;
-    readonly elementDisposables: DisposableStore;
-    currentRenderedCell?: ICellViewModel;
-    cellParts: CellPartsCollection;
-    toJSON: () => object;
-}
-export interface MarkdownCellRenderTemplate extends BaseCellRenderTemplate {
-    readonly editorContainer: HTMLElement;
-    readonly foldingIndicator: HTMLElement;
-    currentEditor?: ICodeEditor;
-}
-export interface CodeCellRenderTemplate extends BaseCellRenderTemplate {
-    outputContainer: FastDomNode<HTMLElement>;
-    cellOutputCollapsedContainer: HTMLElement;
-    outputShowMoreContainer: FastDomNode<HTMLElement>;
-    focusSinkElement: HTMLElement;
-    editor: ICodeEditor;
-}
-export interface ICoordinatesConverter {
-    getCellViewScrollTop(cell: ICellViewModel): number;
-    getCellViewScrollBottom(cell: ICellViewModel): number;
-    getViewIndex(cell: ICellViewModel): number | undefined;
-    getViewIndex2(modelIndex: number): number | undefined;
-    getModelIndex(cell: CellViewModel): number | undefined;
-    getModelIndex2(viewIndex: number): number | undefined;
-    getVisibleRangesPlusViewportAboveAndBelow(): ICellRange[];
-    modelIndexIsVisible(modelIndex: number): boolean;
-    convertModelIndexToViewIndex(modelIndex: number): number;
-}
-export declare const collapsedCellTTPolicy: Pick<TrustedTypePolicy, "createHTML" | "name"> | undefined;

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

@@ -1,6 +0,0 @@
-
-import { createTrustedTypesPolicy } from '../../../../../base/browser/trustedTypes.js';
-
-const collapsedCellTTPolicy = createTrustedTypesPolicy('collapsedCellPreview', { createHTML: value => value });
-
-export { collapsedCellTTPolicy };