@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.2

package/vscode/src/vs/workbench/contrib/speech/common/speechService.js

@@ -1,12 +1,26 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { firstOrDefault } from '../../../../base/common/arrays.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
 const ISpeechService = ( createDecorator('speechService'));
 const HasSpeechProvider = ( new RawContextKey('hasSpeechProvider', false, { type: 'string', description: ( localizeWithPath(
     'vs/workbench/contrib/speech/common/speechService',
     'hasSpeechProvider',
     "A speech provider is registered to the speech service."
 )) }));
+const SpeechToTextInProgress = ( new RawContextKey(
+    'speechToTextInProgress',
+    false,
+    { type: 'string', description: ( localizeWithPath(
+        'vs/workbench/contrib/speech/common/speechService',
+        'speechToTextInProgress',
+        "A speech-to-text session is in progress."
+    )) }
+));
 var SpeechToTextStatus;
 ( (function(SpeechToTextStatus) {
     SpeechToTextStatus[SpeechToTextStatus["Started"] = 1] = "Started";
@@ -14,4 +28,126 @@ var SpeechToTextStatus;
     SpeechToTextStatus[SpeechToTextStatus["Recognized"] = 3] = "Recognized";
     SpeechToTextStatus[SpeechToTextStatus["Stopped"] = 4] = "Stopped";
 })(SpeechToTextStatus || (SpeechToTextStatus = {})));
-export { HasSpeechProvider, ISpeechService, SpeechToTextStatus };
+var KeywordRecognitionStatus;
+( (function(KeywordRecognitionStatus) {
+    KeywordRecognitionStatus[KeywordRecognitionStatus["Recognized"] = 1] = "Recognized";
+    KeywordRecognitionStatus[KeywordRecognitionStatus["Stopped"] = 2] = "Stopped";
+})(KeywordRecognitionStatus || (KeywordRecognitionStatus = {})));
+let SpeechService = class SpeechService extends Disposable {
+    get hasSpeechProvider() { return this.providers.size > 0; }
+    constructor(logService, contextKeyService) {
+        super();
+        this.logService = logService;
+        this.contextKeyService = contextKeyService;
+        this._onDidRegisterSpeechProvider = this._register(( new Emitter()));
+        this.onDidRegisterSpeechProvider = this._onDidRegisterSpeechProvider.event;
+        this._onDidUnregisterSpeechProvider = this._register(( new Emitter()));
+        this.onDidUnregisterSpeechProvider = this._onDidUnregisterSpeechProvider.event;
+        this.providers = ( new Map());
+        this.hasSpeechProviderContext = HasSpeechProvider.bindTo(this.contextKeyService);
+        this._onDidStartSpeechToTextSession = this._register(( new Emitter()));
+        this.onDidStartSpeechToTextSession = this._onDidStartSpeechToTextSession.event;
+        this._onDidEndSpeechToTextSession = this._register(( new Emitter()));
+        this.onDidEndSpeechToTextSession = this._onDidEndSpeechToTextSession.event;
+        this._activeSpeechToTextSession = undefined;
+        this.speechToTextInProgress = SpeechToTextInProgress.bindTo(this.contextKeyService);
+        this._onDidStartKeywordRecognition = this._register(( new Emitter()));
+        this.onDidStartKeywordRecognition = this._onDidStartKeywordRecognition.event;
+        this._onDidEndKeywordRecognition = this._register(( new Emitter()));
+        this.onDidEndKeywordRecognition = this._onDidEndKeywordRecognition.event;
+        this._activeKeywordRecognitionSession = undefined;
+    }
+    registerSpeechProvider(identifier, provider) {
+        if (( this.providers.has(identifier))) {
+            throw new Error(`Speech provider with identifier ${identifier} is already registered.`);
+        }
+        this.providers.set(identifier, provider);
+        this.hasSpeechProviderContext.set(true);
+        this._onDidRegisterSpeechProvider.fire(provider);
+        return toDisposable(() => {
+            this.providers.delete(identifier);
+            this._onDidUnregisterSpeechProvider.fire(provider);
+            if (this.providers.size === 0) {
+                this.hasSpeechProviderContext.set(false);
+            }
+        });
+    }
+    get hasActiveSpeechToTextSession() { return !!this._activeSpeechToTextSession; }
+    createSpeechToTextSession(token) {
+        const provider = firstOrDefault(Array.from(( this.providers.values())));
+        if (!provider) {
+            throw new Error(`No Speech provider is registered.`);
+        }
+        else if (this.providers.size > 1) {
+            this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
+        }
+        const session = this._activeSpeechToTextSession = provider.createSpeechToTextSession(token);
+        const disposables = ( new DisposableStore());
+        const onSessionStoppedOrCanceled = () => {
+            if (session === this._activeSpeechToTextSession) {
+                this._activeSpeechToTextSession = undefined;
+                this.speechToTextInProgress.reset();
+                this._onDidEndSpeechToTextSession.fire();
+            }
+            disposables.dispose();
+        };
+        disposables.add(token.onCancellationRequested(() => onSessionStoppedOrCanceled()));
+        if (token.isCancellationRequested) {
+            onSessionStoppedOrCanceled();
+        }
+        disposables.add(session.onDidChange(e => {
+            switch (e.status) {
+                case SpeechToTextStatus.Started:
+                    if (session === this._activeSpeechToTextSession) {
+                        this.speechToTextInProgress.set(true);
+                        this._onDidStartSpeechToTextSession.fire();
+                    }
+                    break;
+                case SpeechToTextStatus.Stopped:
+                    onSessionStoppedOrCanceled();
+                    break;
+            }
+        }));
+        return session;
+    }
+    get hasActiveKeywordRecognition() { return !!this._activeKeywordRecognitionSession; }
+    async recognizeKeyword(token) {
+        const provider = firstOrDefault(Array.from(( this.providers.values())));
+        if (!provider) {
+            throw new Error(`No Speech provider is registered.`);
+        }
+        else if (this.providers.size > 1) {
+            this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
+        }
+        const session = this._activeKeywordRecognitionSession = provider.createKeywordRecognitionSession(token);
+        this._onDidStartKeywordRecognition.fire();
+        const disposables = ( new DisposableStore());
+        const onSessionStoppedOrCanceled = () => {
+            if (session === this._activeKeywordRecognitionSession) {
+                this._activeKeywordRecognitionSession = undefined;
+                this._onDidEndKeywordRecognition.fire();
+            }
+            disposables.dispose();
+        };
+        disposables.add(token.onCancellationRequested(() => onSessionStoppedOrCanceled()));
+        if (token.isCancellationRequested) {
+            onSessionStoppedOrCanceled();
+        }
+        disposables.add(session.onDidChange(e => {
+            if (e.status === KeywordRecognitionStatus.Stopped) {
+                onSessionStoppedOrCanceled();
+            }
+        }));
+        try {
+            return (await Event.toPromise(session.onDidChange)).status;
+        }
+        finally {
+            onSessionStoppedOrCanceled();
+        }
+    }
+};
+SpeechService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IContextKeyService))
+], SpeechService));
+export { HasSpeechProvider, ISpeechService, KeywordRecognitionStatus, SpeechService, SpeechToTextInProgress, SpeechToTextStatus };

