@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/scm/common/scm.js

@@ -0,0 +1,2 @@
+const VIEWLET_ID = 'workbench.view.scm';
+export { VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -0,0 +1,167 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, editorSelectionBackground, transparent, editorFindMatch, editorHoverHighlight, editorFindMatchHighlight, overviewRulerFindMatchForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { PANEL_BORDER, EDITOR_DRAG_AND_DROP_BACKGROUND, TAB_ACTIVE_BORDER } from '../../../common/theme.js';
+const ansiColorIdentifiers = [];
+registerColor('terminal.background', null, ( nls.localize(
+    'terminal.background',
+    'The background color of the terminal, this allows coloring the terminal differently to the panel.'
+)));
+registerColor('terminal.foreground', {
+    light: '#333333',
+    dark: '#CCCCCC',
+    hcDark: '#FFFFFF',
+    hcLight: '#292929'
+}, ( nls.localize('terminal.foreground', 'The foreground color of the terminal.')));
+registerColor('terminalCursor.foreground', null, ( nls.localize(
+    'terminalCursor.foreground',
+    'The foreground color of the terminal cursor.'
+)));
+registerColor('terminalCursor.background', null, ( nls.localize(
+    'terminalCursor.background',
+    'The background color of the terminal cursor. Allows customizing the color of a character overlapped by a block cursor.'
+)));
+const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor('terminal.selectionBackground', {
+    light: editorSelectionBackground,
+    dark: editorSelectionBackground,
+    hcDark: editorSelectionBackground,
+    hcLight: editorSelectionBackground
+}, ( nls.localize(
+    'terminal.selectionBackground',
+    'The selection background color of the terminal.'
+)));
+registerColor('terminal.inactiveSelectionBackground', {
+    light: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5)),
+    dark: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5)),
+    hcDark: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.7)),
+    hcLight: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))
+}, ( nls.localize(
+    'terminal.inactiveSelectionBackground',
+    'The selection background color of the terminal when it does not have focus.'
+)));
+registerColor('terminal.selectionForeground', {
+    light: null,
+    dark: null,
+    hcDark: '#000000',
+    hcLight: '#ffffff'
+}, ( nls.localize(
+    'terminal.selectionForeground',
+    'The selection foreground color of the terminal. When this is null the selection foreground will be retained and have the minimum contrast ratio feature applied.'
+)));
+registerColor('terminalCommandDecoration.defaultBackground', {
+    light: '#00000040',
+    dark: '#ffffff40',
+    hcDark: '#ffffff80',
+    hcLight: '#00000040',
+}, ( nls.localize(
+    'terminalCommandDecoration.defaultBackground',
+    'The default terminal command decoration background color.'
+)));
+registerColor('terminalCommandDecoration.successBackground', {
+    dark: '#1B81A8',
+    light: '#2090D3',
+    hcDark: '#1B81A8',
+    hcLight: '#007100'
+}, ( nls.localize(
+    'terminalCommandDecoration.successBackground',
+    'The terminal command decoration background color for successful commands.'
+)));
+registerColor('terminalCommandDecoration.errorBackground', {
+    dark: '#F14C4C',
+    light: '#E51400',
+    hcDark: '#F14C4C',
+    hcLight: '#B5200D'
+}, ( nls.localize(
+    'terminalCommandDecoration.errorBackground',
+    'The terminal command decoration background color for error commands.'
+)));
+registerColor('terminalOverviewRuler.cursorForeground', {
+    dark: '#A0A0A0CC',
+    light: '#A0A0A0CC',
+    hcDark: '#A0A0A0CC',
+    hcLight: '#A0A0A0CC'
+}, ( nls.localize(
+    'terminalOverviewRuler.cursorForeground',
+    'The overview ruler cursor color.'
+)));
+registerColor('terminal.border', {
+    dark: PANEL_BORDER,
+    light: PANEL_BORDER,
+    hcDark: PANEL_BORDER,
+    hcLight: PANEL_BORDER
+}, ( nls.localize(
+    'terminal.border',
+    'The color of the border that separates split panes within the terminal. This defaults to panel.border.'
+)));
+registerColor('terminal.findMatchBackground', {
+    dark: editorFindMatch,
+    light: editorFindMatch,
+    hcDark: null,
+    hcLight: '#0F4A85'
+}, ( nls.localize(
+    'terminal.findMatchBackground',
+    'Color of the current search match in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
+)));
+registerColor('terminal.hoverHighlightBackground', {
+    dark: ( transparent(editorHoverHighlight, 0.5)),
+    light: ( transparent(editorHoverHighlight, 0.5)),
+    hcDark: ( transparent(editorHoverHighlight, 0.5)),
+    hcLight: ( transparent(editorHoverHighlight, 0.5))
+}, ( nls.localize(
+    'terminal.findMatchHighlightBorder',
+    'Border color of the other search matches in the terminal.'
+)));
+registerColor('terminal.findMatchBorder', {
+    dark: null,
+    light: null,
+    hcDark: '#f38518',
+    hcLight: '#0F4A85'
+}, ( nls.localize(
+    'terminal.findMatchBorder',
+    'Border color of the current search match in the terminal.'
+)));
+registerColor('terminal.findMatchHighlightBackground', {
+    dark: editorFindMatchHighlight,
+    light: editorFindMatchHighlight,
+    hcDark: null,
+    hcLight: null
+}, ( nls.localize(
+    'terminal.findMatchHighlightBackground',
+    'Color of the other search matches in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
+)));
+registerColor('terminal.findMatchHighlightBorder', {
+    dark: null,
+    light: null,
+    hcDark: '#f38518',
+    hcLight: '#0F4A85'
+}, ( nls.localize(
+    'terminal.findMatchHighlightBorder',
+    'Border color of the other search matches in the terminal.'
+)));
+registerColor('terminalOverviewRuler.findMatchForeground', {
+    dark: overviewRulerFindMatchForeground,
+    light: overviewRulerFindMatchForeground,
+    hcDark: '#f38518',
+    hcLight: '#0F4A85'
+}, ( nls.localize(
+    'terminalOverviewRuler.findMatchHighlightForeground',
+    'Overview ruler marker color for find matches in the terminal.'
+)));
+registerColor('terminal.dropBackground', {
+    dark: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    light: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    hcDark: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    hcLight: EDITOR_DRAG_AND_DROP_BACKGROUND
+}, ( nls.localize(
+    'terminal.dragAndDropBackground',
+    "Background color when dragging on top of terminals. The color should have transparency so that the terminal contents can still shine through."
+)));
+registerColor('terminal.tab.activeBorder', {
+    dark: TAB_ACTIVE_BORDER,
+    light: TAB_ACTIVE_BORDER,
+    hcDark: TAB_ACTIVE_BORDER,
+    hcLight: TAB_ACTIVE_BORDER
+}, ( nls.localize(
+    'terminal.tab.activeBorder',
+    'Border on the side of the terminal tab in the panel. This defaults to tab.activeBorder.'
+)));
+export { TERMINAL_SELECTION_BACKGROUND_COLOR, ansiColorIdentifiers };

