@codingame/monaco-vscode-api 6.0.3 → 7.0.0

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.d.ts

@@ -5,6 +5,7 @@ import { Unicode11Addon } from '@xterm/addon-unicode11';
 import { WebglAddon } from '@xterm/addon-webgl';
 import { SerializeAddon } from '@xterm/addon-serialize';
 import { ImageAddon } from '@xterm/addon-image';
+import { ClipboardAddon } from '@xterm/addon-clipboard';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 import { IShellIntegration } from '../../../../../platform/terminal/common/terminal.js';
@@ -50,6 +51,7 @@ declare class XtermTerminal extends Disposable implements IXtermTerminal, IDetac
     private _markNavigationAddon;
     private _shellIntegrationAddon;
     private _decorationAddon;
+    private _clipboardAddon?;
     private _searchAddon?;
     private _unicode11Addon?;
     private _webglAddon?;
@@ -141,6 +143,7 @@ declare class XtermTerminal extends Disposable implements IXtermTerminal, IDetac
     private _enableWebglRenderer;
     private _disableWebglForThisSession;
     private _refreshImageAddon;
+    protected _getClipboardAddonConstructor(): Promise<typeof ClipboardAddon>;
     protected _getImageAddonConstructor(): Promise<typeof ImageAddon>;
     protected _getSearchAddonConstructor(): Promise<typeof SearchAddon>;
     protected _getUnicode11Constructor(): Promise<typeof Unicode11Addon>;

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.d.ts

@@ -119,7 +119,6 @@ interface ITerminalConfiguration {
     shellIntegration?: {
         enabled: boolean;
         decorationsEnabled: boolean;
-        suggestEnabled: boolean;
     };
     enableImages: boolean;
     smoothScrolling: boolean;

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

@@ -30,12 +30,7 @@ const TERMINAL_CURSOR_BACKGROUND_COLOR = registerColor('terminalCursor.backgroun
     3,
     '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
-}, ( localizeWithPath(_moduleId, 4, 'The selection background color of the terminal.')));
+const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor('terminal.selectionBackground', editorSelectionBackground, ( localizeWithPath(_moduleId, 4, 'The selection background color of the terminal.')));
 const TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR = registerColor('terminal.inactiveSelectionBackground', {
     light: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))),
     dark: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))),
@@ -82,18 +77,8 @@ const TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR = registerColor('termin
     9,
     'The terminal command decoration background color for error commands.'
 )));
