@codingame/monaco-vscode-api 13.1.6 → 14.0.0

package/vscode/src/vs/editor/browser/observableCodeEditor.js

@@ -9,8 +9,11 @@ import '../../base/common/cancellation.js';
 import '../../base/common/event.js';
 import { observableFromEvent, observableSignal } from '../../base/common/observableInternal/utils.js';
 import { EditorOption } from '../common/config/editorOptions.js';
+import { OffsetRange } from '../common/core/offsetRange.js';
 import { Position } from '../common/core/position.js';
 import { Selection } from '../common/core/selection.js';
+import { ContentWidgetPositionPreference } from './editorBrowser.js';
+import { Point } from './point.js';
 
 function observableCodeEditor(editor) {
     return ObservableCodeEditor.get(editor);
@@ -108,13 +111,15 @@ class ObservableCodeEditor extends Disposable {
         this.cursorPosition = derivedOpts({ owner: this, equalsFn: Position.equals }, reader => this.selections.read(reader)?.[0]?.getPosition() ?? null);
         this.cursorLineNumber = derived(this, reader => this.cursorPosition.read(reader)?.lineNumber ?? null);
         this.onDidType = observableSignal(this);
+        this.onDidPaste = observableSignal(this);
         this.scrollTop = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollTop());
         this.scrollLeft = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollLeft());
         this.layoutInfo = observableFromEvent(this.editor.onDidLayoutChange, () => this.editor.getLayoutInfo());
         this.layoutInfoContentLeft = ( this.layoutInfo.map(l => l.contentLeft));
         this.layoutInfoDecorationsLeft = ( this.layoutInfo.map(l => l.decorationsLeft));
+        this.layoutInfoWidth = ( this.layoutInfo.map(l => l.width));
         this.contentWidth = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentWidth());
-        this._overlayWidgetCounter = 0;
+        this._widgetCounter = 0;
         this._register(this.editor.onBeginUpdate(() => this._beginUpdate()));
         this._register(this.editor.onEndUpdate(() => this._endUpdate()));
         this._register(this.editor.onDidChangeModel(() => {
@@ -137,6 +142,16 @@ class ObservableCodeEditor extends Disposable {
                 this._endUpdate();
             }
         }));
