@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleView.js

@@ -1,27 +1,37 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { AccessibilityHelpNLS } from 'monaco-editor/esm/vs/editor/common/standaloneStrings.js';
+import { CodeActionController } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeActionController.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { WorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
 import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId } from './accessibilityConfiguration.js';
 import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
-import { CodeActionController } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeActionController.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { AccessibleViewAction, accessibilityHelpIsShown, accessibleViewIsShown, AccessibleViewNextAction, AccessibleViewPreviousAction } from './accessibilityContribution.js';
 const IAccessibleViewService = ( createDecorator('accessibleViewService'));
 let AccessibleView = class AccessibleView extends Disposable {
     get editorWidget() { return this._editorWidget; }
-    constructor(_openerService, _instantiationService, _configurationService, _modelService, _contextViewService, _contextKeyService, _accessibilityService, _keybindingService) {
+    constructor(_openerService, _instantiationService, _configurationService, _modelService, _contextViewService, _contextKeyService, _accessibilityService, _keybindingService, _layoutService, _menuService) {
         super();
         this._openerService = _openerService;
         this._instantiationService = _instantiationService;
@@ -31,64 +41,93 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._contextKeyService = _contextKeyService;
         this._accessibilityService = _accessibilityService;
         this._keybindingService = _keybindingService;
+        this._layoutService = _layoutService;
+        this._menuService = _menuService;
         this._accessiblityHelpIsShown = accessibilityHelpIsShown.bindTo(this._contextKeyService);
         this._accessibleViewIsShown = accessibleViewIsShown.bindTo(this._contextKeyService);
-        this._editorContainer = document.createElement('div');
-        this._editorContainer.classList.add('accessible-view');
+        this._accessibleViewSupportsNavigation = accessibleViewSupportsNavigation.bindTo(this._contextKeyService);
+        this._accessibleViewVerbosityEnabled = accessibleViewVerbosityEnabled.bindTo(this._contextKeyService);
+        this._accessibleViewGoToSymbolSupported = accessibleViewGoToSymbolSupported.bindTo(this._contextKeyService);
+        this._accessibleViewCurrentProviderId = accessibleViewCurrentProviderId.bindTo(this._contextKeyService);
+        this._container = document.createElement('div');
+        this._container.classList.add('accessible-view');
         const codeEditorWidgetOptions = {
             contributions: EditorExtensionsRegistry.getEditorContributions().filter(c => c.id !== CodeActionController.ID)
         };
+        const titleBar = document.createElement('div');
+        titleBar.classList.add('accessible-view-title-bar');
+        this._title = document.createElement('div');
+        this._title.classList.add('accessible-view-title');
+        titleBar.appendChild(this._title);
+        const actionBar = document.createElement('div');
+        actionBar.classList.add('accessible-view-action-bar');
+        titleBar.appendChild(actionBar);
+        this._container.appendChild(titleBar);
+        this._toolbar = this._register(_instantiationService.createInstance(WorkbenchToolBar, actionBar, { orientation: 0  }));
+        this._toolbar.context = { viewId: 'accessibleView' };
+        const toolbarElt = this._toolbar.getElement();
+        toolbarElt.tabIndex = 0;
         const editorOptions = {
             ...getSimpleEditorOptions(this._configurationService),
             lineDecorationsWidth: 6,
-            dragAndDrop: true,
+            dragAndDrop: false,
             cursorWidth: 1,
             wrappingStrategy: 'advanced',
             wrappingIndent: 'none',
             padding: { top: 2, bottom: 2 },
             quickSuggestions: false,
             renderWhitespace: 'none',
-            dropIntoEditor: { enabled: true },
+            dropIntoEditor: { enabled: false },
             readOnly: true,
             fontFamily: 'var(--monaco-monospace-font)'
         };
-        this._editorWidget = this._register(this._instantiationService.createInstance(CodeEditorWidget, this._editorContainer, editorOptions, codeEditorWidgetOptions));
+        this._editorWidget = this._register(this._instantiationService.createInstance(CodeEditorWidget, this._container, editorOptions, codeEditorWidgetOptions));
         this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
             if (this._currentProvider && this._accessiblityHelpIsShown.get()) {
                 this.show(this._currentProvider);
             }
         }));
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (this._currentProvider && this._accessiblityHelpIsShown.get() && e.affectsConfiguration(`accessibility.verbosity.${this._currentProvider.verbositySettingKey}`)) {
-                this.show(this._currentProvider);
+            if (this._currentProvider && e.affectsConfiguration(this._currentProvider.verbositySettingKey)) {
+                if (this._accessiblityHelpIsShown.get()) {
+                    this.show(this._currentProvider);
+                }
+                this._accessibleViewVerbosityEnabled.set(this._configurationService.getValue(this._currentProvider.verbositySettingKey));
+                this._updateToolbar(this._currentProvider.actions, this._currentProvider.options.type);
             }
         }));
