@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/workbench/contrib/terminal/common/terminalContextKey.js

@@ -1,64 +1,62 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { TerminalSettingId } from '../../../../platform/terminal/common/terminal.js';
 import { TERMINAL_VIEW_ID } from './terminal.js';
 const _moduleId = "vs/workbench/contrib/terminal/common/terminalContextKey";
+var TerminalContextKeyStrings;
+( ((function(TerminalContextKeyStrings) {
+    TerminalContextKeyStrings["IsOpen"] = "terminalIsOpen";
+    TerminalContextKeyStrings["Count"] = "terminalCount";
+    TerminalContextKeyStrings["GroupCount"] = "terminalGroupCount";
+    TerminalContextKeyStrings["TabsNarrow"] = "isTerminalTabsNarrow";
+    TerminalContextKeyStrings["HasFixedWidth"] = "terminalHasFixedWidth";
+    TerminalContextKeyStrings["ProcessSupported"] = "terminalProcessSupported";
+    TerminalContextKeyStrings["Focus"] = "terminalFocus";
+    TerminalContextKeyStrings["FocusInAny"] = "terminalFocusInAny";
+    TerminalContextKeyStrings["AccessibleBufferFocus"] = "terminalAccessibleBufferFocus";
+    TerminalContextKeyStrings["AccessibleBufferOnLastLine"] = "terminalAccessibleBufferOnLastLine";
+    TerminalContextKeyStrings["EditorFocus"] = "terminalEditorFocus";
+    TerminalContextKeyStrings["TabsFocus"] = "terminalTabsFocus";
+    TerminalContextKeyStrings["WebExtensionContributedProfile"] = "terminalWebExtensionContributedProfile";
+    TerminalContextKeyStrings["TerminalHasBeenCreated"] = "terminalHasBeenCreated";
+    TerminalContextKeyStrings["TerminalEditorActive"] = "terminalEditorActive";
+    TerminalContextKeyStrings["TabsMouse"] = "terminalTabsMouse";
+    TerminalContextKeyStrings["AltBufferActive"] = "terminalAltBufferActive";
+    TerminalContextKeyStrings["SuggestWidgetVisible"] = "terminalSuggestWidgetVisible";
+    TerminalContextKeyStrings["A11yTreeFocus"] = "terminalA11yTreeFocus";
+    TerminalContextKeyStrings["ViewShowing"] = "terminalViewShowing";
+    TerminalContextKeyStrings["TextSelected"] = "terminalTextSelected";
+    TerminalContextKeyStrings["TextSelectedInFocused"] = "terminalTextSelectedInFocused";
+    TerminalContextKeyStrings["FindVisible"] = "terminalFindVisible";
+    TerminalContextKeyStrings["FindInputFocused"] = "terminalFindInputFocused";
+    TerminalContextKeyStrings["FindFocused"] = "terminalFindFocused";
+    TerminalContextKeyStrings["TabsSingularSelection"] = "terminalTabsSingularSelection";
+    TerminalContextKeyStrings["SplitTerminal"] = "terminalSplitTerminal";
+    TerminalContextKeyStrings["ShellType"] = "terminalShellType";
+    TerminalContextKeyStrings["InTerminalRunCommandPicker"] = "inTerminalRunCommandPicker";
+    TerminalContextKeyStrings["TerminalShellIntegrationEnabled"] = "terminalShellIntegrationEnabled";
+})(TerminalContextKeyStrings || (TerminalContextKeyStrings = {}))));
 var TerminalContextKeys;
 ( ((function(TerminalContextKeys) {
-    TerminalContextKeys.isOpen = ( (new RawContextKey("terminalIsOpen" , false, true)));
-    TerminalContextKeys.focus = ( (new RawContextKey(
-        "terminalFocus" ,
-        false,
-        ( localizeWithPath(_moduleId, 0, "Whether the terminal is focused."))
-    )));
-    TerminalContextKeys.focusInAny = ( (new RawContextKey(
-        "terminalFocusInAny" ,
-        false,
-        ( localizeWithPath(
-            _moduleId,
-            1,
-            "Whether any terminal is focused, including detached terminals used in other UI."
-        ))
-    )));
-    TerminalContextKeys.editorFocus = ( (new RawContextKey(
-        "terminalEditorFocus" ,
-        false,
-        ( localizeWithPath(_moduleId, 2, "Whether a terminal in the editor area is focused."))
-    )));
-    TerminalContextKeys.count = ( (new RawContextKey("terminalCount" , 0, ( localizeWithPath(_moduleId, 3, "The current number of terminals.")))));
-    TerminalContextKeys.groupCount = ( (new RawContextKey("terminalGroupCount" , 0, true)));
-    TerminalContextKeys.tabsNarrow = ( (new RawContextKey(
-        "isTerminalTabsNarrow" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.terminalHasFixedWidth = ( (new RawContextKey(
-        "terminalHasFixedWidth" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.tabsFocus = ( (new RawContextKey(
-        "terminalTabsFocus" ,
-        false,
-        ( localizeWithPath(_moduleId, 4, "Whether the terminal tabs widget is focused."))
-    )));
-    TerminalContextKeys.webExtensionContributedProfile = ( (new RawContextKey(
-        "terminalWebExtensionContributedProfile" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.terminalHasBeenCreated = ( (new RawContextKey(
-        "terminalHasBeenCreated" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.terminalEditorActive = ( (new RawContextKey(
-        "terminalEditorActive" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.tabsMouse = ( (new RawContextKey("terminalTabsMouse" , false, true)));
+    TerminalContextKeys.isOpen = ( (new RawContextKey(TerminalContextKeyStrings.IsOpen, false, true)));
+    TerminalContextKeys.focus = ( (new RawContextKey(TerminalContextKeyStrings.Focus, false, ( localizeWithPath(_moduleId, 0, "Whether the terminal is focused.")))));
+    TerminalContextKeys.focusInAny = ( (new RawContextKey(TerminalContextKeyStrings.FocusInAny, false, ( localizeWithPath(
+        _moduleId,
+        1,
+        "Whether any terminal is focused, including detached terminals used in other UI."
+    )))));
+    TerminalContextKeys.editorFocus = ( (new RawContextKey(TerminalContextKeyStrings.EditorFocus, false, ( localizeWithPath(_moduleId, 2, "Whether a terminal in the editor area is focused.")))));
+    TerminalContextKeys.count = ( (new RawContextKey(TerminalContextKeyStrings.Count, 0, ( localizeWithPath(_moduleId, 3, "The current number of terminals.")))));
+    TerminalContextKeys.groupCount = ( (new RawContextKey(TerminalContextKeyStrings.GroupCount, 0, true)));
+    TerminalContextKeys.tabsNarrow = ( (new RawContextKey(TerminalContextKeyStrings.TabsNarrow, false, true)));
+    TerminalContextKeys.terminalHasFixedWidth = ( (new RawContextKey(TerminalContextKeyStrings.HasFixedWidth, false, true)));
+    TerminalContextKeys.tabsFocus = ( (new RawContextKey(TerminalContextKeyStrings.TabsFocus, false, ( localizeWithPath(_moduleId, 4, "Whether the terminal tabs widget is focused.")))));
+    TerminalContextKeys.webExtensionContributedProfile = ( (new RawContextKey(TerminalContextKeyStrings.WebExtensionContributedProfile, false, true)));
+    TerminalContextKeys.terminalHasBeenCreated = ( (new RawContextKey(TerminalContextKeyStrings.TerminalHasBeenCreated, false, true)));
+    TerminalContextKeys.terminalEditorActive = ( (new RawContextKey(TerminalContextKeyStrings.TerminalEditorActive, false, true)));
+    TerminalContextKeys.tabsMouse = ( (new RawContextKey(TerminalContextKeyStrings.TabsMouse, false, true)));
     TerminalContextKeys.shellType = ( (new RawContextKey(
-        "terminalShellType" ,
+        TerminalContextKeyStrings.ShellType,
         undefined,
         { type: 'string', description: ( localizeWithPath(
             _moduleId,
@@ -66,75 +64,31 @@ var TerminalContextKeys;
             "The shell type of the active terminal, this is set to the last known value when no terminals exist."
         )) }
     )));
-    TerminalContextKeys.altBufferActive = ( (new RawContextKey(
-        "terminalAltBufferActive" ,
-        false,
-        ( localizeWithPath(_moduleId, 6, "Whether the terminal's alt buffer is active."))
-    )));
-    TerminalContextKeys.suggestWidgetVisible = ( (new RawContextKey(
-        "terminalSuggestWidgetVisible" ,
-        false,
-        ( localizeWithPath(_moduleId, 7, "Whether the terminal's suggest widget is visible."))
-    )));
+    TerminalContextKeys.altBufferActive = ( (new RawContextKey(TerminalContextKeyStrings.AltBufferActive, false, ( localizeWithPath(_moduleId, 6, "Whether the terminal's alt buffer is active.")))));
+    TerminalContextKeys.suggestWidgetVisible = ( (new RawContextKey(TerminalContextKeyStrings.SuggestWidgetVisible, false, ( localizeWithPath(_moduleId, 7, "Whether the terminal's suggest widget is visible.")))));
     TerminalContextKeys.notFocus = ( (TerminalContextKeys.focus.toNegated()));
-    TerminalContextKeys.viewShowing = ( (new RawContextKey(
-        "terminalViewShowing" ,
-        false,
-        ( localizeWithPath(_moduleId, 8, "Whether the terminal view is showing"))
-    )));
-    TerminalContextKeys.textSelected = ( (new RawContextKey(
-        "terminalTextSelected" ,
-        false,
-        ( localizeWithPath(_moduleId, 9, "Whether text is selected in the active terminal."))
-    )));
-    TerminalContextKeys.textSelectedInFocused = ( (new RawContextKey(
-        "terminalTextSelectedInFocused" ,
-        false,
-        ( localizeWithPath(_moduleId, 10, "Whether text is selected in a focused terminal."))
-    )));
+    TerminalContextKeys.viewShowing = ( (new RawContextKey(TerminalContextKeyStrings.ViewShowing, false, ( localizeWithPath(_moduleId, 8, "Whether the terminal view is showing")))));
+    TerminalContextKeys.textSelected = ( (new RawContextKey(TerminalContextKeyStrings.TextSelected, false, ( localizeWithPath(_moduleId, 9, "Whether text is selected in the active terminal.")))));
+    TerminalContextKeys.textSelectedInFocused = ( (new RawContextKey(TerminalContextKeyStrings.TextSelectedInFocused, false, ( localizeWithPath(_moduleId, 10, "Whether text is selected in a focused terminal.")))));
     TerminalContextKeys.notTextSelected = ( (TerminalContextKeys.textSelected.toNegated()));
-    TerminalContextKeys.findVisible = ( (new RawContextKey(
-        "terminalFindVisible" ,
-        false,
-        true
-    )));
+    TerminalContextKeys.findVisible = ( (new RawContextKey(TerminalContextKeyStrings.FindVisible, false, true)));
     TerminalContextKeys.notFindVisible = ( (TerminalContextKeys.findVisible.toNegated()));
-    TerminalContextKeys.findInputFocus = ( (new RawContextKey(
-        "terminalFindInputFocused" ,
-        false,
-        true
-    )));
-    TerminalContextKeys.findFocus = ( (new RawContextKey(
-        "terminalFindFocused" ,
-        false,
-        true
-    )));
+    TerminalContextKeys.findInputFocus = ( (new RawContextKey(TerminalContextKeyStrings.FindInputFocused, false, true)));
+    TerminalContextKeys.findFocus = ( (new RawContextKey(TerminalContextKeyStrings.FindFocused, false, true)));
     TerminalContextKeys.notFindFocus = ( (TerminalContextKeys.findInputFocus.toNegated()));
-    TerminalContextKeys.processSupported = ( (new RawContextKey(
-        "terminalProcessSupported" ,
-        false,
-        ( localizeWithPath(
-            _moduleId,
-            11,
-            "Whether terminal processes can be launched in the current workspace."
-        ))
-    )));
-    TerminalContextKeys.tabsSingularSelection = ( (new RawContextKey(
-        "terminalTabsSingularSelection" ,
-        false,
-        ( localizeWithPath(
-            _moduleId,
-            12,
-            "Whether one terminal is selected in the terminal tabs list."
-        ))
-    )));
-    TerminalContextKeys.splitTerminal = ( (new RawContextKey(
-        "terminalSplitTerminal" ,
-        false,
-        ( localizeWithPath(_moduleId, 13, "Whether the focused tab's terminal is a split terminal."))
-    )));
+    TerminalContextKeys.processSupported = ( (new RawContextKey(TerminalContextKeyStrings.ProcessSupported, false, ( localizeWithPath(
+        _moduleId,
+        11,
+        "Whether terminal processes can be launched in the current workspace."
+    )))));
+    TerminalContextKeys.tabsSingularSelection = ( (new RawContextKey(TerminalContextKeyStrings.TabsSingularSelection, false, ( localizeWithPath(
+        _moduleId,
+        12,
+        "Whether one terminal is selected in the terminal tabs list."
+    )))));
+    TerminalContextKeys.splitTerminal = ( (new RawContextKey(TerminalContextKeyStrings.SplitTerminal, false, ( localizeWithPath(_moduleId, 13, "Whether the focused tab's terminal is a split terminal.")))));
     TerminalContextKeys.inTerminalRunCommandPicker = ( (new RawContextKey(
-        "inTerminalRunCommandPicker" ,
+        TerminalContextKeyStrings.InTerminalRunCommandPicker,
         false,
         ( localizeWithPath(
             _moduleId,
@@ -143,7 +97,7 @@ var TerminalContextKeys;
         ))
     )));
     TerminalContextKeys.terminalShellIntegrationEnabled = ( (new RawContextKey(
-        "terminalShellIntegrationEnabled" ,
+        TerminalContextKeyStrings.TerminalShellIntegrationEnabled,
         false,
         ( localizeWithPath(
             _moduleId,
@@ -153,32 +107,26 @@ var TerminalContextKeys;
     )));
     TerminalContextKeys.shouldShowViewInlineActions = ( (ContextKeyExpr.and(
          (ContextKeyExpr.equals('view', TERMINAL_VIEW_ID)),
-         (ContextKeyExpr.notEquals(
-            `config.${"terminal.integrated.tabs.hideCondition" }`,
-            'never'
-        )),
+         (ContextKeyExpr.notEquals(`config.${TerminalSettingId.TabsHideCondition}`, 'never')),
          (ContextKeyExpr.or(
-            ContextKeyExpr.not(`config.${"terminal.integrated.tabs.enabled" }`),
-             (ContextKeyExpr.and( (ContextKeyExpr.equals(
-                `config.${"terminal.integrated.tabs.showActions" }`,
-                'singleTerminal'
-            )),  (ContextKeyExpr.equals("terminalGroupCount", 1)))),
-             (ContextKeyExpr.and( (ContextKeyExpr.equals(
-                `config.${"terminal.integrated.tabs.showActions" }`,
-                'singleTerminalOrNarrow'
-            )),  (ContextKeyExpr.or(
-                 (ContextKeyExpr.equals("terminalGroupCount", 1)),
-                 (ContextKeyExpr.has("isTerminalTabsNarrow" ))
-            )))),
-             (ContextKeyExpr.and( (ContextKeyExpr.equals(
-                `config.${"terminal.integrated.tabs.showActions" }`,
-                'singleGroup'
-            )),  (ContextKeyExpr.equals("terminalGroupCount", 1)))),
-             (ContextKeyExpr.equals(
-                `config.${"terminal.integrated.tabs.showActions" }`,
-                'always'
-            ))
+            ContextKeyExpr.not(`config.${TerminalSettingId.TabsEnabled}`),
+             (ContextKeyExpr.and(
+                 (ContextKeyExpr.equals(`config.${TerminalSettingId.TabsShowActions}`, 'singleTerminal')),
+                 (ContextKeyExpr.equals(TerminalContextKeyStrings.GroupCount, 1))
+            )),
+             (ContextKeyExpr.and(
+                 (ContextKeyExpr.equals(`config.${TerminalSettingId.TabsShowActions}`, 'singleTerminalOrNarrow')),
+                 (ContextKeyExpr.or(
+                     (ContextKeyExpr.equals(TerminalContextKeyStrings.GroupCount, 1)),
+                     (ContextKeyExpr.has(TerminalContextKeyStrings.TabsNarrow))
+                ))
+            )),
+             (ContextKeyExpr.and(
+                 (ContextKeyExpr.equals(`config.${TerminalSettingId.TabsShowActions}`, 'singleGroup')),
+                 (ContextKeyExpr.equals(TerminalContextKeyStrings.GroupCount, 1))
+            )),
+             (ContextKeyExpr.equals(`config.${TerminalSettingId.TabsShowActions}`, 'always'))
         ))
     )));
 })(TerminalContextKeys || (TerminalContextKeys = {}))));
-export { TerminalContextKeys };
+export { TerminalContextKeyStrings, TerminalContextKeys };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalStrings.js

@@ -0,0 +1,41 @@
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+const _moduleId = "vs/workbench/contrib/terminal/common/terminalStrings";
+const terminalStrings = {
+    terminal: ( localizeWithPath(_moduleId, 0, "Terminal")),
+    new: ( localizeWithPath(_moduleId, 1, "New Terminal")),
+    doNotShowAgain: ( localizeWithPath(_moduleId, 2, 'Do Not Show Again')),
+    currentSessionCategory: ( localizeWithPath(_moduleId, 3, 'current session')),
+    previousSessionCategory: ( localizeWithPath(_moduleId, 4, 'previous session')),
+    typeTask: ( localizeWithPath(_moduleId, 5, "Task")),
+    typeLocal: ( localizeWithPath(_moduleId, 6, "Local")),
+    actionCategory: ( localize2WithPath(_moduleId, 7, "Terminal")),
+    focus: ( localize2WithPath(_moduleId, 8, "Focus Terminal")),
+    focusAndHideAccessibleBuffer: ( localize2WithPath(_moduleId, 9, "Focus Terminal and Hide Accessible Buffer")),
+    kill: {
+        ...( localize2WithPath(_moduleId, 10, "Kill Terminal")),
+        short: ( localizeWithPath(_moduleId, 11, "Kill")),
+    },
+    moveToEditor: ( localize2WithPath(_moduleId, 12, "Move Terminal into Editor Area")),
+    moveIntoNewWindow: ( localize2WithPath(_moduleId, 13, "Move Terminal into New Window")),
+    moveToTerminalPanel: ( localize2WithPath(_moduleId, 14, "Move Terminal into Panel")),
+    changeIcon: ( localize2WithPath(_moduleId, 15, "Change Icon...")),
+    changeColor: ( localize2WithPath(_moduleId, 16, "Change Color...")),
+    split: {
+        ...( localize2WithPath(_moduleId, 17, "Split Terminal")),
+        short: ( localizeWithPath(_moduleId, 18, "Split")),
+    },
+    unsplit: ( localize2WithPath(_moduleId, 19, "Unsplit Terminal")),
+    rename: ( localize2WithPath(_moduleId, 20, "Rename...")),
+    toggleSizeToContentWidth: ( localize2WithPath(_moduleId, 21, "Toggle Size to Content Width")),
+    focusHover: ( localize2WithPath(_moduleId, 22, "Focus Hover")),
+    sendSequence: ( localize2WithPath(_moduleId, 23, "Send Custom Sequence To Terminal")),
+    newWithCwd: ( localize2WithPath(
+        _moduleId,
+        24,
+        "Create New Terminal Starting in a Custom Working Directory"
+    )),
+    renameWithArgs: ( localize2WithPath(_moduleId, 25, "Rename the Currently Active Terminal")),
+    scrollToPreviousCommand: ( localize2WithPath(_moduleId, 26, "Scroll To Previous Command")),
+    scrollToNextCommand: ( localize2WithPath(_moduleId, 27, "Scroll To Next Command"))
+};
+export { terminalStrings };

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/common/terminal.accessibility.js

@@ -0,0 +1,12 @@
+var TerminalAccessibilityCommandId;
+( (function(TerminalAccessibilityCommandId) {
+    TerminalAccessibilityCommandId["FocusAccessibleBuffer"] = "workbench.action.terminal.focusAccessibleBuffer";
+    TerminalAccessibilityCommandId["AccessibleBufferGoToNextCommand"] = "workbench.action.terminal.accessibleBufferGoToNextCommand";
+    TerminalAccessibilityCommandId["AccessibleBufferGoToPreviousCommand"] = "workbench.action.terminal.accessibleBufferGoToPreviousCommand";
+    TerminalAccessibilityCommandId["ScrollToBottomAccessibleView"] = "workbench.action.terminal.scrollToBottomAccessibleView";
+    TerminalAccessibilityCommandId["ScrollToTopAccessibleView"] = "workbench.action.terminal.scrollToTopAccessibleView";
+})(TerminalAccessibilityCommandId || (TerminalAccessibilityCommandId = {})));
+const defaultTerminalAccessibilityCommandsToSkipShell = [
+    TerminalAccessibilityCommandId.FocusAccessibleBuffer
+];
+export { TerminalAccessibilityCommandId, defaultTerminalAccessibilityCommandsToSkipShell };

package/vscode/src/vs/workbench/contrib/terminalContrib/find/common/terminal.find.js

@@ -0,0 +1,22 @@
+var TerminalFindCommandId;
+( (function(TerminalFindCommandId) {
+    TerminalFindCommandId["FindFocus"] = "workbench.action.terminal.focusFind";
+    TerminalFindCommandId["FindHide"] = "workbench.action.terminal.hideFind";
+    TerminalFindCommandId["FindNext"] = "workbench.action.terminal.findNext";
+    TerminalFindCommandId["FindPrevious"] = "workbench.action.terminal.findPrevious";
+    TerminalFindCommandId["ToggleFindRegex"] = "workbench.action.terminal.toggleFindRegex";
+    TerminalFindCommandId["ToggleFindWholeWord"] = "workbench.action.terminal.toggleFindWholeWord";
+    TerminalFindCommandId["ToggleFindCaseSensitive"] = "workbench.action.terminal.toggleFindCaseSensitive";
+    TerminalFindCommandId["SearchWorkspace"] = "workbench.action.terminal.searchWorkspace";
+})(TerminalFindCommandId || (TerminalFindCommandId = {})));
+const defaultTerminalFindCommandToSkipShell = [
+    TerminalFindCommandId.FindFocus,
+    TerminalFindCommandId.FindHide,
+    TerminalFindCommandId.FindNext,
+    TerminalFindCommandId.FindPrevious,
+    TerminalFindCommandId.ToggleFindRegex,
+    TerminalFindCommandId.ToggleFindWholeWord,
+    TerminalFindCommandId.ToggleFindCaseSensitive,
+    TerminalFindCommandId.SearchWorkspace,
+];
+export { TerminalFindCommandId, defaultTerminalFindCommandToSkipShell };

package/vscode/src/vs/workbench/contrib/terminalContrib/suggest/common/terminal.suggest.js

@@ -0,0 +1,18 @@
+var TerminalSuggestCommandId;
+( (function(TerminalSuggestCommandId) {
+    TerminalSuggestCommandId["SelectPrevSuggestion"] = "workbench.action.terminal.selectPrevSuggestion";
+    TerminalSuggestCommandId["SelectPrevPageSuggestion"] = "workbench.action.terminal.selectPrevPageSuggestion";
+    TerminalSuggestCommandId["SelectNextSuggestion"] = "workbench.action.terminal.selectNextSuggestion";
+    TerminalSuggestCommandId["SelectNextPageSuggestion"] = "workbench.action.terminal.selectNextPageSuggestion";
+    TerminalSuggestCommandId["AcceptSelectedSuggestion"] = "workbench.action.terminal.acceptSelectedSuggestion";
+    TerminalSuggestCommandId["HideSuggestWidget"] = "workbench.action.terminal.hideSuggestWidget";
+})(TerminalSuggestCommandId || (TerminalSuggestCommandId = {})));
+const defaultTerminalSuggestCommandsToSkipShell = [
+    TerminalSuggestCommandId.SelectPrevSuggestion,
+    TerminalSuggestCommandId.SelectPrevPageSuggestion,
+    TerminalSuggestCommandId.SelectNextSuggestion,
+    TerminalSuggestCommandId.SelectNextPageSuggestion,
+    TerminalSuggestCommandId.AcceptSelectedSuggestion,
+    TerminalSuggestCommandId.HideSuggestWidget,
+];
+export { TerminalSuggestCommandId, defaultTerminalSuggestCommandsToSkipShell };

package/vscode/src/vs/workbench/contrib/testing/common/constants.js

@@ -0,0 +1,103 @@
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { TestResultState, TestRunProfileBitset } from './testTypes.js';
+const _moduleId = "vs/workbench/contrib/testing/common/constants";
+var Testing;
+( ((function(Testing) {
+    Testing["ViewletId"] = "workbench.view.extension.test";
+    Testing["ExplorerViewId"] = "workbench.view.testing";
+    Testing["OutputPeekContributionId"] = "editor.contrib.testingOutputPeek";
+    Testing["DecorationsContributionId"] = "editor.contrib.testingDecorations";
+    Testing["CoverageDecorationsContributionId"] = "editor.contrib.coverageDecorations";
+    Testing["CoverageViewId"] = "workbench.view.testCoverage";
+    Testing["ResultsPanelId"] = "workbench.panel.testResults";
+    Testing["ResultsViewId"] = "workbench.panel.testResults.view";
+    Testing["MessageLanguageId"] = "vscodeInternalTestMessage";
+})(Testing || (Testing = {}))));
+var TestExplorerViewMode;
+( ((function(TestExplorerViewMode) {
+    TestExplorerViewMode["List"] = "list";
+    TestExplorerViewMode["Tree"] = "true";
+})(TestExplorerViewMode || (TestExplorerViewMode = {}))));
+var TestExplorerViewSorting;
+( ((function(TestExplorerViewSorting) {
+    TestExplorerViewSorting["ByLocation"] = "location";
+    TestExplorerViewSorting["ByStatus"] = "status";
+    TestExplorerViewSorting["ByDuration"] = "duration";
+})(TestExplorerViewSorting || (TestExplorerViewSorting = {}))));
+const testStateNames = {
+    [TestResultState.Errored]: ( localizeWithPath(_moduleId, 0, 'Errored')),
+    [TestResultState.Failed]: ( localizeWithPath(_moduleId, 1, 'Failed')),
+    [TestResultState.Passed]: ( localizeWithPath(_moduleId, 2, 'Passed')),
+    [TestResultState.Queued]: ( localizeWithPath(_moduleId, 3, 'Queued')),
+    [TestResultState.Running]: ( localizeWithPath(_moduleId, 4, 'Running')),
+    [TestResultState.Skipped]: ( localizeWithPath(_moduleId, 5, 'Skipped')),
+    [TestResultState.Unset]: ( localizeWithPath(_moduleId, 6, 'Not yet run')),
+};
+const labelForTestInState = (label, state) => ( localizeWithPath(_moduleId, 7, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const testConfigurationGroupNames = {
+    [TestRunProfileBitset.Debug]: ( localizeWithPath(_moduleId, 8, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localizeWithPath(_moduleId, 9, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localizeWithPath(_moduleId, 10, 'Coverage')),
+};
+var TestCommandId;
+( ((function(TestCommandId) {
+    TestCommandId["CancelTestRefreshAction"] = "testing.cancelTestRefresh";
+    TestCommandId["CancelTestRunAction"] = "testing.cancelRun";
+    TestCommandId["ClearTestResultsAction"] = "testing.clearTestResults";
+    TestCommandId["CollapseAllAction"] = "testing.collapseAll";
+    TestCommandId["ConfigureTestProfilesAction"] = "testing.configureProfile";
+    TestCommandId["ContinousRunUsingForTest"] = "testing.continuousRunUsingForTest";
+    TestCommandId["CoverageAtCursor"] = "testing.coverageAtCursor";
+    TestCommandId["CoverageByUri"] = "testing.coverage.uri";
+    TestCommandId["CoverageClear"] = "testing.coverage.close";
+    TestCommandId["CoverageCurrentFile"] = "testing.coverageCurrentFile";
+    TestCommandId["CoverageFilterToTest"] = "testing.coverageFilterToTest";
+    TestCommandId["CoverageFilterToTestInEditor"] = "testing.coverageFilterToTestInEditor";
+    TestCommandId["CoverageLastRun"] = "testing.coverageLastRun";
+    TestCommandId["CoverageSelectedAction"] = "testing.coverageSelected";
+    TestCommandId["CoverageToggleToolbar"] = "testing.coverageToggleToolbar";
+    TestCommandId["CoverageViewChangeSorting"] = "testing.coverageViewChangeSorting";
+    TestCommandId["DebugAction"] = "testing.debug";
+    TestCommandId["DebugAllAction"] = "testing.debugAll";
+    TestCommandId["DebugAtCursor"] = "testing.debugAtCursor";
+    TestCommandId["DebugByUri"] = "testing.debug.uri";
+    TestCommandId["DebugCurrentFile"] = "testing.debugCurrentFile";
+    TestCommandId["DebugFailedTests"] = "testing.debugFailTests";
+    TestCommandId["DebugLastRun"] = "testing.debugLastRun";
+    TestCommandId["DebugSelectedAction"] = "testing.debugSelected";
+    TestCommandId["FilterAction"] = "workbench.actions.treeView.testExplorer.filter";
+    TestCommandId["GetExplorerSelection"] = "_testing.getExplorerSelection";
+    TestCommandId["GetSelectedProfiles"] = "testing.getSelectedProfiles";
+    TestCommandId["GoToTest"] = "testing.editFocusedTest";
+    TestCommandId["HideTestAction"] = "testing.hideTest";
+    TestCommandId["OpenCoverage"] = "testing.openCoverage";
+    TestCommandId["OpenOutputPeek"] = "testing.openOutputPeek";
+    TestCommandId["RefreshTestsAction"] = "testing.refreshTests";
+    TestCommandId["ReRunFailedTests"] = "testing.reRunFailTests";
+    TestCommandId["ReRunLastRun"] = "testing.reRunLastRun";
+    TestCommandId["RunAction"] = "testing.run";
+    TestCommandId["RunAllAction"] = "testing.runAll";
+    TestCommandId["RunAllWithCoverageAction"] = "testing.coverageAll";
+    TestCommandId["RunAtCursor"] = "testing.runAtCursor";
+    TestCommandId["RunByUri"] = "testing.run.uri";
+    TestCommandId["RunCurrentFile"] = "testing.runCurrentFile";
+    TestCommandId["RunSelectedAction"] = "testing.runSelected";
+    TestCommandId["RunUsingProfileAction"] = "testing.runUsing";
+    TestCommandId["RunWithCoverageAction"] = "testing.coverage";
+    TestCommandId["SearchForTestExtension"] = "testing.searchForTestExtension";
+    TestCommandId["SelectDefaultTestProfiles"] = "testing.selectDefaultTestProfiles";
+    TestCommandId["ShowMostRecentOutputAction"] = "testing.showMostRecentOutput";
+    TestCommandId["StartContinousRun"] = "testing.startContinuousRun";
+    TestCommandId["StopContinousRun"] = "testing.stopContinuousRun";
+    TestCommandId["TestingSortByDurationAction"] = "testing.sortByDuration";
+    TestCommandId["TestingSortByLocationAction"] = "testing.sortByLocation";
+    TestCommandId["TestingSortByStatusAction"] = "testing.sortByStatus";
+    TestCommandId["TestingViewAsListAction"] = "testing.viewAsList";
+    TestCommandId["TestingViewAsTreeAction"] = "testing.viewAsTree";
+    TestCommandId["ToggleContinousRunForTest"] = "testing.toggleContinuousRunForTest";
+    TestCommandId["ToggleInlineTestOutput"] = "testing.toggleInlineTestOutput";
+    TestCommandId["UnhideAllTestsAction"] = "testing.unhideAllTests";
+    TestCommandId["UnhideTestAction"] = "testing.unhideTest";
+})(TestCommandId || (TestCommandId = {}))));
+export { TestCommandId, TestExplorerViewMode, TestExplorerViewSorting, Testing, labelForTestInState, testConfigurationGroupNames };

package/vscode/src/vs/workbench/contrib/testing/common/getComputedState.js

@@ -1,18 +1,19 @@
 import { Iterable } from '../../../../base/common/iterator.js';
+import { TestResultState } from './testTypes.js';
 import { statePriority, maxPriority, makeEmptyCounts } from './testingStates.js';
 const isDurationAccessor = (accessor) => 'getOwnDuration' in accessor;
 const getComputedState = (accessor, node, force = false) => {
     let computed = accessor.getCurrentComputedState(node);
     if (computed === undefined || force) {
-        computed = accessor.getOwnState(node) ?? 0 ;
+        computed = accessor.getOwnState(node) ?? TestResultState.Unset;
         let childrenCount = 0;
         const stateMap = makeEmptyCounts();
         for (const child of accessor.getChildren(node)) {
             const childComputed = getComputedState(accessor, child);
             childrenCount++;
             stateMap[childComputed]++;
-            computed = childComputed === 5  && computed === 0
-                ? 5  : maxPriority(computed, childComputed);
+            computed = childComputed === TestResultState.Skipped && computed === TestResultState.Unset
+                ? TestResultState.Skipped : maxPriority(computed, childComputed);
         }
         if (childrenCount > LARGE_NODE_THRESHOLD) {
             largeNodeChildrenStates.set(node, stateMap);