+        this._register(this.editor.onDidPaste((e) => {
+            this._beginUpdate();
+            try {
+                this._forceUpdate();
+                this.onDidPaste.trigger(this._currentTransaction, e);
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
         this._register(this.editor.onDidChangeModelContent(e => {
             this._beginUpdate();
             try {
@@ -204,7 +219,7 @@ class ObservableCodeEditor extends Disposable {
         return d;
     }
     createOverlayWidget(widget) {
-        const overlayWidgetId = 'observableOverlayWidget' + (this._overlayWidgetCounter++);
+        const overlayWidgetId = 'observableOverlayWidget' + (this._widgetCounter++);
         const w = {
             getDomNode: () => widget.domNode,
             getPosition: () => widget.position.get(),
@@ -223,6 +238,57 @@ class ObservableCodeEditor extends Disposable {
             this.editor.removeOverlayWidget(w);
         });
     }
+    observeLineOffsetRange(lineRange, store) {
+        const start = this.observePosition(( lineRange.map(r => ( new Position(r.startLineNumber, 1)))), store);
+        const end = this.observePosition(( lineRange.map(r => ( new Position(r.endLineNumberExclusive + 1, 1)))), store);
+        return derived(reader => {
+            start.read(reader);
+            end.read(reader);
+            const range = lineRange.read(reader);
+            const lineCount = this.model.read(reader)?.getLineCount();
+            const s = ((typeof lineCount !== 'undefined' && range.startLineNumber > lineCount
+                ? this.editor.getBottomForLineNumber(lineCount)
+                : this.editor.getTopForLineNumber(range.startLineNumber))
+                - this.scrollTop.read(reader));
+            const e = range.isEmpty ? s : (this.editor.getBottomForLineNumber(range.endLineNumberExclusive - 1) - this.scrollTop.read(reader));
+            return ( new OffsetRange(s, e));
+        });
+    }
+    observePosition(position, store) {
+        let pos = position.get();
+        const result = observableValueOpts({ owner: this, debugName: () => `topLeftOfPosition${pos?.toString()}`, equalsFn: equalsIfDefined(Point.equals) }, ( new Point(0, 0)));
+        const contentWidgetId = `observablePositionWidget` + (this._widgetCounter++);
+        const domNode = document.createElement('div');
+        const w = {
+            getDomNode: () => domNode,
+            getPosition: () => {
+                return pos ? { preference: [ContentWidgetPositionPreference.EXACT], position: position.get() } : null;
+            },
+            getId: () => contentWidgetId,
+            allowEditorOverflow: false,
+            afterRender: (position, coordinate) => {
+                const model = this._model.get();
+                if (model && pos && pos.lineNumber > model.getLineCount()) {
+                    result.set(( new Point(
+                        0,
+                        this.editor.getBottomForLineNumber(model.getLineCount()) - this.scrollTop.get()
+                    )), undefined);
+                }
+                else {
+                    result.set(coordinate ? ( new Point(coordinate.left, coordinate.top)) : null, undefined);
+                }
+            },
+        };
+        this.editor.addContentWidget(w);
+        store.add(autorun(reader => {
+            pos = position.read(reader);
+            this.editor.layoutContentWidget(w);
+        }));
+        store.add(toDisposable(() => {
+            this.editor.removeContentWidget(w);
+        }));
+        return result;
+    }
 }
 
 export { ObservableCodeEditor, observableCodeEditor };

package/vscode/src/vs/editor/browser/point.d.ts

@@ -0,0 +1,9 @@
+export declare class Point {
+    readonly x: number;
+    readonly y: number;
+    static equals(a: Point, b: Point): boolean;
+    constructor(x: number, y: number);
+    add(other: Point): Point;
+    deltaX(delta: number): Point;
+    deltaY(delta: number): Point;
+}

package/vscode/src/vs/editor/browser/point.js

@@ -0,0 +1,22 @@
+
+
+class Point {
+    static equals(a, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    add(other) {
+        return ( new Point(this.x + other.x, this.y + other.y));
+    }
+    deltaX(delta) {
+        return ( new Point(this.x + delta, this.y));
+    }
+    deltaY(delta) {
+        return ( new Point(this.x, this.y + delta));
+    }
+}
+
+export { Point };

package/vscode/src/vs/editor/browser/rect.d.ts

@@ -0,0 +1,30 @@
+import { OffsetRange } from "../common/core/offsetRange.js";
+import { Point } from "./point.js";
+export declare class Rect {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    static fromPoint(point: Point): Rect;
+    static fromLeftTopRightBottom(left: number, top: number, right: number, bottom: number): Rect;
+    static fromLeftTopWidthHeight(left: number, top: number, width: number, height: number): Rect;
+    static fromRanges(leftRight: OffsetRange, topBottom: OffsetRange): Rect;
+    static hull(rects: Rect[]): Rect;
+    readonly width: number;
+    readonly height: number;
+    constructor(left: number, top: number, right: number, bottom: number);
+    withMargin(margin: number): Rect;
+    intersectVertical(range: OffsetRange): Rect;
+    toString(): string;
+    intersect(parent: Rect): Rect | undefined;
+    union(other: Rect): Rect;
+    containsRect(other: Rect): boolean;
+    moveToBeContainedIn(parent: Rect): Rect;
+    withWidth(width: number): Rect;
+    withHeight(height: number): Rect;
+    withTop(top: number): Rect;
+    moveLeft(delta: number): Rect;
+    moveRight(delta: number): Rect;
+    moveUp(delta: number): Rect;
+    moveDown(delta: number): Rect;
+}

package/vscode/src/vs/editor/browser/rect.js

@@ -0,0 +1,131 @@
+
+import { BugIndicatingError } from '../../base/common/errors.js';
+
+class Rect {
+    static fromPoint(point) {
+        return ( new Rect(point.x, point.y, point.x, point.y));
+    }
+    static fromLeftTopRightBottom(left, top, right, bottom) {
+        return ( new Rect(left, top, right, bottom));
+    }
+    static fromLeftTopWidthHeight(left, top, width, height) {
+        return ( new Rect(left, top, left + width, top + height));
+    }
+    static fromRanges(leftRight, topBottom) {
+        return ( new Rect(
+            leftRight.start,
+            topBottom.start,
+            leftRight.endExclusive,
+            topBottom.endExclusive
+        ));
+    }
+    static hull(rects) {
+        let left = Number.MAX_SAFE_INTEGER;
+        let top = Number.MAX_SAFE_INTEGER;
+        let right = Number.MIN_SAFE_INTEGER;
+        let bottom = Number.MIN_SAFE_INTEGER;
+        for (const rect of rects) {
+            left = Math.min(left, rect.left);
+            top = Math.min(top, rect.top);
+            right = Math.max(right, rect.right);
+            bottom = Math.max(bottom, rect.bottom);
+        }
+        return ( new Rect(left, top, right, bottom));
+    }
+    constructor(left, top, right, bottom) {
+        this.left = left;
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.width = this.right - this.left;
+        this.height = this.bottom - this.top;
+        if (left > right || top > bottom) {
+            throw ( new BugIndicatingError('Invalid arguments'));
+        }
+    }
+    withMargin(margin) {
+        return ( new Rect(
+            this.left - margin,
+            this.top - margin,
+            this.right + margin,
+            this.bottom + margin
+        ));
+    }
+    intersectVertical(range) {
+        return ( new Rect(
+            this.left,
+            Math.max(this.top, range.start),
+            this.right,
+            Math.min(this.bottom, range.endExclusive)
+        ));
+    }
+    toString() {
+        return `Rect{(${this.left},${this.top}), (${this.right},${this.bottom})}`;
+    }
+    intersect(parent) {
+        const left = Math.max(this.left, parent.left);
+        const right = Math.min(this.right, parent.right);
+        const top = Math.max(this.top, parent.top);
+        const bottom = Math.min(this.bottom, parent.bottom);
+        if (left > right || top > bottom) {
+            return undefined;
+        }
+        return ( new Rect(left, top, right, bottom));
+    }
+    union(other) {
+        return ( new Rect(
+            Math.min(this.left, other.left),
+            Math.min(this.top, other.top),
+            Math.max(this.right, other.right),
+            Math.max(this.bottom, other.bottom)
+        ));
+    }
+    containsRect(other) {
+        return this.left <= other.left
+            && this.top <= other.top
+            && this.right >= other.right
+            && this.bottom >= other.bottom;
+    }
+    moveToBeContainedIn(parent) {
+        const width = this.width;
+        const height = this.height;
+        let left = this.left;
+        let top = this.top;
+        if (left < parent.left) {
+            left = parent.left;
+        }
+        else if (left + width > parent.right) {
+            left = parent.right - width;
+        }
+        if (top < parent.top) {
+            top = parent.top;
+        }
+        else if (top + height > parent.bottom) {
+            top = parent.bottom - height;
+        }
+        return ( new Rect(left, top, left + width, top + height));
+    }
+    withWidth(width) {
+        return ( new Rect(this.left, this.top, this.left + width, this.bottom));
+    }
+    withHeight(height) {
+        return ( new Rect(this.left, this.top, this.right, this.top + height));
+    }
+    withTop(top) {
+        return ( new Rect(this.left, top, this.right, this.bottom));
+    }
+    moveLeft(delta) {
+        return ( new Rect(this.left - delta, this.top, this.right - delta, this.bottom));
+    }
+    moveRight(delta) {
+        return ( new Rect(this.left + delta, this.top, this.right + delta, this.bottom));
+    }
+    moveUp(delta) {
+        return ( new Rect(this.left, this.top - delta, this.right, this.bottom - delta));
+    }
+    moveDown(delta) {
+        return ( new Rect(this.left, this.top + delta, this.right, this.bottom + delta));
+    }
+}
+
+export { Rect };

package/vscode/src/vs/editor/browser/services/editorWorkerService.d.ts

@@ -12,7 +12,7 @@ import { ILogService } from "../../../platform/log/common/log.service.js";
 import { UnicodeHighlighterOptions } from "../../common/services/unicodeTextModelHighlighter.js";
 import { ILanguageFeaturesService } from "../../common/services/languageFeatures.js";
 import { IChange } from "../../common/diff/legacyLinesDiffComputer.js";
-import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
 import { SectionHeader, FindSectionHeaderOptions } from "../../common/services/findSectionHeaders.js";
 export declare abstract class EditorWorkerService extends Disposable implements IEditorWorkerService {
     private readonly _languageConfigurationService;

package/vscode/src/vs/editor/browser/services/hoverService/hoverService.js

@@ -42,7 +42,7 @@ let HoverService = class HoverService extends Disposable {
         this._accessibilityService = _accessibilityService;
         this._currentDelayedHoverWasShown = false;
         this._managedHovers = ( new Map());
-        contextMenuService.onDidShowContextMenu(() => this.hideHover());
+        this._register(contextMenuService.onDidShowContextMenu(() => this.hideHover()));
         this._contextViewHandler = this._register(( new ContextViewHandler(this._layoutService)));
     }
     showHover(options, focus, skipLastFocusedUpdate, dontShow) {

package/vscode/src/vs/editor/browser/view/viewLayer.d.ts

@@ -45,7 +45,7 @@ export declare class VisibleLinesCollection<T extends IVisibleLine> {
     constructor(_lineFactory: ILineFactory<T>);
     private _createDomNode;
     onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean;
-    onFlushed(e: viewEvents.ViewFlushedEvent): boolean;
+    onFlushed(e: viewEvents.ViewFlushedEvent, flushDom?: boolean): boolean;
     onLinesChanged(e: viewEvents.ViewLinesChangedEvent): boolean;
     onLinesDeleted(e: viewEvents.ViewLinesDeletedEvent): boolean;
     onLinesInserted(e: viewEvents.ViewLinesInsertedEvent): boolean;

package/vscode/src/vs/editor/browser/view/viewLayer.js

@@ -168,7 +168,14 @@ class VisibleLinesCollection {
         }
         return false;
     }
-    onFlushed(e) {
+    onFlushed(e, flushDom) {
+        if (flushDom) {
+            const start = this._linesCollection.getStartLineNumber();
+            const end = this._linesCollection.getEndLineNumber();
+            for (let i = start; i <= end; i++) {
+                this._linesCollection.getLine(i).getDomNode()?.remove();
+            }
+        }
         this._linesCollection.flush();
         return true;
     }

package/vscode/src/vs/editor/browser/view.d.ts

@@ -38,6 +38,7 @@ export declare class View extends ViewEventHandler {
     private readonly _viewParts;
     private readonly _viewController;
     private _experimentalEditContextEnabled;
+    private _accessibilitySupport;
     private _editContext;
     private readonly _pointerHandler;
     private readonly _linesContent;

package/vscode/src/vs/editor/browser/view.js

@@ -51,6 +51,7 @@ import { NativeEditContext } from './controller/editContext/native/nativeEditCon
 import { RulersGpu } from './viewParts/rulersGpu/rulersGpu.js';
 import { EditContext } from './controller/editContext/native/editContextFactory.js';
 import { GpuMarkOverlay } from './viewParts/gpuMark/gpuMark.js';
+import { AccessibilitySupport } from '../../platform/accessibility/common/accessibility.js';
 
 let View = class View extends ViewEventHandler {
     constructor(ownerID, commandDelegate, configuration, colorTheme, model, userInputEvents, overflowWidgetsDomNode, _instantiationService) {
@@ -68,7 +69,8 @@ let View = class View extends ViewEventHandler {
         this._context.addEventHandler(this);
         this._viewParts = [];
         this._experimentalEditContextEnabled = this._context.configuration.options.get(EditorOption.experimentalEditContextEnabled);
-        this._editContext = this._instantiateEditContext(this._experimentalEditContextEnabled);
+        this._accessibilitySupport = this._context.configuration.options.get(EditorOption.accessibilitySupport);
+        this._editContext = this._instantiateEditContext(this._experimentalEditContextEnabled, this._accessibilitySupport);
         this._viewParts.push(this._editContext);
         this._linesContent = createFastDomNode(document.createElement('div'));
         this._linesContent.setClassName('lines-content' + ' monaco-editor-background');
@@ -166,10 +168,10 @@ let View = class View extends ViewEventHandler {
         this._applyLayout();
         this._pointerHandler = this._register(( new PointerHandler(this._context, this._viewController, this._createPointerHandlerHelper())));
     }
-    _instantiateEditContext(experimentalEditContextEnabled) {
+    _instantiateEditContext(experimentalEditContextEnabled, accessibilitySupport) {
         const domNode = getWindow(this._overflowGuardContainer.domNode);
         const isEditContextSupported = EditContext.supported(domNode);
-        if (experimentalEditContextEnabled && isEditContextSupported) {
+        if (experimentalEditContextEnabled && isEditContextSupported && accessibilitySupport !== AccessibilitySupport.Enabled) {
             return this._instantiationService.createInstance(NativeEditContext, this._ownerID, this._context, this._overflowGuardContainer, this._viewController, this._createTextAreaHandlerHelper());
         }
         else {
@@ -178,14 +180,16 @@ let View = class View extends ViewEventHandler {
     }
     _updateEditContext() {
         const experimentalEditContextEnabled = this._context.configuration.options.get(EditorOption.experimentalEditContextEnabled);
-        if (this._experimentalEditContextEnabled === experimentalEditContextEnabled) {
+        const accessibilitySupport = this._context.configuration.options.get(EditorOption.accessibilitySupport);
+        if (this._experimentalEditContextEnabled === experimentalEditContextEnabled && this._accessibilitySupport === accessibilitySupport) {
             return;
         }
         this._experimentalEditContextEnabled = experimentalEditContextEnabled;
+        this._accessibilitySupport = accessibilitySupport;
         const isEditContextFocused = this._editContext.isFocused();
         const indexOfEditContext = this._viewParts.indexOf(this._editContext);
         this._editContext.dispose();
-        this._editContext = this._instantiateEditContext(experimentalEditContextEnabled);
+        this._editContext = this._instantiateEditContext(experimentalEditContextEnabled, accessibilitySupport);
         if (isEditContextFocused) {
             this._editContext.focus();
         }

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLines.js

@@ -165,7 +165,7 @@ class ViewLines extends ViewPart {
         return true;
     }
     onFlushed(e) {
-        const shouldRender = this._visibleLines.onFlushed(e);
+        const shouldRender = this._visibleLines.onFlushed(e, this._viewLineOptions.useGpu);
         this._maxLineWidth = 0;
         return shouldRender;
     }

package/vscode/src/vs/editor/browser/viewParts/viewLinesGpu/viewLinesGpu.d.ts

@@ -26,13 +26,17 @@ export declare class ViewLinesGpu extends ViewPart implements IViewLines {
     private _atlasGpuTexture;
     private readonly _atlasGpuTextureVersions;
     private _initialized;
-    private _renderStrategy;
-    private _contentLeftObs;
+    private readonly _glyphRasterizer;
+    private readonly _renderStrategy;
+    private _rebuildBindGroup?;
     constructor(context: ViewContext, _viewGpuContext: ViewGpuContext, _instantiationService: IInstantiationService, _logService: ILogService);
     initWebgpu(): Promise<void>;
+    private _refreshRenderStrategy;
+    private _viewportMaxColumn;
     private _updateAtlasStorageBufferAndTexture;
     prepareRender(ctx: RenderingContext): void;
     render(ctx: RestrictedRenderingContext): void;
+    onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean;
     onCursorStateChanged(e: viewEvents.ViewCursorStateChangedEvent): boolean;
     onDecorationsChanged(e: viewEvents.ViewDecorationsChangedEvent): boolean;
     onFlushed(e: viewEvents.ViewFlushedEvent): boolean;
@@ -44,7 +48,7 @@ export declare class ViewLinesGpu extends ViewPart implements IViewLines {
     onScrollChanged(e: viewEvents.ViewScrollChangedEvent): boolean;
     onThemeChanged(e: viewEvents.ViewThemeChangedEvent): boolean;
     onZonesChanged(e: viewEvents.ViewZonesChangedEvent): boolean;
-    onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean;
+    private _refreshGlyphRasterizer;
     renderText(viewportData: ViewportData): void;
     private _renderText;
     linesVisibleRangesForRange(_range: Range, includeNewLines: boolean): LineVisibleRanges[] | null;