+        this._register(this._editorWidget.onDidDispose(() => this._resetContextKeys()));
     }
-    show(provider) {
+    _resetContextKeys() {
+        this._accessiblityHelpIsShown.reset();
+        this._accessibleViewIsShown.reset();
+        this._accessibleViewSupportsNavigation.reset();
+        this._accessibleViewVerbosityEnabled.reset();
+        this._accessibleViewGoToSymbolSupported.reset();
+        this._accessibleViewCurrentProviderId.reset();
+    }
+    show(provider, symbol, showAccessibleViewHelp) {
+        provider = provider ?? this._currentProvider;
+        if (!provider) {
+            return;
+        }
         const delegate = {
-            getAnchor: () => { return { x: (window.innerWidth / 2) - (800  / 2), y: 3  }; },
+            getAnchor: () => { return { x: (window.innerWidth / 2) - ((Math.min(this._layoutService.dimension.width * 0.62 , 600 )) / 2), y: this._layoutService.offset.quickPickTop }; },
             render: (container) => {
                 container.classList.add('accessible-view-container');
-                return this._render(provider, container);
+                return this._render(provider, container, showAccessibleViewHelp);
             },
             onHide: () => {
-                if (provider.options.type === "help" ) {
-                    this._accessiblityHelpIsShown.reset();
-                }
-                else {
-                    this._accessibleViewIsShown.reset();
+                if (!showAccessibleViewHelp) {
+                    this._currentProvider = undefined;
+                    this._resetContextKeys();
                 }
-                this._currentProvider = undefined;
             }
         };
         this._contextViewService.showContextView(delegate);
-        if (provider.options.type === "help" ) {
-            this._accessiblityHelpIsShown.set(true);
-        }
-        else {
-            this._accessibleViewIsShown.set(true);
+        if (symbol && this._currentProvider) {
+            this.showSymbol(this._currentProvider, symbol);
         }
-        this._currentProvider = provider;
     }
     previous() {
         if (!this._currentProvider) {
@@ -102,18 +141,108 @@ let AccessibleView = class AccessibleView extends Disposable {
         }
         this._currentProvider.next?.();
     }
-    _render(provider, container) {
-        this._currentProvider = provider;
-        const settingKey = `accessibility.verbosity.${provider.verbositySettingKey}`;
-        const value = this._configurationService.getValue(settingKey);
+    goToSymbol() {
+        if (!this._currentProvider) {
+            return;
+        }
+        this._instantiationService.createInstance(AccessibleViewSymbolQuickPick, this).show(this._currentProvider);
+    }
+    getSymbols() {
+        if (!this._currentProvider || !this._currentContent) {
+            return;
+        }
+        const tokens = this._currentProvider.options.language && this._currentProvider.options.language !== 'markdown' ? this._currentProvider.getSymbols?.() : marked.lexer(this._currentContent);
+        if (!tokens) {
+            return;
+        }
+        const symbols = [];
+        let firstListItem;
+        for (const token of tokens) {
+            let label = undefined;
+            if ('type' in token) {
+                switch (token.type) {
+                    case 'heading':
+                    case 'paragraph':
+                    case 'code':
+                        label = token.text;
+                        break;
+                    case 'list': {
+                        const firstItem = token.items?.[0];
+                        if (!firstItem) {
+                            break;
+                        }
+                        firstListItem = `- ${firstItem.text}`;
+                        label = token.items?.map(i => i.text).join(', ');
+                        break;
+                    }
+                }
+            }
+            else {
+                label = token.label;
+            }
+            if (label) {
+                symbols.push({ info: label, label: ( localize('symbolLabel', "({0}) {1}", token.type, label)), ariaLabel: ( localize('symbolLabelAria', "({0}) {1}", token.type, label)), firstListItem });
+                firstListItem = undefined;
+            }
+        }
+        return symbols;
+    }
+    showSymbol(provider, symbol) {
+        if (!this._currentContent) {
+            return;
+        }
+        const index = this._currentContent.split('\n').findIndex(line => line.includes(symbol.info.split('\n')[0]) || (symbol.firstListItem && line.includes(symbol.firstListItem))) ?? -1;
+        if (index >= 0) {
+            this.show(provider);
+            this._editorWidget.revealLine(index + 1);
+            this._editorWidget.setSelection({ startLineNumber: index + 1, startColumn: 1, endLineNumber: index + 1, endColumn: 1 });
+        }
+        this._updateContextKeys(provider, true);
+    }
+    disableHint() {
+        if (!this._currentProvider) {
+            return;
+        }
+        this._configurationService.updateValue(this._currentProvider?.verbositySettingKey, false);
+        alert(( localize(
+            'disableAccessibilityHelp',
+            '{0} accessibility verbosity is now disabled',
+            this._currentProvider.verbositySettingKey
+        )));
+    }
+    _updateContextKeys(provider, shown) {
+        if (provider.options.type === "help" ) {
+            this._accessiblityHelpIsShown.set(shown);
+            this._accessibleViewIsShown.reset();
+        }
+        else {
+            this._accessibleViewIsShown.set(shown);
+            this._accessiblityHelpIsShown.reset();
+        }
+        if (provider.next && provider.previous) {
+            this._accessibleViewSupportsNavigation.set(true);
+        }
+        else {
+            this._accessibleViewSupportsNavigation.reset();
+        }
+        const verbosityEnabled = this._configurationService.getValue(provider.verbositySettingKey);
+        this._accessibleViewVerbosityEnabled.set(verbosityEnabled);
+        this._accessibleViewGoToSymbolSupported.set(this._goToSymbolsSupported() ? this.getSymbols()?.length > 0 : false);
+    }
+    _render(provider, container, showAccessibleViewHelp) {
+        if (!showAccessibleViewHelp) {
+            this._currentProvider = provider;
+            this._accessibleViewCurrentProviderId.set(provider.verbositySettingKey.replaceAll('accessibility.verbosity.', ''));
+        }
+        const value = this._configurationService.getValue(provider.verbositySettingKey);
         const readMoreLink = provider.options.readMoreUrl ? ( localize(
             "openDoc",
-            "\nPress H now to open a browser window with more information related to accessibility.\n"
+            "\n\nPress H now to open a browser window with more information related to accessibility.\n\n"
         )) : '';
-        const disableHelpHint = provider.options.type === "help"  && !!value ? ( localize(
-            'disable-help-hint',
-            '\nTo disable the `accessibility.verbosity` hint for this feature, press D now.\n'
-        )) : '\n';
+        let disableHelpHint = '';
+        if (provider.options.type === "help"  && !!value) {
+            disableHelpHint = this._getDisableVerbosityHint(provider.verbositySettingKey);
+        }
         const accessibilitySupport = this._accessibilityService.isScreenReaderOptimized();
         let message = '';
         if (provider.options.type === "help" ) {
@@ -129,9 +258,10 @@ let AccessibleView = class AccessibleView extends Disposable {
                 message += '\n';
             }
         }
-        const fragment = message + provider.provideContent() + readMoreLink + disableHelpHint + ( localize('exit-tip', 'Exit this dialog via the Escape key.'));
+        this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + ( localize('exit-tip', '\nExit this dialog via the Escape key.'));
+        this._updateContextKeys(provider, true);
         this._getTextModel(( URI.from(
-            { path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment }
+            { path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment: this._currentContent }
         ))).then((model) => {
             if (!model) {
                 return;
@@ -142,32 +272,39 @@ let AccessibleView = class AccessibleView extends Disposable {
                 return;
             }
             model.setLanguage(provider.options.language ?? 'markdown');
-            container.appendChild(this._editorContainer);
-            this._editorWidget.updateOptions({ ariaLabel: provider.next && provider.previous ? ( localize(
-                'accessibleViewAriaLabelWithNav',
-                "{0} {1}",
-                provider.options.ariaLabel,
-                this._getNavigationAriaHint(provider.verbositySettingKey)
-            )) : ( localize('accessibleViewAriaLabel', "{0}", provider.options.ariaLabel)) });
+            container.appendChild(this._container);
+            let actionsHint = '';
+            const verbose = this._configurationService.getValue(provider.verbositySettingKey);
+            const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || this._currentProvider?.actions;
+            if (verbose && !showAccessibleViewHelp && hasActions) {
+                actionsHint = ( localize(
+                    'ariaAccessibleViewActions',
+                    "Use Shift+Tab to explore actions such as disabling this hint."
+                ));
+            }
+            let ariaLabel = provider.options.type === "help"  ? ( localize('accessibility-help', "Accessibility Help")) : ( localize('accessible-view', "Accessible View"));
+            this._title.textContent = ariaLabel;
+            if (actionsHint && provider.options.type === "view" ) {
+                ariaLabel = ( localize('accessible-view-hint', "Accessible View, {0}", actionsHint));
+            }
+            else if (actionsHint) {
+                ariaLabel = ( localize('accessibility-help-hint', "Accessibility Help, {0}", actionsHint));
+            }
+            this._editorWidget.updateOptions({ ariaLabel });
             this._editorWidget.focus();
         });
+        this._updateToolbar(provider.actions, provider.options.type);
+        const handleEscape = (e) => {
+            e.stopPropagation();
+            this._contextViewService.hideContextView();
+            this._updateContextKeys(provider, false);
+            setTimeout(() => provider.onClose(), 100);
+        };
         const disposableStore = ( new DisposableStore());
-        disposableStore.add(this._editorWidget.onKeyUp((e) => {
-            if (e.keyCode === 34  && this._configurationService.getValue(settingKey)) {
-                alert(( localize(
-                    'disableAccessibilityHelp',
-                    '{0} accessibility verbosity is now disabled',
-                    provider.verbositySettingKey
-                )));
-                this._configurationService.updateValue(settingKey, false);
-            }
-            provider.onKeyDown?.(e);
-        }));
+        disposableStore.add(this._editorWidget.onKeyUp((e) => provider.onKeyUp?.(e)));
         disposableStore.add(this._editorWidget.onKeyDown((e) => {
             if (e.keyCode === 9 ) {
-                e.stopPropagation();
-                this._contextViewService.hideContextView();
-                setTimeout(() => provider.onClose(), 100);
+                handleEscape(e);
             }
             else if (e.keyCode === 38  && provider.options.readMoreUrl) {
                 const url = provider.options.readMoreUrl;
@@ -177,12 +314,43 @@ let AccessibleView = class AccessibleView extends Disposable {
                 e.stopPropagation();
             }
         }));
-        disposableStore.add(this._editorWidget.onDidBlurEditorText(() => this._contextViewService.hideContextView()));
+        disposableStore.add(addDisposableListener(this._toolbar.getElement(), EventType.KEY_DOWN, (e) => {
+            const keyboardEvent = ( new StandardKeyboardEvent(e));
+            if (keyboardEvent.equals(9 )) {
+                handleEscape(e);
+            }
+        }));
+        disposableStore.add(this._editorWidget.onDidBlurEditorWidget(() => {
+            if (document.activeElement !== this._toolbar.getElement()) {
+                this._contextViewService.hideContextView();
+            }
+        }));
         disposableStore.add(this._editorWidget.onDidContentSizeChange(() => this._layout()));
+        disposableStore.add(this._layoutService.onDidLayout(() => this._layout()));
         return disposableStore;
     }
+    _updateToolbar(providedActions, type) {
+        this._toolbar.setAriaLabel(type === "help"  ? ( localize('accessibleHelpToolbar', 'Accessibility Help')) : ( localize('accessibleViewToolbar', "Accessible View")));
+        const menuActions = [];
+        const toolbarMenu = this._register(this._menuService.createMenu(MenuId.AccessibleView, this._contextKeyService));
+        createAndFillInActionBarActions(toolbarMenu, {}, menuActions);
+        if (providedActions) {
+            for (const providedAction of providedActions) {
+                providedAction.class = providedAction.class || ThemeIcon.asClassName(Codicon.primitiveSquare);
+                providedAction.checked = undefined;
+            }
+            this._toolbar.setActions([...providedActions, ...menuActions]);
+        }
+        else {
+            this._toolbar.setActions(menuActions);
+        }
+    }
     _layout() {
-        this._editorWidget.layout({ width: 800 , height: this._editorWidget.getContentHeight() });
+        const dimension = this._layoutService.dimension;
+        const maxHeight = dimension.height && dimension.height * .4;
+        const height = Math.min(maxHeight, this._editorWidget.getContentHeight());
+        const width = Math.min(dimension.width * 0.62 , 600 );
+        this._editorWidget.layout({ width, height });
     }
     async _getTextModel(resource) {
         const existing = this._modelService.getModel(resource);
@@ -191,23 +359,100 @@ let AccessibleView = class AccessibleView extends Disposable {
         }
         return this._modelService.createModel(resource.fragment, null, resource, false);
     }
-    _getNavigationAriaHint(verbositySettingKey) {
+    _goToSymbolsSupported() {
+        if (!this._currentProvider) {
+            return false;
+        }
+        return this._currentProvider.options.type === "help"  || this._currentProvider.options.language === 'markdown' || this._currentProvider.options.language === undefined || !!this._currentProvider.getSymbols;
+    }
+    showAccessibleViewHelp() {
+        if (!this._currentProvider) {
+            return;
+        }
+        const currentProvider = Object.assign({}, this._currentProvider);
+        currentProvider.options = Object.assign({}, currentProvider.options);
+        const accessibleViewHelpProvider = {
+            provideContent: () => this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
+            onClose: () => this.show(currentProvider),
+            options: { type: "help"  },
+            verbositySettingKey: this._currentProvider.verbositySettingKey
+        };
+        this._contextViewService.hideContextView();
+        setTimeout(() => this.show(accessibleViewHelpProvider, undefined, true), 100);
+    }
+    _getAccessibleViewHelpDialogContent(providerHasSymbols) {
+        const navigationHint = this._getNavigationHint();
+        const goToSymbolHint = this._getGoToSymbolHint(providerHasSymbols);
+        const toolbarHint = ( localize('toolbar', "Navigate to the toolbar (Shift+Tab))"));
+        let hint = ( localize('intro', "In the accessible view, you can:\n"));
+        if (navigationHint) {
+            hint += ' - ' + navigationHint + '\n';
+        }
+        if (goToSymbolHint) {
+            hint += ' - ' + goToSymbolHint + '\n';
+        }
+        if (toolbarHint) {
+            hint += ' - ' + toolbarHint + '\n';
+        }
+        return hint;
+    }
+    _getNavigationHint() {
         let hint = '';
-        const nextKeybinding = this._keybindingService.lookupKeybinding(AccessibleViewNextAction.id)?.getAriaLabel();
-        const previousKeybinding = this._keybindingService.lookupKeybinding(AccessibleViewPreviousAction.id)?.getAriaLabel();
-        if (this._configurationService.getValue(verbositySettingKey)) {
-            hint = (nextKeybinding && previousKeybinding) ? ( localize(
-                'chatAccessibleViewNextPreviousHint',
-                "Show the next {0} or previous {1} item in the accessible view",
+        const nextKeybinding = this._keybindingService.lookupKeybinding("editor.action.accessibleViewNext" )?.getAriaLabel();
+        const previousKeybinding = this._keybindingService.lookupKeybinding("editor.action.accessibleViewPrevious" )?.getAriaLabel();
+        if (nextKeybinding && previousKeybinding) {
+            hint = ( localize(
+                'accessibleViewNextPreviousHint',
+                "Show the next ({0}) or previous ({1}) item",
                 nextKeybinding,
                 previousKeybinding
-            )) : ( localize(
+            ));
+        }
+        else {
+            hint = ( localize(
                 'chatAccessibleViewNextPreviousHintNoKb',
-                "Show the next or previous item in the accessible view by configuring keybindings for Show Next / Previous in Accessible View"
+                "Show the next or previous item by configuring keybindings for the Show Next & Previous in Accessible View commands"
+            ));
+        }
+        return hint;
+    }
+    _getDisableVerbosityHint(verbositySettingKey) {
+        if (!this._configurationService.getValue(verbositySettingKey)) {
+            return '';
+        }
+        let hint = '';
+        const disableKeybinding = this._keybindingService.lookupKeybinding("editor.action.accessibleViewDisableHint" , this._contextKeyService)?.getAriaLabel();
+        if (disableKeybinding) {
+            hint = ( localize(
+                'acessibleViewDisableHint',
+                "Disable accessibility verbosity for this feature ({0}). This will disable the hint to open the accessible view for example.\n",
+                disableKeybinding
+            ));
+        }
+        else {
+            hint = ( localize(
+                'accessibleViewDisableHintNoKb',
+                "Add a keybinding for the command Disable Accessible View Hint, which disables accessibility verbosity for this feature.\n"
             ));
         }
         return hint;
     }
+    _getGoToSymbolHint(providerHasSymbols) {
+        const goToSymbolKb = this._keybindingService.lookupKeybinding("editor.action.accessibleViewGoToSymbol" )?.getAriaLabel();
+        let goToSymbolHint = '';
+        if (providerHasSymbols) {
+            if (goToSymbolKb) {
+                goToSymbolHint = ( localize('goToSymbolHint', 'Go to a symbol ({0})', goToSymbolKb));
+            }
+            else {
+                goToSymbolHint = ( localize(
+                    'goToSymbolHintNoKb',
+                    'To go to a symbol, configure a keybinding for the command Go To Symbol in Accessible View'
+                ));
+            }
+        }
+        return goToSymbolHint;
+    }
 };
 AccessibleView = ( __decorate([
     ( __param(0, IOpenerService)),
@@ -217,7 +462,9 @@ AccessibleView = ( __decorate([
     ( __param(4, IContextViewService)),
     ( __param(5, IContextKeyService)),
     ( __param(6, IAccessibilityService)),
-    ( __param(7, IKeybindingService))
+    ( __param(7, IKeybindingService)),
+    ( __param(8, ILayoutService)),
+    ( __param(9, IMenuService))
 ], AccessibleView));
 let AccessibleViewService = class AccessibleViewService extends Disposable {
     constructor(_instantiationService, _configurationService, _keybindingService) {
@@ -238,19 +485,35 @@ let AccessibleViewService = class AccessibleViewService extends Disposable {
     previous() {
         this._accessibleView?.previous();
     }
+    goToSymbol() {
+        this._accessibleView?.goToSymbol();
+    }
     getOpenAriaHint(verbositySettingKey) {
         if (!this._configurationService.getValue(verbositySettingKey)) {
             return null;
         }
-        const keybinding = this._keybindingService.lookupKeybinding(AccessibleViewAction.id)?.getAriaLabel();
-        return keybinding ? ( localize(
-            'chatAccessibleViewHint',
-            "Inspect this in the accessible view with {0}",
-            keybinding
-        )) : ( localize(
-            'chatAccessibleViewHintNoKb',
-            "Inspect this in the accessible view via the command Open Accessible View which is currently not triggerable via keybinding"
-        ));
+        const keybinding = this._keybindingService.lookupKeybinding("editor.action.accessibleView" )?.getAriaLabel();
+        let hint = null;
+        if (keybinding) {
+            hint = ( localize(
+                'acessibleViewHint',
+                "Inspect this in the accessible view with {0}",
+                keybinding
+            ));
+        }
+        else {
+            hint = ( localize(
+                'acessibleViewHintNoKbEither',
+                "Inspect this in the accessible view via the command Open Accessible View which is currently not triggerable via keybinding."
+            ));
+        }
+        return hint;
+    }
+    disableHint() {
+        this._accessibleView?.disableHint();
+    }
+    showAccessibleViewHelp() {
+        this._accessibleView?.showAccessibleViewHelp();
     }
 };
 AccessibleViewService = ( __decorate([
@@ -258,4 +521,36 @@ AccessibleViewService = ( __decorate([
     ( __param(1, IConfigurationService)),
     ( __param(2, IKeybindingService))
 ], AccessibleViewService));
+let AccessibleViewSymbolQuickPick = class AccessibleViewSymbolQuickPick {
+    constructor(_accessibleView, _quickInputService) {
+        this._accessibleView = _accessibleView;
+        this._quickInputService = _quickInputService;
+    }
+    show(provider) {
+        const quickPick = this._quickInputService.createQuickPick();
+        quickPick.placeholder = ( localize('accessibleViewSymbolQuickPickPlaceholder', "Type to search symbols"));
+        quickPick.title = ( localize('accessibleViewSymbolQuickPickTitle', "Go to Symbol Accessible View"));
+        const symbols = this._accessibleView.getSymbols();
+        if (!symbols) {
+            return;
+        }
+        for (const symbol of symbols) {
+        }
+        quickPick.canSelectMany = false;
+        quickPick.items = symbols;
+        quickPick.show();
+        quickPick.onDidAccept(() => {
+            this._accessibleView.showSymbol(provider, quickPick.selectedItems[0]);
+            quickPick.hide();
+        });
+        quickPick.onDidHide(() => {
+            if (quickPick.selectedItems.length === 0) {
+                this._accessibleView.show(provider);
+            }
+        });
+    }
+};
+AccessibleViewSymbolQuickPick = ( __decorate([
+    ( __param(1, IQuickInputService))
+], AccessibleViewSymbolQuickPick));
 export { AccessibleViewService, IAccessibleViewService };