@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -1,33 +1,4 @@
 import { EditorType } from '../common/editorCommon.js';
-var ContentWidgetPositionPreference;
-( (function(ContentWidgetPositionPreference) {
-    ContentWidgetPositionPreference[ContentWidgetPositionPreference["EXACT"] = 0] = "EXACT";
-    ContentWidgetPositionPreference[ContentWidgetPositionPreference["ABOVE"] = 1] = "ABOVE";
-    ContentWidgetPositionPreference[ContentWidgetPositionPreference["BELOW"] = 2] = "BELOW";
-})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {})));
-var OverlayWidgetPositionPreference;
-( (function(OverlayWidgetPositionPreference) {
-    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_RIGHT_CORNER"] = 0] = "TOP_RIGHT_CORNER";
-    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["BOTTOM_RIGHT_CORNER"] = 1] = "BOTTOM_RIGHT_CORNER";
-    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_CENTER"] = 2] = "TOP_CENTER";
-})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {})));
-var MouseTargetType;
-( (function(MouseTargetType) {
-    MouseTargetType[MouseTargetType["UNKNOWN"] = 0] = "UNKNOWN";
-    MouseTargetType[MouseTargetType["TEXTAREA"] = 1] = "TEXTAREA";
-    MouseTargetType[MouseTargetType["GUTTER_GLYPH_MARGIN"] = 2] = "GUTTER_GLYPH_MARGIN";
-    MouseTargetType[MouseTargetType["GUTTER_LINE_NUMBERS"] = 3] = "GUTTER_LINE_NUMBERS";
-    MouseTargetType[MouseTargetType["GUTTER_LINE_DECORATIONS"] = 4] = "GUTTER_LINE_DECORATIONS";
-    MouseTargetType[MouseTargetType["GUTTER_VIEW_ZONE"] = 5] = "GUTTER_VIEW_ZONE";
-    MouseTargetType[MouseTargetType["CONTENT_TEXT"] = 6] = "CONTENT_TEXT";
-    MouseTargetType[MouseTargetType["CONTENT_EMPTY"] = 7] = "CONTENT_EMPTY";
-    MouseTargetType[MouseTargetType["CONTENT_VIEW_ZONE"] = 8] = "CONTENT_VIEW_ZONE";
-    MouseTargetType[MouseTargetType["CONTENT_WIDGET"] = 9] = "CONTENT_WIDGET";
-    MouseTargetType[MouseTargetType["OVERVIEW_RULER"] = 10] = "OVERVIEW_RULER";
-    MouseTargetType[MouseTargetType["SCROLLBAR"] = 11] = "SCROLLBAR";
-    MouseTargetType[MouseTargetType["OVERLAY_WIDGET"] = 12] = "OVERLAY_WIDGET";
-    MouseTargetType[MouseTargetType["OUTSIDE_EDITOR"] = 13] = "OUTSIDE_EDITOR";
-})(MouseTargetType || (MouseTargetType = {})));
 function isCodeEditor(thing) {
     if (thing && typeof thing.getEditorType === 'function') {
         return thing.getEditorType() === EditorType.ICodeEditor;
@@ -67,4 +38,4 @@ function getIEditor(thing) {
     }
     return null;
 }
-export { ContentWidgetPositionPreference, MouseTargetType, OverlayWidgetPositionPreference, getCodeEditor, getIEditor, isCodeEditor, isCompositeEditor, isDiffEditor };
+export { getCodeEditor, getIEditor, isCodeEditor, isCompositeEditor, isDiffEditor };

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

@@ -9,11 +9,10 @@ import { CommandsRegistry } from '../../platform/commands/common/commands.js';
 import { ContextKeyExpr } from '../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../platform/contextkey/common/contextkey.service.js';
 import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
-import { KeybindingWeight, KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
+import { KeybindingsRegistry } from '../../platform/keybinding/common/keybindingsRegistry.js';
 import { Registry } from '../../platform/registry/common/platform.js';
 import { ITelemetryService } from '../../platform/telemetry/common/telemetry.service.js';
 import { assertType } from '../../base/common/types.js';
-import { KeyMod as KeyMod$1, KeyCode } from '../../base/common/keyCodes.js';
 import { ILogService } from '../../platform/log/common/log.service.js';
 import { getActiveElement } from '../../base/browser/dom.js';
 var EditorContributionInstantiation;
@@ -382,18 +381,18 @@ const UndoCommand = registerCommand(( (new MultiCommand({
     id: 'undo',
     precondition: undefined,
     kbOpts: {
-        weight: KeybindingWeight.EditorCore,
-        primary: KeyMod$1.CtrlCmd | KeyCode.KeyZ
+        weight: 0 ,
+        primary: 2048  | 56
     },
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(561, "&&Undo")),
+            title: ( localize(565, "&&Undo")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(562, "Undo")),
+            title: ( localize(566, "Undo")),
             order: 1
         }]
 }))));
