@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

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

@@ -1,4 +1,4 @@
-import { IBufferCell } from '../../../../../../../external/xterm/typings/xterm.js';
+import { IBufferCell } from '../../../../../../../external/@xterm/xterm/typings/xterm.js';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -11,6 +11,7 @@ type XtermAttributes = Omit<IBufferCell, 'getWidth' | 'getChars' | 'getCode'> &
 
 interface IXtermCore {
 	viewport?: {
+		readonly scrollBarWidth: number;
 		_innerRefresh(): void;
 	};
 	_onData: IEventEmitter<string>;
@@ -39,7 +40,9 @@ interface IXtermCore {
 			}
 		},
 		_renderer: {
-			_renderLayers?: any[];
+			value?: {
+				_renderLayers?: any[];
+			}
 		};
 		_handleIntersectionChange: any;
 	};

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

@@ -6,7 +6,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
 import { ITerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/capabilities.js';
 import { IMergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariable.js';
-import { IShellLaunchConfig, TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
+import { TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
 import { IEnvironmentVariableInfo } from './environmentVariable.js';
 
 type FontWeight = 'normal' | 'bold' | number;
@@ -126,12 +126,6 @@ interface ITerminalConfiguration {
     smoothScrolling: boolean;
     ignoreBracketedPasteMode: boolean;
 }
-interface ITerminalConfigHelper {
-    config: ITerminalConfiguration;
-    configFontIsMonospace(): boolean;
-    getFont(): ITerminalFont;
-    showRecommendations(shellLaunchConfig: IShellLaunchConfig): void;
-}
 interface ITerminalFont {
     fontFamily: string;
     fontSize: number;
@@ -240,4 +234,4 @@ interface ITerminalStatusHoverAction {
     run: () => void;
 }
 
-export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfigHelper, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };
+export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };

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

@@ -20,7 +20,9 @@ const DEFAULT_COMMANDS_TO_SKIP_SHELL = [
     "workbench.action.terminal.copyAndClearSelection" ,
     "workbench.action.terminal.copySelection" ,
     "workbench.action.terminal.copySelectionAsHtml" ,
+    "workbench.action.terminal.copyLastCommand" ,
     "workbench.action.terminal.copyLastCommandOutput" ,
+    "workbench.action.terminal.copyLastCommandAndLastCommandOutput" ,
     "workbench.action.terminal.deleteToLineStart" ,
     "workbench.action.terminal.deleteWordLeft" ,
     "workbench.action.terminal.deleteWordRight" ,

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

@@ -0,0 +1,101 @@
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.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 ;
+        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);
+        }
+        if (childrenCount > LARGE_NODE_THRESHOLD) {
+            largeNodeChildrenStates.set(node, stateMap);
+        }
+        accessor.setComputedState(node, computed);
+    }
+    return computed;
+};
+const getComputedDuration = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedDuration(node);
+    if (computed === undefined || force) {
+        const own = accessor.getOwnDuration(node);
+        if (own !== undefined) {
+            computed = own;
+        }
+        else {
+            computed = undefined;
+            for (const child of accessor.getChildren(node)) {
+                const d = getComputedDuration(accessor, child);
+                if (d !== undefined) {
+                    computed = (computed || 0) + d;
+                }
+            }
+        }
+        accessor.setComputedDuration(node, computed);
+    }
+    return computed;
+};
+const LARGE_NODE_THRESHOLD = 64;
+const largeNodeChildrenStates = ( new WeakMap());
+const refreshComputedState = (accessor, node, explicitNewComputedState, refreshDuration = true) => {
+    const oldState = accessor.getCurrentComputedState(node);
+    const oldPriority = statePriority[oldState];
+    const newState = explicitNewComputedState ?? getComputedState(accessor, node, true);
+    const newPriority = statePriority[newState];
+    const toUpdate = ( new Set());
+    if (newPriority !== oldPriority) {
+        accessor.setComputedState(node, newState);
+        toUpdate.add(node);
+        let moveFromState = oldState;
+        let moveToState = newState;
+        for (const parent of accessor.getParents(node)) {
+            const lnm = largeNodeChildrenStates.get(parent);
+            if (lnm) {
+                lnm[moveFromState]--;
+                lnm[moveToState]++;
+            }
+            const prev = accessor.getCurrentComputedState(parent);
+            if (newPriority > oldPriority) {
+                if (prev !== undefined && statePriority[prev] >= newPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveToState] > 1) {
+                    break;
+                }
+                accessor.setComputedState(parent, newState);
+                toUpdate.add(parent);
+            }
+            else  {
+                if (prev === undefined || statePriority[prev] > oldPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveFromState] > 0) {
+                    break;
+                }
+                moveToState = getComputedState(accessor, parent, true);
+                accessor.setComputedState(parent, moveToState);
+                toUpdate.add(parent);
+            }
+            moveFromState = prev;
+        }
+    }
+    if (isDurationAccessor(accessor) && refreshDuration) {
+        for (const parent of Iterable.concat(Iterable.single(node), accessor.getParents(node))) {
+            const oldDuration = accessor.getCurrentComputedDuration(parent);
+            const newDuration = getComputedDuration(accessor, parent, true);
+            if (oldDuration === newDuration) {
+                break;
+            }
+            accessor.setComputedDuration(parent, newDuration);
+            toUpdate.add(parent);
+        }
+    }
+    return toUpdate;
+};
+export { refreshComputedState };

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