-const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor('terminalOverviewRuler.cursorForeground', {
-    dark: '#A0A0A0CC',
-    light: '#A0A0A0CC',
-    hcDark: '#A0A0A0CC',
-    hcLight: '#A0A0A0CC'
-}, ( localizeWithPath(_moduleId, 10, 'The overview ruler cursor color.')));
-registerColor('terminal.border', {
-    dark: PANEL_BORDER,
-    light: PANEL_BORDER,
-    hcDark: PANEL_BORDER,
-    hcLight: PANEL_BORDER
-}, ( localizeWithPath(
+const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor('terminalOverviewRuler.cursorForeground', '#A0A0A0CC', ( localizeWithPath(_moduleId, 10, 'The overview ruler cursor color.')));
+registerColor('terminal.border', PANEL_BORDER, ( localizeWithPath(
     _moduleId,
     11,
     'The color of the border that separates split panes within the terminal. This defaults to panel.border.'
@@ -108,12 +93,7 @@ const TERMINAL_FIND_MATCH_BACKGROUND_COLOR = registerColor('terminal.findMatchBa
     12,
     'Color of the current search match in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
 )), true);
-registerColor('terminal.hoverHighlightBackground', {
-    dark: ( (transparent(editorHoverHighlight, 0.5))),
-    light: ( (transparent(editorHoverHighlight, 0.5))),
-    hcDark: ( (transparent(editorHoverHighlight, 0.5))),
-    hcLight: ( (transparent(editorHoverHighlight, 0.5)))
-}, ( localizeWithPath(_moduleId, 13, 'Border color of the other search matches in the terminal.')));
+registerColor('terminal.hoverHighlightBackground', ( (transparent(editorHoverHighlight, 0.5))), ( localizeWithPath(_moduleId, 13, 'Border color of the other search matches in the terminal.')));
 const TERMINAL_FIND_MATCH_BORDER_COLOR = registerColor('terminal.findMatchBorder', {
     dark: null,
     light: null,
@@ -146,26 +126,22 @@ const TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR = registerColor('termi
     16,
     '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
-}, ( localizeWithPath(
+registerColor('terminal.dropBackground', EDITOR_DRAG_AND_DROP_BACKGROUND, ( localizeWithPath(
     _moduleId,
     17,
     "Background color when dragging on top of terminals. The color should have transparency so that the terminal contents can still shine through."
 )), true);
-registerColor('terminal.tab.activeBorder', {
-    dark: TAB_ACTIVE_BORDER,
-    light: TAB_ACTIVE_BORDER,
-    hcDark: TAB_ACTIVE_BORDER,
-    hcLight: TAB_ACTIVE_BORDER
-}, ( localizeWithPath(
+registerColor('terminal.tab.activeBorder', TAB_ACTIVE_BORDER, ( localizeWithPath(
     _moduleId,
     18,
     'Border on the side of the terminal tab in the panel. This defaults to tab.activeBorder.'
 )));
+registerColor('terminal.initialHintForeground', {
+    dark: '#ffffff56',
+    light: '#0007',
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(_moduleId, 19, 'Foreground color of the terminal initial hint.')));
 const ansiColorMap = {
     'terminal.ansiBlack': {
         index: 0,
@@ -316,7 +292,7 @@ function registerColors() {
     for (const id in ansiColorMap) {
         const entry = ansiColorMap[id];
         const colorName = id.substring(13);
-        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localizeWithPath(_moduleId, 19, '\'{0}\' ANSI color in the terminal.', colorName)));
+        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localizeWithPath(_moduleId, 20, '\'{0}\' ANSI color in the terminal.', colorName)));
     }
 }
 export { TERMINAL_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR, TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR, TERMINAL_CURSOR_BACKGROUND_COLOR, TERMINAL_CURSOR_FOREGROUND_COLOR, TERMINAL_FIND_MATCH_BACKGROUND_COLOR, TERMINAL_FIND_MATCH_BORDER_COLOR, TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR, TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR, TERMINAL_FOREGROUND_COLOR, TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR, TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR, TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR, TERMINAL_SELECTION_BACKGROUND_COLOR, TERMINAL_SELECTION_FOREGROUND_COLOR, ansiColorIdentifiers, ansiColorMap, registerColors };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.d.ts

@@ -0,0 +1,88 @@
+import { ITransaction } from '../../../../base/common/observableInternal/base.js';
+import { IObservableSignal } from '../../../../base/common/observableInternal/utils.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { IPrefixTreeNode, WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { TestId } from './testId.js';
+import { LiveTestResult } from './testResult.js';
+import { IFileCoverage, ICoverageCount, CoverageDetails } from './testTypes.js';
+
+interface ICoverageAccessor {
+    getCoverageDetails: (id: string, testId: string | undefined, token: CancellationToken) => Promise<CoverageDetails[]>;
+}
+/**
+ * Class that exposese coverage information for a run.
+ */
+declare class TestCoverage {
+    readonly result: LiveTestResult;
+    readonly fromTaskId: string;
+    private readonly uriIdentityService;
+    private readonly accessor;
+    private readonly fileCoverage;
+    readonly didAddCoverage: IObservableSignal<IPrefixTreeNode<AbstractFileCoverage>[]>;
+    readonly tree: WellDefinedPrefixTree<AbstractFileCoverage>;
+    readonly associatedData: Map<unknown, unknown>;
+    constructor(result: LiveTestResult, fromTaskId: string, uriIdentityService: IUriIdentityService, accessor: ICoverageAccessor);
+    /** Gets all test IDs that were included in this test run. */
+    allPerTestIDs(): Generator<string, void, unknown>;
+    append(coverage: IFileCoverage, tx: ITransaction | undefined): void;
+    /**
+     * Builds a new tree filtered to per-test coverage data for the given ID.
+     */
+    filterTreeForTest(testId: TestId): WellDefinedPrefixTree<AbstractFileCoverage>;
+    /**
+     * Gets coverage information for all files.
+     */
+    getAllFiles(): ResourceMap<FileCoverage>;
+    /**
+     * Gets coverage information for a specific file.
+     */
+    getUri(uri: URI): FileCoverage | undefined;
+    /**
+     * Gets computed information for a file, including DFS-computed information
+     * from child tests.
+     */
+    getComputedForUri(uri: URI): AbstractFileCoverage | undefined;
+    private treePathForUri;
+    private treePathToUri;
+}
+declare abstract class AbstractFileCoverage {
+    readonly fromResult: LiveTestResult;
+    id: string;
+    readonly uri: URI;
+    statement: ICoverageCount;
+    branch?: ICoverageCount;
+    declaration?: ICoverageCount;
+    readonly didChange: IObservableSignal<void>;
+    /**
+     * Gets the total coverage percent based on information provided.
+     * This is based on the Clover total coverage formula
+     */
+    get tpc(): number;
+    /**
+     * Per-test coverage data for this file, if available.
+     */
+    perTestData?: Set<string>;
+    constructor(coverage: IFileCoverage, fromResult: LiveTestResult);
+}
+declare class FileCoverage extends AbstractFileCoverage {
+    private readonly accessor;
+    private _details?;
+    private resolved?;
+    private _detailsForTest?;
+    /** Gets whether details are synchronously available */
+    get hasSynchronousDetails(): boolean | undefined;
+    constructor(coverage: IFileCoverage, fromResult: LiveTestResult, accessor: ICoverageAccessor);
+    /**
+     * Gets per-line coverage details.
+     */
+    detailsForTest(_testId: TestId, token?: Readonly<CancellationToken>): Promise<CoverageDetails[]>;
+    /**
+     * Gets per-line coverage details.
+     */
+    details(token?: Readonly<CancellationToken>): Promise<CoverageDetails[]>;
+}
+
+export { AbstractFileCoverage, FileCoverage, type ICoverageAccessor, TestCoverage };

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

@@ -1,4 +1,3 @@
-import { assert } from '../../../../base/common/assert.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { deepClone } from '../../../../base/common/objects.js';
@@ -8,7 +7,7 @@ import '../../../../base/common/observableInternal/autorun.js';
 import { observableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';
-import { IFileCoverage } from './testTypes.js';
+import './testTypes.js';
 let incId = 0;
 class TestCoverage {
     constructor(result, fromTaskId, uriIdentityService, accessor) {
@@ -20,7 +19,19 @@ class TestCoverage {
         this.didAddCoverage = observableSignal(this);
         this.tree = ( new WellDefinedPrefixTree());
         this.associatedData = ( new Map());
-        this.perTestCoverageIDs = ( new Set());
+    }
+    *allPerTestIDs() {
+        const seen = ( new Set());
+        for (const root of this.tree.nodes) {
+            if (root.value && root.value.perTestData) {
+                for (const id of root.value.perTestData) {
+                    if (!( seen.has(id))) {
+                        seen.add(id);
+                        yield id;
+                    }
+                }
+            }
+        }
     }
     append(coverage, tx) {
         const previous = this.getComputedForUri(coverage.uri);
@@ -38,23 +49,10 @@ class TestCoverage {
         };
         const canonical = [...this.treePathForUri(coverage.uri,  true)];
         const chain = [];
-        const isPerTestCoverage = !!coverage.testId;
-        if (coverage.testId) {
-            this.perTestCoverageIDs.add(( coverage.testId.toString()));
-        }
         this.tree.mutatePath(this.treePathForUri(coverage.uri,  false), node => {
             chain.push(node);
             if (chain.length === canonical.length) {
-                if (isPerTestCoverage) {
-                    const v = node.value ??= ( new FileCoverage(IFileCoverage.empty(String(incId++), coverage.uri), result, this.accessor));
-                    assert(v instanceof FileCoverage, 'coverage is unexpectedly computed');
-                    v.perTestData ??= ( new Map());
-                    const perTest = ( new FileCoverage(coverage, result, this.accessor));
-                    perTest.isForTest = { id: coverage.testId, parent: v };
-                    v.perTestData.set(( coverage.testId.toString()), perTest);
-                    this.fileCoverage.set(coverage.uri, v);
-                }
-                else if (node.value) {
+                if (node.value) {
                     const v = node.value;
                     v.id = coverage.id;
                     v.statement = coverage.statement;
@@ -66,7 +64,7 @@ class TestCoverage {
                     this.fileCoverage.set(coverage.uri, v);
                 }
             }
-            else if (!isPerTestCoverage) {
+            else {
                 if (!node.value) {
                     const intermediate = deepClone(coverage);
                     intermediate.id = String(incId++);
@@ -80,8 +78,14 @@ class TestCoverage {
                     node.value.didChange.trigger(tx);
                 }
             }
+            if (coverage.testIds) {
+                node.value.perTestData ??= ( new Set());
+                for (const id of coverage.testIds) {
+                    node.value.perTestData.add(id);
+                }
+            }
         });
-        if (chain && !isPerTestCoverage) {
+        if (chain) {
             this.didAddCoverage.trigger(tx, chain);
         }
     }
@@ -89,20 +93,14 @@ class TestCoverage {
         const tree = ( new WellDefinedPrefixTree());
         for (const node of ( this.tree.values())) {
             if (node instanceof FileCoverage) {
-                const fileData = node.perTestData?.get(( testId.toString()));
-                if (!fileData) {
+                if (!node.perTestData?.has(( testId.toString()))) {
                     continue;
                 }
-                const canonical = [...this.treePathForUri(fileData.uri,  true)];
+                const canonical = [...this.treePathForUri(node.uri,  true)];
                 const chain = [];
-                tree.mutatePath(this.treePathForUri(fileData.uri,  false), node => {
-                    chain.push(node);
-                    if (chain.length === canonical.length) {
-                        node.value = fileData;
-                    }
-                    else {
-                        node.value ??= ( new BypassedFileCoverage(this.treePathToUri(canonical.slice(0, chain.length)), fileData.fromResult));
-                    }
+                tree.mutatePath(this.treePathForUri(node.uri,  false), n => {
+                    chain.push(n);
+                    n.value ??= ( new BypassedFileCoverage(this.treePathToUri(canonical.slice(0, chain.length)), node.fromResult));
                 });
             }
         }
@@ -169,8 +167,27 @@ class FileCoverage extends AbstractFileCoverage {
         super(coverage, fromResult);
         this.accessor = accessor;
     }
+    async detailsForTest(_testId, token = CancellationToken.None) {
+        this._detailsForTest ??= ( new Map());
+        const testId = ( _testId.toString());
+        const prev = this._detailsForTest.get(testId);
+        if (prev) {
+            return prev;
+        }
+        const promise = (async () => {
+            try {
+                return await this.accessor.getCoverageDetails(this.id, testId, token);
+            }
+            catch (e) {
+                this._detailsForTest?.delete(testId);
+                throw e;
+            }
+        })();
+        this._detailsForTest.set(testId, promise);
+        return promise;
+    }
     async details(token = CancellationToken.None) {
-        this._details ??= this.accessor.getCoverageDetails(this.id, token);
+        this._details ??= this.accessor.getCoverageDetails(this.id, undefined, token);
         try {
             const d = await this._details;
             this.resolved = true;

package/vscode/src/vs/workbench/contrib/testing/common/testId.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Enum for describing relative positions of tests. Similar to
+ * `node.compareDocumentPosition` in the DOM.
+ */
+declare const enum TestPosition {
+    /** a === b */
+    IsSame = 0,
+    /** Neither a nor b are a child of one another. They may share a common parent, though. */
+    Disconnected = 1,
+    /** b is a child of a */
+    IsChild = 2,
+    /** b is a parent of a */
+    IsParent = 3
+}
+type TestItemLike = {
+    id: string;
+    parent?: TestItemLike;
+    _isRoot?: boolean;
+};
+/**
+ * The test ID is a stringifiable client that
+ */
+declare class TestId {
+    readonly path: readonly string[];
+    private readonly viewEnd;
+    private stringifed?;
+    /**
+     * Creates a test ID from an ext host test item.
+     */
+    static fromExtHostTestItem(item: TestItemLike, rootId: string, parent?: TestItemLike | undefined): TestId;
+    /**
+     * Cheaply ets whether the ID refers to the root .
+     */
+    static isRoot(idString: string): boolean;
+    /**
+     * Cheaply gets whether the ID refers to the root .
+     */
+    static root(idString: string): string;
+    /**
+     * Creates a test ID from a serialized TestId instance.
+     */
+    static fromString(idString: string): TestId;
+    /**
+     * Gets the ID resulting from adding b to the base ID.
+     */
+    static join(base: TestId, b: string): TestId;
+    /**
+     * Gets the string ID resulting from adding b to the base ID.
+     */
+    static joinToString(base: string | TestId, b: string): string;
+    /**
+     * Cheaply gets the parent ID of a test identified with the string.
+     */
+    static parentId(idString: string): string | undefined;
+    /**
+     * Cheaply gets the local ID of a test identified with the string.
+     */
+    static localId(idString: string): string;
+    /**
+     * Gets whether maybeChild is a child of maybeParent.
+     * todo@connor4312: review usages of this to see if using the WellDefinedPrefixTree is better
+     */
+    static isChild(maybeParent: string, maybeChild: string): boolean;
+    /**
+     * Compares the position of the two ID strings.
+     * todo@connor4312: review usages of this to see if using the WellDefinedPrefixTree is better
+     */
+    static compare(a: string, b: string): TestPosition;
+    static getLengthOfCommonPrefix(length: number, getId: (i: number) => TestId): number;
+    constructor(path: readonly string[], viewEnd?: number);
+    /**
+     * Gets the ID of the parent test.
+     */
+    get rootId(): TestId;
+    /**
+     * Gets the ID of the parent test.
+     */
+    get parentId(): TestId | undefined;
+    /**
+     * Gets the local ID of the current full test ID.
+     */
+    get localId(): string;
+    /**
+     * Gets whether this ID refers to the root.
+     */
+    get controllerId(): string;
+    /**
+     * Gets whether this ID refers to the root.
+     */
+    get isRoot(): boolean;
+    /**
+     * Returns an iterable that yields IDs of all parent items down to and
+     * including the current item.
+     */
+    idsFromRoot(): Generator<TestId, void, unknown>;
+    /**
+     * Returns an iterable that yields IDs of the current item up to the root
+     * item.
+     */
+    idsToRoot(): Generator<TestId, void, unknown>;
+    /**
+     * Compares the other test ID with this one.
+     */
+    compare(other: TestId | string): TestPosition;
+    /**
+     * Serializes the ID.
+     */
+    toJSON(): string;
+    /**
+     * Serializes the ID to a string.
+     */
+    toString(): string;
+}
+
+export { TestId, TestPosition };