@@ -402,20 +401,20 @@ const RedoCommand = registerCommand(( (new MultiCommand({
     id: 'redo',
     precondition: undefined,
     kbOpts: {
-        weight: KeybindingWeight.EditorCore,
-        primary: KeyMod$1.CtrlCmd | KeyCode.KeyY,
-        secondary: [KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.KeyZ],
-        mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.KeyZ }
+        weight: 0 ,
+        primary: 2048  | 55 ,
+        secondary: [2048  | 1024  | 56 ],
+        mac: { primary: 2048  | 1024  | 56  }
     },
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(563, "&&Redo")),
+            title: ( localize(567, "&&Redo")),
             order: 2
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(564, "Redo")),
+            title: ( localize(568, "Redo")),
             order: 1
         }]
 }))));
@@ -424,19 +423,19 @@ const SelectAllCommand = registerCommand(( (new MultiCommand({
     id: 'editor.action.selectAll',
     precondition: undefined,
     kbOpts: {
-        weight: KeybindingWeight.EditorCore,
+        weight: 0 ,
         kbExpr: null,
-        primary: KeyMod$1.CtrlCmd | KeyCode.KeyA
+        primary: 2048  | 31
     },
     menuOpts: [{
             menuId: MenuId.MenubarSelectionMenu,
             group: '1_basic',
-            title: ( localize(565, "&&Select All")),
+            title: ( localize(569, "&&Select All")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(566, "Select All")),
+            title: ( localize(570, "Select All")),
             order: 1
         }]
 }))));

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.js