@@ -0,0 +1,30 @@
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const staticObservableValue = (value) => ({
+    onDidChange: Event.None,
+    value,
+});
+class MutableObservableValue extends Disposable {
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        if (v !== this._value) {
+            this._value = v;
+            this.changeEmitter.fire(v);
+        }
+    }
+    static stored(stored, defaultValue) {
+        const o = ( new MutableObservableValue(stored.get(defaultValue)));
+        o._register(stored);
+        o._register(o.onDidChange(value => stored.store(value)));
+        return o;
+    }
+    constructor(_value) {
+        super();
+        this._value = _value;
+        this.changeEmitter = this._register(( new Emitter()));
+        this.onDidChange = this.changeEmitter.event;
+    }
+}
+export { MutableObservableValue, staticObservableValue };

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

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+const defaultSerialization = {
+    deserialize: d => JSON.parse(d),
+    serialize: d => JSON.stringify(d),
+};
+let StoredValue = class StoredValue extends Disposable {
+    constructor(options, storage) {
+        super();
+        this.storage = storage;
+        this.key = options.key;
+        this.scope = options.scope;
+        this.target = options.target;
+        this.serialization = options.serialization ?? defaultSerialization;
+        this.onDidChange = this.storage.onDidChangeValue(this.scope, this.key, this._register(( new DisposableStore())));
+    }
+    get(defaultValue) {
+        if (this.value === undefined) {
+            const value = this.storage.get(this.key, this.scope);
+            this.value = value === undefined ? defaultValue : this.serialization.deserialize(value);
+        }
+        return this.value;
+    }
+    store(value) {
+        this.value = value;
+        this.storage.store(this.key, this.serialization.serialize(value), this.scope, this.target);
+    }
+    delete() {
+        this.storage.remove(this.key, this.scope);
+    }
+};
+StoredValue = ( __decorate([
+    ( __param(1, IStorageService))
+], StoredValue));
+export { StoredValue };

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