package/vscode/src/vs/workbench/contrib/tags/browser/workspaceTagsService.js

@@ -0,0 +1,12 @@
+class NoOpWorkspaceTagsService {
+    getTags() {
+        return Promise.resolve({});
+    }
+    async getTelemetryWorkspaceId(workspace, state) {
+        return undefined;
+    }
+    getHashedRemotesFromUri(workspaceUri, stripEndingDotGit) {
+        return Promise.resolve([]);
+    }
+}
+export { NoOpWorkspaceTagsService };

package/vscode/src/vs/workbench/contrib/tags/common/workspaceTags.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+const IWorkspaceTagsService = ( createDecorator('workspaceTagsService'));
+export { IWorkspaceTagsService };

package/vscode/src/vs/workbench/contrib/typeHierarchy/browser/media/typeHierarchy.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .type-hierarchy .message,.monaco-workbench .type-hierarchy .results{display:none}.monaco-workbench .type-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .type-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .type-hierarchy .editor,.monaco-workbench .type-hierarchy .tree{height:100%}.monaco-editor .type-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-editor .type-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-workbench .type-hierarchy .tree .typehierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .type-hierarchy .tree .typehierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .type-hierarchy .type-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .type-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .type-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .type-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,281 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { isCancellationError } from '../../../../base/common/errors.js';
+import { Event } from '../../../../base/common/event.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { registerEditorContribution, EditorAction2 } from '../../../../editor/browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { PeekContext } from '../../../../editor/contrib/peekView/browser/peekView.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { registerAction2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { RawContextKey, IContextKeyService, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { TypeHierarchyTreePeekWidget } from './typeHierarchyPeek.js';
+import { TypeHierarchyProviderRegistry, TypeHierarchyModel } from '../common/typeHierarchy.js';
+var TypeHierarchyController_1;
+const _ctxHasTypeHierarchyProvider = ( new RawContextKey('editorHasTypeHierarchyProvider', false, ( localizeWithPath(
+    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+    'editorHasTypeHierarchyProvider',
+    'Whether a type hierarchy provider is available'
+))));
+const _ctxTypeHierarchyVisible = ( new RawContextKey('typeHierarchyVisible', false, ( localizeWithPath(
+    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+    'typeHierarchyVisible',
+    'Whether type hierarchy peek is currently showing'
+))));
+const _ctxTypeHierarchyDirection = ( new RawContextKey(
+    'typeHierarchyDirection',
+    undefined,
+    { type: 'string', description: ( localizeWithPath(
+        'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+        'typeHierarchyDirection',
+        'whether type hierarchy shows super types or subtypes'
+    )) }
+));
+function sanitizedDirection(candidate) {
+    return candidate === "subtypes"  || candidate === "supertypes"
+        ? candidate
+        : "subtypes" ;
+}
+let TypeHierarchyController = class TypeHierarchyController {
+    static { TypeHierarchyController_1 = this; }
+    static { this.Id = 'typeHierarchy'; }
+    static get(editor) {
+        return editor.getContribution(TypeHierarchyController_1.Id);
+    }
+    static { this._storageDirectionKey = 'typeHierarchy/defaultDirection'; }
+    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_1._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_1._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(( localizeWithPath(
+                    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                    'no.item',
+                    "No results"
+                )));
+            }
+        }).catch(err => {
+            if (isCancellationError(err)) {
+                this.endTypeHierarchy();
+                return;
+            }
+            this._widget.showMessage(( localizeWithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                '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_1.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 = TypeHierarchyController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IInstantiationService))
+], TypeHierarchyController));
+registerEditorContribution(TypeHierarchyController.Id, TypeHierarchyController, 0 );
+registerAction2(class PeekTypeHierarchyAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showTypeHierarchy',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title',
+                'Peek Type Hierarchy'
+            )),
+            menu: {
+                id: MenuId.EditorContextPeek,
+                group: 'navigation',
+                order: 1000,
+                when: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            },
+            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            f1: true
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromEditor();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showSupertypes',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.supertypes',
+                '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: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.subtypes',
+                '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: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.refocusTypeHierarchy',
+                '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: ( localizeWithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                '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();
+    }
+});