@@ -0,0 +1,109 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable, toDisposable, dispose } from '../../../../base/common/lifecycle.js';
+import { ThreeKeyMap } from '../../../../base/common/map.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { GlyphRasterizer } from '../raster/glyphRasterizer.js';
+import { IdleTaskQueue } from '../taskQueue.js';
+import { TextureAtlasPage } from './textureAtlasPage.js';
+let TextureAtlas = class TextureAtlas extends Disposable {
+    get pages() { return this._pages; }
+    constructor(
+    _maxTextureSize, options, _themeService, _instantiationService) {
+        super();
+        this._maxTextureSize = _maxTextureSize;
+        this._themeService = _themeService;
+        this._instantiationService = _instantiationService;
+        this._warmUpTask = this._register(( new MutableDisposable()));
+        this._warmedUpRasterizers = ( new Set());
+        this._pages = [];
+        this._glyphPageIndex = ( new ThreeKeyMap());
+        this._onDidDeleteGlyphs = this._register(( new Emitter()));
+        this.onDidDeleteGlyphs = this._onDidDeleteGlyphs.event;
+        this._allocatorType = options?.allocatorType ?? 'slab';
+        this._register(Event.runAndSubscribe(this._themeService.onDidColorThemeChange, () => {
+            this._colorMap = this._themeService.getColorTheme().tokenColorMap;
+        }));
+        const dprFactor = Math.max(1, Math.floor(getActiveWindow().devicePixelRatio));
+        this.pageSize = Math.min(1024 * dprFactor, this._maxTextureSize);
+        this._initFirstPage();
+        this._register(toDisposable(() => dispose(this._pages)));
+    }
+    _initFirstPage() {
+        const firstPage = this._instantiationService.createInstance(TextureAtlasPage, 0, this.pageSize, this._allocatorType);
+        this._pages.push(firstPage);
+        const nullRasterizer = ( new GlyphRasterizer(1, ''));
+        firstPage.getGlyph(nullRasterizer, '', 0);
+        nullRasterizer.dispose();
+    }
+    clear() {
+        for (const page of this._pages) {
+            page.dispose();
+        }
+        this._pages.length = 0;
+        this._glyphPageIndex.clear();
+        this._warmedUpRasterizers.clear();
+        this._warmUpTask.clear();
+        this._initFirstPage();
+        this._onDidDeleteGlyphs.fire();
+    }
+    getGlyph(rasterizer, chars, metadata) {
+        metadata &= ~((255  | 768  | 1024) );
+        if (!( this._warmedUpRasterizers.has(rasterizer.id))) {
+            this._warmUpAtlas(rasterizer);
+            this._warmedUpRasterizers.add(rasterizer.id);
+        }
+        return this._tryGetGlyph(this._glyphPageIndex.get(chars, metadata, rasterizer.cacheKey) ?? 0, rasterizer, chars, metadata);
+    }
+    _tryGetGlyph(pageIndex, rasterizer, chars, metadata) {
+        this._glyphPageIndex.set(chars, metadata, rasterizer.cacheKey, pageIndex);
+        return (this._pages[pageIndex].getGlyph(rasterizer, chars, metadata)
+            ?? (pageIndex + 1 < this._pages.length
+                ? this._tryGetGlyph(pageIndex + 1, rasterizer, chars, metadata)
+                : undefined)
+            ?? this._getGlyphFromNewPage(rasterizer, chars, metadata));
+    }
+    _getGlyphFromNewPage(rasterizer, chars, metadata) {
+        this._pages.push(this._instantiationService.createInstance(TextureAtlasPage, this._pages.length, this.pageSize, this._allocatorType));
+        this._glyphPageIndex.set(chars, metadata, rasterizer.cacheKey, this._pages.length - 1);
+        return this._pages[this._pages.length - 1].getGlyph(rasterizer, chars, metadata);
+    }
+    getUsagePreview() {
+        return Promise.all(( this._pages.map(e => e.getUsagePreview())));
+    }
+    getStats() {
+        return ( this._pages.map(e => e.getStats()));
+    }
+    _warmUpAtlas(rasterizer) {
+        this._warmUpTask.value?.clear();
+        const taskQueue = this._warmUpTask.value = ( new IdleTaskQueue());
+        for (let code = 65 ; code <= 90 ; code++) {
+            taskQueue.enqueue(() => {
+                for (const fgColor of ( this._colorMap.keys())) {
+                    this.getGlyph(rasterizer, String.fromCharCode(code), ((fgColor << 15) ) & 16744448 );
+                }
+            });
+        }
+        for (let code = 97 ; code <= 122 ; code++) {
+            taskQueue.enqueue(() => {
+                for (const fgColor of ( this._colorMap.keys())) {
+                    this.getGlyph(rasterizer, String.fromCharCode(code), ((fgColor << 15) ) & 16744448 );
+                }
+            });
+        }
+        for (let code = 33 ; code <= 126 ; code++) {
+            taskQueue.enqueue(() => {
+                for (const fgColor of ( this._colorMap.keys())) {
+                    this.getGlyph(rasterizer, String.fromCharCode(code), ((fgColor << 15) ) & 16744448 );
+                }
+            });
+        }
+    }
+};
+TextureAtlas = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IInstantiationService))
+], TextureAtlas));
+export { TextureAtlas };

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasPage.js