package/dist/vscode/vs/workbench/contrib/testing/common/testId.js

@@ -34,14 +34,17 @@ class TestId {
         const idx = idString.lastIndexOf("\0" );
         return idx === -1 ? idString : idString.slice(idx + "\0" .length);
     }
+    static isChild(maybeParent, maybeChild) {
+        return maybeChild.startsWith(maybeParent) && maybeChild[maybeParent.length] === "\0" ;
+    }
     static compare(a, b) {
         if (a === b) {
             return 0 ;
         }
-        if (b.startsWith(a + "\0" )) {
+        if (TestId.isChild(a, b)) {
             return 2 ;
         }
-        if (a.startsWith(b + "\0" )) {
+        if (TestId.isChild(b, a)) {
             return 3 ;
         }
         return 1 ;

package/dist/vscode/vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution.js

@@ -0,0 +1,244 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { registerEditorContribution, EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { PeekContext } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { TypeHierarchyTreePeekWidget } from './typeHierarchyPeek.js';
+import { TypeHierarchyProviderRegistry, TypeHierarchyModel } from '../common/typeHierarchy.js';
+const _ctxHasTypeHierarchyProvider = ( new RawContextKey('editorHasTypeHierarchyProvider', false, ( localize(
+    'editorHasTypeHierarchyProvider',
+    'Whether a type hierarchy provider is available'
+))));
+const _ctxTypeHierarchyVisible = ( new RawContextKey('typeHierarchyVisible', false, ( localize('typeHierarchyVisible', 'Whether type hierarchy peek is currently showing'))));
+const _ctxTypeHierarchyDirection = ( new RawContextKey(
+    'typeHierarchyDirection',
+    undefined,
+    { type: 'string', description: ( localize(
+        'typeHierarchyDirection',
+        'whether type hierarchy shows super types or subtypes'
+    )) }
+));
+function sanitizedDirection(candidate) {
+    return candidate === "subtypes"  || candidate === "supertypes"
+        ? candidate
+        : "subtypes" ;
+}
+let TypeHierarchyController = class TypeHierarchyController {
+    static get(editor) {
+        return editor.getContribution(TypeHierarchyController.Id);
+    }
+    constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
+        this._editor = _editor;
+        this._contextKeyService = _contextKeyService;
+        this._storageService = _storageService;
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._disposables = ( new DisposableStore());
+        this._sessionDisposables = ( new DisposableStore());
+        this._ctxHasProvider = _ctxHasTypeHierarchyProvider.bindTo(this._contextKeyService);
+        this._ctxIsVisible = _ctxTypeHierarchyVisible.bindTo(this._contextKeyService);
+        this._ctxDirection = _ctxTypeHierarchyDirection.bindTo(this._contextKeyService);
+        this._disposables.add(Event.any(_editor.onDidChangeModel, _editor.onDidChangeModelLanguage, TypeHierarchyProviderRegistry.onDidChange)(() => {
+            this._ctxHasProvider.set(_editor.hasModel() && ( TypeHierarchyProviderRegistry.has(_editor.getModel())));
+        }));
+        this._disposables.add(this._sessionDisposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async startTypeHierarchyFromEditor() {
+        this._sessionDisposables.clear();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const document = this._editor.getModel();
+        const position = this._editor.getPosition();
+        if (!( TypeHierarchyProviderRegistry.has(document))) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        const model = TypeHierarchyModel.create(document, position, cts.token);
+        const direction = sanitizedDirection(this._storageService.get(TypeHierarchyController._storageDirectionKey, 0 , "subtypes" ));
+        this._showTypeHierarchyWidget(position, direction, model, cts);
+    }
+    _showTypeHierarchyWidget(position, direction, model, cts) {
+        this._ctxIsVisible.set(true);
+        this._ctxDirection.set(direction);
+        Event.any(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endTypeHierarchy, this, this._sessionDisposables);
+        this._widget = this._instantiationService.createInstance(TypeHierarchyTreePeekWidget, this._editor, position, direction);
+        this._widget.showLoading();
+        this._sessionDisposables.add(this._widget.onDidClose(() => {
+            this.endTypeHierarchy();
+            this._storageService.store(TypeHierarchyController._storageDirectionKey, this._widget.direction, 0 , 0 );
+        }));
+        this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
+        this._sessionDisposables.add(this._widget);
+        model.then(model => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (model) {
+                this._sessionDisposables.add(model);
+                this._widget.showModel(model);
+            }
+            else {
+                this._widget.showMessage(( localize('no.item', "No results")));
+            }
+        }).catch(err => {
+            if (isCancellationError(err)) {
+                this.endTypeHierarchy();
+                return;
+            }
+            this._widget.showMessage(( localize('error', "Failed to show type hierarchy")));
+        });
+    }
+    async startTypeHierarchyFromTypeHierarchy() {
+        if (!this._widget) {
+            return;
+        }
+        const model = this._widget.getModel();
+        const typeItem = this._widget.getFocused();
+        if (!typeItem || !model) {
+            return;
+        }
+        const newEditor = await this._editorService.openCodeEditor({ resource: typeItem.item.uri }, this._editor);
+        if (!newEditor) {
+            return;
+        }
+        const newModel = model.fork(typeItem.item);
+        this._sessionDisposables.clear();
+        TypeHierarchyController.get(newEditor)?._showTypeHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
+    }
+    showSupertypes() {
+        this._widget?.updateDirection("supertypes" );
+        this._ctxDirection.set("supertypes" );
+    }
+    showSubtypes() {
+        this._widget?.updateDirection("subtypes" );
+        this._ctxDirection.set("subtypes" );
+    }
+    endTypeHierarchy() {
+        this._sessionDisposables.clear();
+        this._ctxIsVisible.set(false);
+        this._editor.focus();
+    }
+};
+TypeHierarchyController.Id = 'typeHierarchy';
+TypeHierarchyController._storageDirectionKey = 'typeHierarchy/defaultDirection';
+TypeHierarchyController = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IInstantiationService))
+], TypeHierarchyController));
+registerEditorContribution(TypeHierarchyController.Id, TypeHierarchyController, 0 );
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showTypeHierarchy',
+            title: { value: ( localize('title', "Peek Type Hierarchy")), original: 'Peek Type Hierarchy' },
+            menu: {
+                id: MenuId.EditorContextPeek,
+                group: 'navigation',
+                order: 1000,
+                when: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            },
+            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor))
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromEditor();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showSupertypes',
+            title: { value: ( localize('title.supertypes', "Show Supertypes")), original: 'Show Supertypes' },
+            icon: Codicon.typeHierarchySuper,
+            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )),
+                order: 1,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.showSupertypes();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showSubtypes',
+            title: { value: ( localize('title.subtypes', "Show Subtypes")), original: 'Show Subtypes' },
+            icon: Codicon.typeHierarchySub,
+            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )),
+                order: 1,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.showSubtypes();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.refocusTypeHierarchy',
+            title: { value: ( localize('title.refocusTypeHierarchy', "Refocus Type Hierarchy")), original: 'Refocus Type Hierarchy' },
+            precondition: _ctxTypeHierarchyVisible,
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 3
+            }
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromTypeHierarchy();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.closeTypeHierarchy',
+            title: ( localize('close', 'Close')),
+            icon: Codicon.close,
+            precondition: _ctxTypeHierarchyVisible,
+            keybinding: {
+                weight: 200  + 10,
+                primary: 9 ,
+                when: ContextKeyExpr.not('config.editor.stablePeek')
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                order: 1000
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.endTypeHierarchy();
+    }
+});