@@ -0,0 +1,115 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICoveredCount } from './testTypes.js';
+class TestCoverage {
+    static async load(taskId, accessor, token) {
+        const files = await accessor.provideFileCoverage(token);
+        const map = ( new ResourceMap());
+        for (const [i, file] of files.entries()) {
+            map.set(file.uri, ( new FileCoverage(file, i, accessor)));
+        }
+        return ( new TestCoverage(taskId, map));
+    }
+    get tree() {
+        return this._tree ??= this.buildCoverageTree();
+    }
+    constructor(fromTaskId, fileCoverage) {
+        this.fromTaskId = fromTaskId;
+        this.fileCoverage = fileCoverage;
+    }
+    getAllFiles() {
+        return this.fileCoverage;
+    }
+    getUri(uri) {
+        return this.fileCoverage.get(uri);
+    }
+    getComputedForUri(uri) {
+        return this.tree.find(this.treePathForUri(uri));
+    }
+    buildCoverageTree() {
+        const tree = ( new WellDefinedPrefixTree());
+        for (const file of ( this.fileCoverage.values())) {
+            tree.insert(this.treePathForUri(file.uri), file);
+        }
+        const calculateComputed = (path, node) => {
+            if (node.value) {
+                return node.value;
+            }
+            const fileCoverage = {
+                uri: this.treePathToUri(path),
+                statement: ICoveredCount.empty(),
+            };
+            if (node.children) {
+                for (const [prefix, child] of node.children) {
+                    path.push(prefix);
+                    const v = calculateComputed(path, child);
+                    path.pop();
+                    ICoveredCount.sum(fileCoverage.statement, v.statement);
+                    if (v.branch) {
+                        ICoveredCount.sum(fileCoverage.branch ??= ICoveredCount.empty(), v.branch);
+                    }
+                    if (v.function) {
+                        ICoveredCount.sum(fileCoverage.function ??= ICoveredCount.empty(), v.function);
+                    }
+                }
+            }
+            return node.value = ( new ComputedFileCoverage(fileCoverage));
+        };
+        for (const node of tree.nodes) {
+            calculateComputed([], node);
+        }
+        return tree;
+    }
+    *treePathForUri(uri) {
+        yield uri.scheme;
+        yield uri.authority;
+        yield* uri.path.split('/');
+    }
+    treePathToUri(path) {
+        return ( URI.from({ scheme: path[0], authority: path[1], path: path.slice(2).join('/') }));
+    }
+}
+class AbstractFileCoverage {
+    get tpc() {
+        let numerator = this.statement.covered;
+        let denominator = this.statement.total;
+        if (this.branch) {
+            numerator += this.branch.covered;
+            denominator += this.branch.total;
+        }
+        if (this.function) {
+            numerator += this.function.covered;
+            denominator += this.function.total;
+        }
+        return denominator === 0 ? 1 : numerator / denominator;
+    }
+    constructor(coverage) {
+        this.uri = URI.revive(coverage.uri);
+        this.statement = coverage.statement;
+        this.branch = coverage.branch;
+        this.function = coverage.function;
+    }
+}
+class ComputedFileCoverage extends AbstractFileCoverage {
+}
+class FileCoverage extends AbstractFileCoverage {
+    constructor(coverage, index, accessor) {
+        super(coverage);
+        this.index = index;
+        this.accessor = accessor;
+        this._details = coverage.details;
+    }
+    async details(token = CancellationToken.None) {
+        this._details ??= this.accessor.resolveFileCoverage(this.index, token);
+        try {
+            return await this._details;
+        }
+        catch (e) {
+            this._details = undefined;
+            throw e;
+        }
+    }
+}
+export { AbstractFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage };

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

@@ -0,0 +1,74 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IViewsService } from '../../../common/views.js';
+import { ITestResultService } from './testResultService.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+const ITestCoverageService = ( createDecorator('testCoverageService'));
+let TestCoverageService = class TestCoverageService extends Disposable {
+    constructor(contextKeyService, resultService, viewsService, notificationService) {
+        super();
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.lastOpenCts = this._register(( new MutableDisposable()));
+        this.selected = observableValue('testCoverage', undefined);
+        this._isOpenKey = TestingContextKeys.isTestCoverageOpen.bindTo(contextKeyService);
+        this._register(resultService.onResultsChanged(evt => {
+            if ('completed' in evt) {
+                const coverage = evt.completed.tasks.find(t => t.coverage.get());
+                if (coverage) {
+                    this.openCoverage(coverage, false);
+                }
+            }
+            else if ('removed' in evt && this.selected.get()) {
+                const taskId = this.selected.get()?.fromTaskId;
+                if (( evt.removed.some(e => ( e.tasks.some(t => t.id === taskId))))) {
+                    this.closeCoverage();
+                }
+            }
+        }));
+    }
+    async openCoverage(task, focus = true) {
+        this.lastOpenCts.value?.cancel();
+        const cts = this.lastOpenCts.value = ( new CancellationTokenSource());
+        const getCoverage = task.coverage.get();
+        if (!getCoverage) {
+            return;
+        }
+        try {
+            const coverage = await getCoverage(cts.token);
+            this.selected.set(coverage, undefined);
+            this._isOpenKey.set(true);
+        }
+        catch (e) {
+            if (!cts.token.isCancellationRequested) {
+                this.notificationService.error(( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/testCoverageService',
+                    'testCoverageError',
+                    'Failed to load test coverage: {}',
+                    String(e)
+                )));
+            }
+            return;
+        }
+        if (focus && !cts.token.isCancellationRequested) {
+            this.viewsService.openView("workbench.view.testCoverage" , true);
+        }
+    }
+    closeCoverage() {
+        this._isOpenKey.set(false);
+        this.selected.set(undefined, undefined);
+    }
+};
+TestCoverageService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ITestResultService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, INotificationService))
+], TestCoverageService));
+export { ITestCoverageService, TestCoverageService };

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