@@ -0,0 +1,86 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { ThreeKeyMap } from '../../../../base/common/map.js';
+import { LogLevel } from '../../../../platform/log/common/log.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { TextureAtlasShelfAllocator } from './textureAtlasShelfAllocator.js';
+import { TextureAtlasSlabAllocator } from './textureAtlasSlabAllocator.js';
+var TextureAtlasPage_1;
+let TextureAtlasPage = class TextureAtlasPage extends Disposable {
+    static { TextureAtlasPage_1 = this; }
+    get version() { return this._version; }
+    static { this.maximumGlyphCount = 5_000; }
+    get usedArea() { return this._usedArea; }
+    get source() { return this._canvas; }
+    get glyphs() {
+        return ( this._glyphInOrderSet.values());
+    }
+    constructor(textureIndex, pageSize, allocatorType, _logService, _themeService) {
+        super();
+        this._logService = _logService;
+        this._themeService = _themeService;
+        this._version = 0;
+        this._usedArea = { left: 0, top: 0, right: 0, bottom: 0 };
+        this._glyphMap = ( new ThreeKeyMap());
+        this._glyphInOrderSet = ( new Set());
+        this._canvas = ( new OffscreenCanvas(pageSize, pageSize));
+        switch (allocatorType) {
+            case 'shelf':
+                this._allocator = ( new TextureAtlasShelfAllocator(this._canvas, textureIndex));
+                break;
+            case 'slab':
+                this._allocator = ( new TextureAtlasSlabAllocator(this._canvas, textureIndex));
+                break;
+            default:
+                this._allocator = allocatorType(this._canvas, textureIndex);
+                break;
+        }
+        this._register(Event.runAndSubscribe(this._themeService.onDidColorThemeChange, () => {
+            this._colorMap = this._themeService.getColorTheme().tokenColorMap;
+        }));
+        this._register(toDisposable(() => {
+            this._canvas.width = 1;
+            this._canvas.height = 1;
+        }));
+    }
+    getGlyph(rasterizer, chars, metadata) {
+        return this._glyphMap.get(chars, metadata, rasterizer.cacheKey) ?? this._createGlyph(rasterizer, chars, metadata);
+    }
+    _createGlyph(rasterizer, chars, metadata) {
+        if (this._glyphInOrderSet.size >= TextureAtlasPage_1.maximumGlyphCount) {
+            return undefined;
+        }
+        const rasterizedGlyph = rasterizer.rasterizeGlyph(chars, metadata, this._colorMap);
+        const glyph = this._allocator.allocate(rasterizedGlyph);
+        if (glyph === undefined) {
+            return undefined;
+        }
+        this._glyphMap.set(chars, metadata, rasterizer.cacheKey, glyph);
+        this._glyphInOrderSet.add(glyph);
+        this._version++;
+        this._usedArea.right = Math.max(this._usedArea.right, glyph.x + glyph.w - 1);
+        this._usedArea.bottom = Math.max(this._usedArea.bottom, glyph.y + glyph.h - 1);
+        if (this._logService.getLevel() === LogLevel.Trace) {
+            this._logService.trace('New glyph', {
+                chars,
+                metadata,
+                rasterizedGlyph,
+                glyph
+            });
+        }
+        return glyph;
+    }
+    getUsagePreview() {
+        return this._allocator.getUsagePreview();
+    }
+    getStats() {
+        return this._allocator.getStats();
+    }
+};
+TextureAtlasPage = TextureAtlasPage_1 = ( __decorate([
+    ( __param(3, ILogService)),
+    ( __param(4, IThemeService))
+], TextureAtlasPage));
+export { TextureAtlasPage };

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasShelfAllocator.js

