@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -2,10 +2,9 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { getActiveWindow } from '../../../../base/browser/dom.js';
 import { BugIndicatingError } from '../../../../base/common/errors.js';
-import { observableValue } from '../../../../base/common/observableInternal/base.js';
 import '../../../../base/common/arrays.js';
 import '../../../../base/common/event.js';
-import '../../../../base/common/lifecycle.js';
+import { MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 import '../../../../base/common/observableInternal/derived.js';
 import '../../../../base/common/cancellation.js';
@@ -16,7 +15,6 @@ import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
 import { TextureAtlasPage } from '../../gpu/atlas/textureAtlasPage.js';
-import { FullFileRenderStrategy } from '../../gpu/fullFileRenderStrategy.js';
 import { BindingId } from '../../gpu/gpu.js';
 import { GPULifecycle } from '../../gpu/gpuDisposable.js';
 import { quadVertices } from '../../gpu/gpuUtils.js';
@@ -26,6 +24,10 @@ import { ViewPart } from '../../view/viewPart.js';
 import { ViewLineOptions } from '../viewLines/viewLineOptions.js';
 import { CursorColumns } from '../../../common/core/cursorColumns.js';
 import { TextureAtlas } from '../../gpu/atlas/textureAtlas.js';
+import { createContentSegmenter } from '../../gpu/contentSegmenter.js';
+import { ViewportRenderStrategy } from '../../gpu/renderStrategy/viewportRenderStrategy.js';
+import { FullFileRenderStrategy } from '../../gpu/renderStrategy/fullFileRenderStrategy.js';
+import { GlyphRasterizer } from '../../gpu/raster/glyphRasterizer.js';
 
 var GlyphStorageBufferInfo;
 (function (GlyphStorageBufferInfo) {
@@ -43,7 +45,8 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
         this._logService = _logService;
         this._atlasGpuTextureVersions = [];
         this._initialized = false;
-        this._contentLeftObs = observableValue('contentLeft', 0);
+        this._glyphRasterizer = this._register(( new MutableDisposable()));
+        this._renderStrategy = this._register(( new MutableDisposable()));
         this.canvas = this._viewGpuContext.canvas.domNode;
         this._register(autorun(reader => {
             this._viewGpuContext.canvasDevicePixelDimensions.read(reader);
@@ -59,7 +62,7 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
         this.initWebgpu();
     }
     async initWebgpu() {
-        this._device = await this._viewGpuContext.device;
+        this._device = ViewGpuContext.deviceSync || (await ViewGpuContext.device);
         if (this._store.isDisposed) {
             return;
         }
@@ -68,7 +71,7 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
             this._atlasGpuTextureVersions.length = 0;
             this._atlasGpuTextureVersions[0] = 0;
             this._atlasGpuTextureVersions[1] = 0;
-            this._renderStrategy.reset();
+            this._renderStrategy.value.reset();
         }));
         const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
         this._viewGpuContext.ctx.configure({
@@ -116,7 +119,7 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
             this._register(runOnChange(this._viewGpuContext.canvasDevicePixelDimensions, ({ width, height }) => {
                 this._device.queue.writeBuffer(layoutInfoUniformBuffer, 0, updateBufferValues(width, height));
             }));
-            this._register(runOnChange(this._contentLeftObs, () => {
+            this._register(runOnChange(this._viewGpuContext.contentLeft, () => {
                 this._device.queue.writeBuffer(layoutInfoUniformBuffer, 0, updateBufferValues());
             }));
         }
@@ -140,7 +143,13 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
                 return values;
             })).object;
         }
-        this._renderStrategy = this._register(this._instantiationService.createInstance(FullFileRenderStrategy, this._context, this._viewGpuContext, this._device));
+        const fontFamily = this._context.configuration.options.get(EditorOption.fontFamily);
+        const fontSize = this._context.configuration.options.get(EditorOption.fontSize);
+        this._glyphRasterizer.value = this._register(( new GlyphRasterizer(fontSize, fontFamily, this._viewGpuContext.devicePixelRatio.get())));
+        this._register(runOnChange(this._viewGpuContext.devicePixelRatio, () => {
+            this._refreshGlyphRasterizer();
+        }));
+        this._renderStrategy.value = this._instantiationService.createInstance(FullFileRenderStrategy, this._context, this._viewGpuContext, this._device, this._glyphRasterizer);
         this._glyphStorageBuffer = this._register(GPULifecycle.createBuffer(this._device, {
             label: 'Monaco glyph storage buffer',
             size: TextureAtlas.maximumPageCount * (TextureAtlasPage.maximumGlyphCount * GlyphStorageBufferInfo.BytesPerEntry),
@@ -165,7 +174,7 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
         }, quadVertices)).object;
         const module = this._device.createShaderModule({
             label: 'Monaco shader module',
-            code: this._renderStrategy.wgsl,
+            code: this._renderStrategy.value.wgsl,
         });
         this._pipeline = this._device.createRenderPipeline({
             label: 'Monaco render pipeline',
@@ -200,24 +209,27 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
                 ],
             },
         });
-        this._bindGroup = this._device.createBindGroup({
-            label: 'Monaco bind group',
-            layout: this._pipeline.getBindGroupLayout(0),
-            entries: [
-                { binding: BindingId.GlyphInfo, resource: { buffer: this._glyphStorageBuffer } },
-                {
-                    binding: BindingId.TextureSampler, resource: this._device.createSampler({
-                        label: 'Monaco atlas sampler',
-                        magFilter: 'nearest',
-                        minFilter: 'nearest',
-                    })
-                },
-                { binding: BindingId.Texture, resource: this._atlasGpuTexture.createView() },
-                { binding: BindingId.LayoutInfoUniform, resource: { buffer: layoutInfoUniformBuffer } },
-                { binding: BindingId.AtlasDimensionsUniform, resource: { buffer: atlasInfoUniformBuffer } },
-                ...this._renderStrategy.bindGroupEntries
-            ],
-        });
+        this._rebuildBindGroup = () => {
+            this._bindGroup = this._device.createBindGroup({
+                label: 'Monaco bind group',
+                layout: this._pipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: BindingId.GlyphInfo, resource: { buffer: this._glyphStorageBuffer } },
+                    {
+                        binding: BindingId.TextureSampler, resource: this._device.createSampler({
+                            label: 'Monaco atlas sampler',
+                            magFilter: 'nearest',
+                            minFilter: 'nearest',
+                        })
+                    },
+                    { binding: BindingId.Texture, resource: this._atlasGpuTexture.createView() },
+                    { binding: BindingId.LayoutInfoUniform, resource: { buffer: layoutInfoUniformBuffer } },
+                    { binding: BindingId.AtlasDimensionsUniform, resource: { buffer: atlasInfoUniformBuffer } },
+                    ...this._renderStrategy.value.bindGroupEntries
+                ],
+            });
+        };
+        this._rebuildBindGroup();
         this._initialized = true;
         if (this._initViewportData) {
             for (const viewportData of this._initViewportData) {
@@ -226,6 +238,28 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
             this._initViewportData = undefined;
         }
     }