@@ -0,0 +1,116 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { splitGlobAware } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { MutableObservableValue } from './observableValue.js';
+import { StoredValue } from './storedValue.js';
+import { namespaceTestTag } from './testTypes.js';
+const ITestExplorerFilterState = ( createDecorator('testingFilterState'));
+const tagRe = /!?@([^ ,:]+)/g;
+const trimExtraWhitespace = (str) => str.replace(/\s\s+/g, ' ').trim();
+let TestExplorerFilterState = class TestExplorerFilterState extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.focusEmitter = ( new Emitter());
+        this.termFilterState = {};
+        this.globList = [];
+        this.includeTags = ( new Set());
+        this.excludeTags = ( new Set());
+        this.text = this._register(( new MutableObservableValue('')));
+        this.fuzzy = this._register(MutableObservableValue.stored(( new StoredValue({
+            key: 'testHistoryFuzzy',
+            scope: 0 ,
+            target: 0 ,
+        }, this.storageService)), false));
+        this.reveal = this._register(( new MutableObservableValue(undefined)));
+        this.onDidRequestInputFocus = this.focusEmitter.event;
+    }
+    focusInput() {
+        this.focusEmitter.fire();
+    }
+    setText(text) {
+        if (text === this.text.value) {
+            return;
+        }
+        this.termFilterState = {};
+        this.globList = [];
+        this.includeTags.clear();
+        this.excludeTags.clear();
+        let globText = '';
+        let lastIndex = 0;
+        for (const match of text.matchAll(tagRe)) {
+            let nextIndex = match.index + match[0].length;
+            const tag = match[0];
+            if (allTestFilterTerms.includes(tag)) {
+                this.termFilterState[tag] = true;
+            }
+            if (text[nextIndex] === ':') {
+                nextIndex++;
+                let delimiter = text[nextIndex];
+                if (delimiter !== `"` && delimiter !== `'`) {
+                    delimiter = ' ';
+                }
+                else {
+                    nextIndex++;
+                }
+                let tagId = '';
+                while (nextIndex < text.length && text[nextIndex] !== delimiter) {
+                    if (text[nextIndex] === '\\') {
+                        tagId += text[nextIndex + 1];
+                        nextIndex += 2;
+                    }
+                    else {
+                        tagId += text[nextIndex];
+                        nextIndex++;
+                    }
+                }
+                if (match[0].startsWith('!')) {
+                    this.excludeTags.add(namespaceTestTag(match[1], tagId));
+                }
+                else {
+                    this.includeTags.add(namespaceTestTag(match[1], tagId));
+                }
+                nextIndex++;
+            }
+            globText += text.slice(lastIndex, match.index);
+            lastIndex = nextIndex;
+        }
+        globText += text.slice(lastIndex).trim();
+        if (globText.length) {
+            for (const filter of ( splitGlobAware(globText, ',').map(s => s.trim())).filter(s => !!s.length)) {
+                if (filter.startsWith('!')) {
+                    this.globList.push({ include: false, text: filter.slice(1).toLowerCase() });
+                }
+                else {
+                    this.globList.push({ include: true, text: filter.toLowerCase() });
+                }
+            }
+        }
+        this.text.value = text;
+    }
+    isFilteringFor(term) {
+        return !!this.termFilterState[term];
+    }
+    toggleFilteringFor(term, shouldFilter) {
+        const text = this.text.value.trim();
+        if (shouldFilter !== false && !this.termFilterState[term]) {
+            this.setText(text ? `${text} ${term}` : term);
+        }
+        else if (shouldFilter !== true && this.termFilterState[term]) {
+            this.setText(trimExtraWhitespace(text.replace(term, '')));
+        }
+    }
+};
+TestExplorerFilterState = ( __decorate([
+    ( __param(0, IStorageService))
+], TestExplorerFilterState));
+const allTestFilterTerms = [
+    "@failed" ,
+    "@executed" ,
+    "@doc" ,
+    "@hidden" ,
+];
+export { ITestExplorerFilterState, TestExplorerFilterState };