@@ -0,0 +1,107 @@
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { ensureNonNullable } from '../gpuUtils.js';
+class TextureAtlasShelfAllocator {
+    constructor(_canvas, _textureIndex) {
+        this._canvas = _canvas;
+        this._textureIndex = _textureIndex;
+        this._currentRow = {
+            x: 0,
+            y: 0,
+            h: 0
+        };
+        this._allocatedGlyphs = ( new Set());
+        this._nextIndex = 0;
+        this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
+            willReadFrequently: true
+        }));
+    }
+    allocate(rasterizedGlyph) {
+        const glyphWidth = rasterizedGlyph.boundingBox.right - rasterizedGlyph.boundingBox.left + 1;
+        const glyphHeight = rasterizedGlyph.boundingBox.bottom - rasterizedGlyph.boundingBox.top + 1;
+        if (glyphWidth > this._canvas.width || glyphHeight > this._canvas.height) {
+            throw ( new BugIndicatingError('Glyph is too large for the atlas page'));
+        }
+        if (rasterizedGlyph.boundingBox.right - rasterizedGlyph.boundingBox.left + 1 > this._canvas.width - this._currentRow.x) {
+            this._currentRow.x = 0;
+            this._currentRow.y += this._currentRow.h;
+            this._currentRow.h = 1;
+        }
+        if (this._currentRow.y + rasterizedGlyph.boundingBox.bottom - rasterizedGlyph.boundingBox.top + 1 > this._canvas.height) {
+            return undefined;
+        }
+        this._ctx.drawImage(rasterizedGlyph.source,
+        rasterizedGlyph.boundingBox.left, rasterizedGlyph.boundingBox.top, glyphWidth, glyphHeight,
+        this._currentRow.x, this._currentRow.y, glyphWidth, glyphHeight);
+        const glyph = {
+            pageIndex: this._textureIndex,
+            glyphIndex: this._nextIndex++,
+            x: this._currentRow.x,
+            y: this._currentRow.y,
+            w: glyphWidth,
+            h: glyphHeight,
+            originOffsetX: rasterizedGlyph.originOffset.x,
+            originOffsetY: rasterizedGlyph.originOffset.y
+        };
+        this._currentRow.x += glyphWidth;
+        this._currentRow.h = Math.max(this._currentRow.h, glyphHeight);
+        this._allocatedGlyphs.add(glyph);
+        return glyph;
+    }
+    getUsagePreview() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        const canvas = ( new OffscreenCanvas(w, h));
+        const ctx = ensureNonNullable(canvas.getContext('2d'));
+        ctx.fillStyle = "#808080" ;
+        ctx.fillRect(0, 0, w, h);
+        const rowHeight = ( new Map());
+        const rowWidth = ( new Map());
+        for (const g of this._allocatedGlyphs) {
+            rowHeight.set(g.y, Math.max(rowHeight.get(g.y) ?? 0, g.h));
+            rowWidth.set(g.y, Math.max(rowWidth.get(g.y) ?? 0, g.x + g.w));
+        }
+        for (const g of this._allocatedGlyphs) {
+            ctx.fillStyle = "#4040FF" ;
+            ctx.fillRect(g.x, g.y, g.w, g.h);
+            ctx.fillStyle = "#FF0000" ;
+            ctx.fillRect(g.x, g.y + g.h, g.w, rowHeight.get(g.y) - g.h);
+        }
+        for (const [rowY, rowW] of rowWidth.entries()) {
+            if (rowY !== this._currentRow.y) {
+                ctx.fillStyle = "#FF0000" ;
+                ctx.fillRect(rowW, rowY, w - rowW, rowHeight.get(rowY));
+            }
+        }
+        return canvas.convertToBlob();
+    }
+    getStats() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        let usedPixels = 0;
+        let wastedPixels = 0;
+        const totalPixels = w * h;
+        const rowHeight = ( new Map());
+        const rowWidth = ( new Map());
+        for (const g of this._allocatedGlyphs) {
+            rowHeight.set(g.y, Math.max(rowHeight.get(g.y) ?? 0, g.h));
+            rowWidth.set(g.y, Math.max(rowWidth.get(g.y) ?? 0, g.x + g.w));
+        }
+        for (const g of this._allocatedGlyphs) {
+            usedPixels += g.w * g.h;
+            wastedPixels += g.w * (rowHeight.get(g.y) - g.h);
+        }
+        for (const [rowY, rowW] of rowWidth.entries()) {
+            if (rowY !== this._currentRow.y) {
+                wastedPixels += (w - rowW) * rowHeight.get(rowY);
+            }
+        }
+        return [
+            `page${this._textureIndex}:`,
+            `     Total: ${totalPixels} (${w}x${h})`,
+            `      Used: ${usedPixels} (${((usedPixels / totalPixels) * 100).toPrecision(2)}%)`,
+            `    Wasted: ${wastedPixels} (${((wastedPixels / totalPixels) * 100).toPrecision(2)}%)`,
+            `Efficiency: ${((usedPixels / (usedPixels + wastedPixels)) * 100).toPrecision(2)}%`,
+        ].join('\n');
+    }
+}
+export { TextureAtlasShelfAllocator };