+    _refreshRenderStrategy(viewportData) {
+        if (this._renderStrategy.value?.type === 'viewport') {
+            return;
+        }
+        if (viewportData.endLineNumber < FullFileRenderStrategy.maxSupportedLines && this._viewportMaxColumn(viewportData) < FullFileRenderStrategy.maxSupportedColumns) {
+            return;
+        }
+        this._logService.trace(`File is larger than ${FullFileRenderStrategy.maxSupportedLines} lines or ${FullFileRenderStrategy.maxSupportedColumns} columns, switching to viewport render strategy`);
+        const viewportRenderStrategy = this._instantiationService.createInstance(ViewportRenderStrategy, this._context, this._viewGpuContext, this._device, this._glyphRasterizer);
+        this._renderStrategy.value = viewportRenderStrategy;
+        this._register(viewportRenderStrategy.onDidChangeBindGroupEntries(() => this._rebuildBindGroup?.()));
+        this._rebuildBindGroup?.();
+    }
+    _viewportMaxColumn(viewportData) {
+        let maxColumn = 0;
+        let lineData;
+        for (let i = viewportData.startLineNumber; i <= viewportData.endLineNumber; i++) {
+            lineData = viewportData.getViewLineRenderingData(i);
+            maxColumn = Math.max(maxColumn, lineData.maxColumn);
+        }
+        return maxColumn;
+    }
     _updateAtlasStorageBufferAndTexture() {
         for (const [layerIndex, page] of ViewGpuContext.atlas.pages.entries()) {
             if (layerIndex >= TextureAtlas.maximumPageCount) {
@@ -276,6 +310,10 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
     render(ctx) {
         throw ( new BugIndicatingError('Should not be called'));
     }
+    onConfigurationChanged(e) {
+        this._refreshGlyphRasterizer();
+        return true;
+    }
     onCursorStateChanged(e) { return true; }
     onDecorationsChanged(e) { return true; }
     onFlushed(e) { return true; }
@@ -287,12 +325,23 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
     onScrollChanged(e) { return true; }
     onThemeChanged(e) { return true; }
     onZonesChanged(e) { return true; }
-    onConfigurationChanged(e) {
-        this._contentLeftObs.set(this._context.configuration.options.get(EditorOption.layoutInfo).contentLeft, undefined);
-        return true;
+    _refreshGlyphRasterizer() {
+        const glyphRasterizer = this._glyphRasterizer.value;
+        if (!glyphRasterizer) {
+            return;
+        }
+        const fontFamily = this._context.configuration.options.get(EditorOption.fontFamily);
+        const fontSize = this._context.configuration.options.get(EditorOption.fontSize);
+        const devicePixelRatio = this._viewGpuContext.devicePixelRatio.get();
+        if (glyphRasterizer.fontFamily !== fontFamily ||
+            glyphRasterizer.fontSize !== fontSize ||
+            glyphRasterizer.devicePixelRatio !== devicePixelRatio) {
+            this._glyphRasterizer.value = ( new GlyphRasterizer(fontSize, fontFamily, devicePixelRatio));
+        }
     }
     renderText(viewportData) {
         if (this._initialized) {
+            this._refreshRenderStrategy(viewportData);
             return this._renderText(viewportData);
         }
         else {
@@ -303,22 +352,17 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
     _renderText(viewportData) {
         this._viewGpuContext.rectangleRenderer.draw(viewportData);
         const options = ( new ViewLineOptions(this._context.configuration, this._context.theme.type));
-        const visibleObjectCount = this._renderStrategy.update(viewportData, options);
+        this._renderStrategy.value.update(viewportData, options);
         this._updateAtlasStorageBufferAndTexture();
         const encoder = this._device.createCommandEncoder({ label: 'Monaco command encoder' });
         this._renderPassColorAttachment.view = this._viewGpuContext.ctx.getCurrentTexture().createView({ label: 'Monaco canvas texture view' });
         const pass = encoder.beginRenderPass(this._renderPassDescriptor);
         pass.setPipeline(this._pipeline);
         pass.setVertexBuffer(0, this._vertexBuffer);
-        const contentLeft = Math.ceil(this._contentLeftObs.get() * this._viewGpuContext.devicePixelRatio.get());
+        const contentLeft = Math.ceil(this._viewGpuContext.contentLeft.get() * this._viewGpuContext.devicePixelRatio.get());
         pass.setScissorRect(contentLeft, 0, this.canvas.width - contentLeft, this.canvas.height);
         pass.setBindGroup(0, this._bindGroup);
-        if (this._renderStrategy?.draw) {
-            this._renderStrategy.draw(pass, viewportData);
-        }
-        else {
-            pass.draw(quadVertices.length / 2, visibleObjectCount);
-        }
+        this._renderStrategy.value.draw(pass, viewportData);
         pass.end();
         const commandBuffer = encoder.finish();
         this._device.queue.submit([commandBuffer]);
@@ -387,9 +431,25 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
         }
         const lineData = viewportData.getViewLineRenderingData(lineNumber);
         const content = lineData.content;
+        let contentSegmenter;
+        if (!(lineData.isBasicASCII && viewLineOptions.useMonospaceOptimizations)) {
+            contentSegmenter = createContentSegmenter(lineData, viewLineOptions);
+        }
+        let chars = '';
         let resolvedStartColumn = 0;
+        let resolvedStartCssPixelOffset = 0;
         for (let x = 0; x < startColumn - 1; x++) {
-            if (content[x] === '\t') {
+            if (lineData.isBasicASCII && viewLineOptions.useMonospaceOptimizations) {
+                chars = content.charAt(x);
+            }
+            else {
+                chars = contentSegmenter.getSegmentAtIndex(x);
+                if (chars === undefined) {
+                    continue;
+                }
+                resolvedStartCssPixelOffset += (this._renderStrategy.value.glyphRasterizer.getTextMetrics(chars).width / getActiveWindow().devicePixelRatio) - viewLineOptions.spaceWidth;
+            }
+            if (chars === '\t') {
                 resolvedStartColumn = CursorColumns.nextRenderTabStop(resolvedStartColumn, lineData.tabSize);
             }
             else {
@@ -397,8 +457,19 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
             }
         }
         let resolvedEndColumn = resolvedStartColumn;
+        let resolvedEndCssPixelOffset = 0;
         for (let x = startColumn - 1; x < endColumn - 1; x++) {
-            if (content[x] === '\t') {
+            if (lineData.isBasicASCII && viewLineOptions.useMonospaceOptimizations) {
+                chars = content.charAt(x);
+            }
+            else {
+                chars = contentSegmenter.getSegmentAtIndex(x);
+                if (chars === undefined) {
+                    continue;
+                }
+                resolvedEndCssPixelOffset += (this._renderStrategy.value.glyphRasterizer.getTextMetrics(chars).width / getActiveWindow().devicePixelRatio) - viewLineOptions.spaceWidth;
+            }
+            if (chars === '\t') {
                 resolvedEndColumn = CursorColumns.nextRenderTabStop(resolvedEndColumn, lineData.tabSize);
             }
             else {
@@ -406,8 +477,8 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
             }
         }
         const result = ( new VisibleRanges(false, [( new FloatHorizontalRange(
-            resolvedStartColumn * viewLineOptions.spaceWidth,
-            (resolvedEndColumn - resolvedStartColumn) * viewLineOptions.spaceWidth
+            resolvedStartColumn * viewLineOptions.spaceWidth + resolvedStartCssPixelOffset,
+            (resolvedEndColumn - resolvedStartColumn) * viewLineOptions.spaceWidth + resolvedEndCssPixelOffset
         ))
         ]));
         return result;
@@ -443,26 +514,39 @@ let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
         }
         const lineData = this._lastViewportData.getViewLineRenderingData(lineNumber);
         const content = lineData.content;
-        let visualColumnTarget = Math.round(mouseContentHorizontalOffset / this._lastViewLineOptions.spaceWidth);
-        let contentColumn = 0;
-        let contentColumnWithTabStops = 0;
-        while (visualColumnTarget > 0) {
-            let columnWithTabStopsSize = 0;
-            if (content[contentColumn] === '\t') {
-                const tabStop = CursorColumns.nextRenderTabStop(contentColumnWithTabStops, lineData.tabSize);
-                columnWithTabStopsSize = tabStop - contentColumnWithTabStops;
+        const dpr = getActiveWindow().devicePixelRatio;
+        const mouseContentHorizontalOffsetDevicePixels = mouseContentHorizontalOffset * dpr;
+        const spaceWidthDevicePixels = this._lastViewLineOptions.spaceWidth * dpr;
+        const contentSegmenter = createContentSegmenter(lineData, this._lastViewLineOptions);
+        let widthSoFar = 0;
+        let charWidth = 0;
+        let tabXOffset = 0;
+        let column = 0;
+        for (let x = 0; x < content.length; x++) {
+            const chars = contentSegmenter.getSegmentAtIndex(x);
+            if (chars === undefined) {
+                column++;
+                continue;
+            }
+            if (chars === '\t') {
+                const offsetBefore = x + tabXOffset;
+                tabXOffset = CursorColumns.nextRenderTabStop(x + tabXOffset, lineData.tabSize);
+                charWidth = spaceWidthDevicePixels * (tabXOffset - offsetBefore);
+                tabXOffset -= x + 1;
+            }
+            else if (lineData.isBasicASCII && this._lastViewLineOptions.useMonospaceOptimizations) {
+                charWidth = spaceWidthDevicePixels;
             }
             else {
-                columnWithTabStopsSize = 1;
+                charWidth = this._renderStrategy.value.glyphRasterizer.getTextMetrics(chars).width;
             }
-            if (visualColumnTarget - columnWithTabStopsSize / 2 < 0) {
+            if (mouseContentHorizontalOffsetDevicePixels < widthSoFar + charWidth / 2) {
                 break;
             }
-            visualColumnTarget -= columnWithTabStopsSize;
-            contentColumn++;
-            contentColumnWithTabStops += columnWithTabStopsSize;
+            widthSoFar += charWidth;
+            column++;
         }
-        return ( new Position(lineNumber, Math.floor(contentColumn) + 1));
+        return ( new Position(lineNumber, column + 1));
     }
 };
 ViewLinesGpu = ( __decorate([

package/vscode/src/vs/editor/browser/widget/codeEditor/codeEditorWidget.d.ts

@@ -316,6 +316,7 @@ export interface ICodeEditorWidgetOptions {
     contributions?: IEditorContributionDescription[];
     telemetryData?: object;
     contextMenuId?: MenuId;
+    contextKeyValues?: Record<string, ContextKeyValue>;
 }
 declare class ModelData {
     readonly model: ITextModel;

package/vscode/src/vs/editor/browser/widget/codeEditor/codeEditorWidget.js

@@ -188,6 +188,11 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
             }
         }));
         this._contextKeyService = this._register(contextKeyService.createScoped(this._domElement));
+        if (codeEditorWidgetOptions.contextKeyValues) {
+            for (const [key, value] of Object.entries(codeEditorWidgetOptions.contextKeyValues)) {
+                this._contextKeyService.createKey(key, value);
+            }
+        }
         this._notificationService = notificationService;
         this._codeEditorService = codeEditorService;
         this._commandService = commandService;

package/vscode/src/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget.d.ts

@@ -7,7 +7,7 @@ import { ILanguageFeaturesService } from "../../../common/services/languageFeatu
 import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
 import { ICommandService } from "../../../../platform/commands/common/commands.service.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
-import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { IInstantiationService, ServicesAccessor } from "../../../../platform/instantiation/common/instantiation.js";
 import { INotificationService } from "../../../../platform/notification/common/notification.service.js";
 import { IThemeService } from "../../../../platform/theme/common/themeService.service.js";
 export declare class EmbeddedCodeEditorWidget extends CodeEditorWidget {
@@ -18,3 +18,4 @@ export declare class EmbeddedCodeEditorWidget extends CodeEditorWidget {
     private _onParentConfigurationChanged;
     updateOptions(newOptions: IEditorOptions): void;
 }
+export declare function getOuterEditor(accessor: ServicesAccessor): ICodeEditor | null;

package/vscode/src/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget.js

@@ -43,5 +43,12 @@ EmbeddedCodeEditorWidget = ( __decorate([
     ( __param(11, ILanguageConfigurationService)),
     ( __param(12, ILanguageFeaturesService))
 ], EmbeddedCodeEditorWidget));
+function getOuterEditor(accessor) {
+    const editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+    if (editor instanceof EmbeddedCodeEditorWidget) {
+        return editor.getParentEditor();
+    }
+    return editor;
+}
 
-export { EmbeddedCodeEditorWidget };
+export { EmbeddedCodeEditorWidget, getOuterEditor };

package/vscode/src/vs/editor/browser/widget/diffEditor/commands.d.ts

@@ -49,3 +49,4 @@ export declare class AccessibleDiffViewerPrev extends Action2 {
 }
 export declare function findDiffEditor(accessor: ServicesAccessor, originalUri: URI, modifiedUri: URI): IDiffEditor | null;
 export declare function findFocusedDiffEditor(accessor: ServicesAccessor): IDiffEditor | null;
+export declare function findDiffEditorContainingCodeEditor(accessor: ServicesAccessor, editor: ICodeEditor): IDiffEditor | null;

package/vscode/src/vs/editor/browser/widget/diffEditor/commands.js

@@ -12,6 +12,7 @@ import { IConfigurationService } from '../../../../platform/configuration/common
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import './registrations.contribution.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 
 class ToggleCollapseUnchangedRegions extends Action2 {
     constructor() {
@@ -221,22 +222,26 @@ function findFocusedDiffEditor(accessor) {
     if (activeElement) {
         for (const d of diffEditors) {
             const container = d.getContainerDomNode();
-            if (isElementOrParentOf(container, activeElement)) {
+            if (container.contains(activeElement)) {
                 return d;
             }
         }
     }
     return null;
 }
-function isElementOrParentOf(elementOrParent, element) {
-    let e = element;
-    while (e) {
-        if (e === elementOrParent) {
-            return true;
+function findDiffEditorContainingCodeEditor(accessor, editor) {
+    if (!editor.getOption(EditorOption.inDiffEditor)) {
+        return null;
+    }
+    const codeEditorService = accessor.get(ICodeEditorService);
+    for (const diffEditor of codeEditorService.listDiffEditors()) {
+        const originalEditor = diffEditor.getOriginalEditor();
+        const modifiedEditor = diffEditor.getModifiedEditor();
+        if (originalEditor === editor || modifiedEditor === editor) {
+            return diffEditor;
         }
-        e = e.parentElement;
     }
-    return false;
+    return null;
 }
 
-export { AccessibleDiffViewerNext, AccessibleDiffViewerPrev, CollapseAllUnchangedRegions, ExitCompareMove, RevertHunkOrSelection, ShowAllUnchangedRegions, SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks, ToggleUseInlineViewWhenSpaceIsLimited, findDiffEditor, findFocusedDiffEditor };
+export { AccessibleDiffViewerNext, AccessibleDiffViewerPrev, CollapseAllUnchangedRegions, ExitCompareMove, RevertHunkOrSelection, ShowAllUnchangedRegions, SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks, ToggleUseInlineViewWhenSpaceIsLimited, findDiffEditor, findDiffEditorContainingCodeEditor, findFocusedDiffEditor };

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorEditors.d.ts

@@ -7,30 +7,32 @@ import { IContentSizeChangedEvent } from "../../../../common/editorCommon.js";
 import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
 import { IKeybindingService } from "../../../../../platform/keybinding/common/keybinding.service.js";
 import { DiffEditorOptions } from "../diffEditorOptions.js";
+import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
 export declare class DiffEditorEditors extends Disposable {
     private readonly originalEditorElement;
     private readonly modifiedEditorElement;
     private readonly _options;
     private _argCodeEditorWidgetOptions;
     private readonly _createInnerEditor;
+    private readonly _contextKeyService;
     private readonly _instantiationService;
     private readonly _keybindingService;
     readonly original: CodeEditorWidget;
     readonly modified: CodeEditorWidget;
     private readonly _onDidContentSizeChange;
     get onDidContentSizeChange(): import("../../../../../base/common/event.js").Event<IContentSizeChangedEvent>;
-    readonly modifiedScrollTop: import("../../../../../base/common/observable.js").IObservable<number, unknown>;
-    readonly modifiedScrollHeight: import("../../../../../base/common/observable.js").IObservable<number, unknown>;
+    readonly modifiedScrollTop: import("../../../../../base/common/observable.js").IObservable<number>;
+    readonly modifiedScrollHeight: import("../../../../../base/common/observable.js").IObservable<number>;
     readonly modifiedObs: import("../../../observableCodeEditor.js").ObservableCodeEditor;
     readonly originalObs: import("../../../observableCodeEditor.js").ObservableCodeEditor;
-    readonly modifiedModel: import("../../../../../base/common/observable.js").IObservable<import("../../../../common/model.js").ITextModel | null, unknown>;
-    readonly modifiedSelections: import("../../../../../base/common/observable.js").IObservable<import("../../../../common/core/selection.js").Selection[], unknown>;
-    readonly modifiedCursor: import("../../../../../base/common/observable.js").IObservable<Position, unknown>;
-    readonly originalCursor: import("../../../../../base/common/observable.js").IObservable<Position, unknown>;
-    readonly isOriginalFocused: import("../../../../../base/common/observable.js").IObservable<boolean, unknown>;
-    readonly isModifiedFocused: import("../../../../../base/common/observable.js").IObservable<boolean, unknown>;
-    readonly isFocused: import("../../../../../base/common/observable.js").IObservable<boolean, unknown>;
-    constructor(originalEditorElement: HTMLElement, modifiedEditorElement: HTMLElement, _options: DiffEditorOptions, _argCodeEditorWidgetOptions: IDiffCodeEditorWidgetOptions, _createInnerEditor: (instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<IEditorOptions>, editorWidgetOptions: ICodeEditorWidgetOptions) => CodeEditorWidget, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService);
+    readonly modifiedModel: import("../../../../../base/common/observable.js").IObservable<import("../../../../common/model.js").ITextModel | null>;
+    readonly modifiedSelections: import("../../../../../base/common/observable.js").IObservable<import("../../../../common/core/selection.js").Selection[]>;
+    readonly modifiedCursor: import("../../../../../base/common/observable.js").IObservable<Position>;
+    readonly originalCursor: import("../../../../../base/common/observable.js").IObservable<Position>;
+    readonly isOriginalFocused: import("../../../../../base/common/observable.js").IObservable<boolean>;
+    readonly isModifiedFocused: import("../../../../../base/common/observable.js").IObservable<boolean>;
+    readonly isFocused: import("../../../../../base/common/observable.js").IObservable<boolean>;
+    constructor(originalEditorElement: HTMLElement, modifiedEditorElement: HTMLElement, _options: DiffEditorOptions, _argCodeEditorWidgetOptions: IDiffCodeEditorWidgetOptions, _createInnerEditor: (instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<IEditorOptions>, editorWidgetOptions: ICodeEditorWidgetOptions) => CodeEditorWidget, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService);
     private _createLeftHandSideEditor;
     private _createRightHandSideEditor;
     private _constructInnerEditor;

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorEditors.js

@@ -14,16 +14,18 @@ import { Position } from '../../../../common/core/position.js';
 import { localize } from '../../../../../nls.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 
 let DiffEditorEditors = class DiffEditorEditors extends Disposable {
     get onDidContentSizeChange() { return this._onDidContentSizeChange.event; }
-    constructor(originalEditorElement, modifiedEditorElement, _options, _argCodeEditorWidgetOptions, _createInnerEditor, _instantiationService, _keybindingService) {
+    constructor(originalEditorElement, modifiedEditorElement, _options, _argCodeEditorWidgetOptions, _createInnerEditor, _contextKeyService, _instantiationService, _keybindingService) {
         super();
         this.originalEditorElement = originalEditorElement;
         this.modifiedEditorElement = modifiedEditorElement;
         this._options = _options;
         this._argCodeEditorWidgetOptions = _argCodeEditorWidgetOptions;
         this._createInnerEditor = _createInnerEditor;
+        this._contextKeyService = _contextKeyService;
         this._instantiationService = _instantiationService;
         this._keybindingService = _keybindingService;
         this.original = this._register(this._createLeftHandSideEditor(this._options.editorOptions.get(), this._argCodeEditorWidgetOptions.originalEditor || {}));
@@ -59,13 +61,17 @@ let DiffEditorEditors = class DiffEditorEditors extends Disposable {
     _createLeftHandSideEditor(options, codeEditorWidgetOptions) {
         const leftHandSideOptions = this._adjustOptionsForLeftHandSide(undefined, options);
         const editor = this._constructInnerEditor(this._instantiationService, this.originalEditorElement, leftHandSideOptions, codeEditorWidgetOptions);
-        editor.setContextValue('isInDiffLeftEditor', true);
+        const isInDiffLeftEditorKey = this._contextKeyService.createKey('isInDiffLeftEditor', editor.hasWidgetFocus());
+        this._register(editor.onDidFocusEditorWidget(() => isInDiffLeftEditorKey.set(true)));
+        this._register(editor.onDidBlurEditorWidget(() => isInDiffLeftEditorKey.set(false)));
         return editor;
     }
     _createRightHandSideEditor(options, codeEditorWidgetOptions) {
         const rightHandSideOptions = this._adjustOptionsForRightHandSide(undefined, options);
         const editor = this._constructInnerEditor(this._instantiationService, this.modifiedEditorElement, rightHandSideOptions, codeEditorWidgetOptions);
-        editor.setContextValue('isInDiffRightEditor', true);
+        const isInDiffRightEditorKey = this._contextKeyService.createKey('isInDiffRightEditor', editor.hasWidgetFocus());
+        this._register(editor.onDidFocusEditorWidget(() => isInDiffRightEditorKey.set(true)));
+        this._register(editor.onDidBlurEditorWidget(() => isInDiffRightEditorKey.set(false)));
         return editor;
     }
     _constructInnerEditor(instantiationService, container, options, editorWidgetOptions) {
@@ -159,8 +165,9 @@ let DiffEditorEditors = class DiffEditorEditors extends Disposable {
     }
 };
 DiffEditorEditors = ( __decorate([
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IKeybindingService))
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IKeybindingService))
 ], DiffEditorEditors));
 
 export { DiffEditorEditors };

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorSash.d.ts

@@ -29,5 +29,5 @@ export declare class DiffEditorSash extends Disposable {
     constructor(_domNode: HTMLElement, _dimensions: {
         height: IObservable<number>;
         width: IObservable<number>;
-    }, _enabled: IObservable<boolean>, _boundarySashes: IObservable<IBoundarySashes | undefined, void>, sashLeft: ISettableObservable<number>, _resetSash: () => void);
+    }, _enabled: IObservable<boolean>, _boundarySashes: IObservable<IBoundarySashes | undefined>, sashLeft: ISettableObservable<number>, _resetSash: () => void);
 }

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.d.ts

@@ -4,7 +4,7 @@ import { FontInfo } from "../../../../../common/config/fontInfo.js";
 import { ModelLineProjectionData } from "../../../../../common/modelLineProjectionData.js";
 import { LineTokens } from "../../../../../common/tokens/lineTokens.js";
 import { InlineDecoration } from "../../../../../common/viewModel.js";
-export declare function renderLines(source: LineSource, options: RenderOptions, decorations: InlineDecoration[], domNode: HTMLElement): RenderLinesResult;
+export declare function renderLines(source: LineSource, options: RenderOptions, decorations: InlineDecoration[], domNode: HTMLElement, noExtra?: boolean): RenderLinesResult;
 export declare class LineSource {
     readonly lineTokens: LineTokens[];
     readonly lineBreakData: (ModelLineProjectionData | null)[];
@@ -24,8 +24,10 @@ export declare class RenderOptions {
     readonly renderWhitespace: FindComputedEditorOptionValueById<EditorOption.renderWhitespace>;
     readonly renderControlCharacters: boolean;
     readonly fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>;
+    readonly setWidth: boolean;
     static fromEditor(editor: ICodeEditor): RenderOptions;
-    constructor(tabSize: number, fontInfo: FontInfo, disableMonospaceOptimizations: boolean, typicalHalfwidthCharacterWidth: number, scrollBeyondLastColumn: number, lineHeight: number, lineDecorationsWidth: number, stopRenderingLineAfter: number, renderWhitespace: FindComputedEditorOptionValueById<EditorOption.renderWhitespace>, renderControlCharacters: boolean, fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>);
+    constructor(tabSize: number, fontInfo: FontInfo, disableMonospaceOptimizations: boolean, typicalHalfwidthCharacterWidth: number, scrollBeyondLastColumn: number, lineHeight: number, lineDecorationsWidth: number, stopRenderingLineAfter: number, renderWhitespace: FindComputedEditorOptionValueById<EditorOption.renderWhitespace>, renderControlCharacters: boolean, fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>, setWidth?: boolean);
+    withSetWidth(setWidth: boolean): RenderOptions;
 }
 export interface RenderLinesResult {
     minWidthInPx: number;