@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/api/browser/mainThreadTelemetry.js

@@ -1,51 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { TELEMETRY_SETTING_ID, TELEMETRY_OLD_SETTING_ID, ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { supportsTelemetry } from '../../../platform/telemetry/common/telemetryUtils.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-var MainThreadTelemetry_1;
-let MainThreadTelemetry = class MainThreadTelemetry extends Disposable {
-    static { MainThreadTelemetry_1 = this; }
-    static { this._name = 'pluginHostTelemetry'; }
-    constructor(extHostContext, _telemetryService, _configurationService, _environmentService, _productService) {
-        super();
-        this._telemetryService = _telemetryService;
-        this._configurationService = _configurationService;
-        this._environmentService = _environmentService;
-        this._productService = _productService;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTelemetry));
-        if (supportsTelemetry(this._productService, this._environmentService)) {
-            this._register(this._configurationService.onDidChangeConfiguration(e => {
-                if (e.affectsConfiguration(TELEMETRY_SETTING_ID) || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID)) {
-                    this._proxy.$onDidChangeTelemetryLevel(this.telemetryLevel);
-                }
-            }));
-        }
-        this._proxy.$initializeTelemetryLevel(this.telemetryLevel, supportsTelemetry(this._productService, this._environmentService), this._productService.enabledTelemetryLevels);
-    }
-    get telemetryLevel() {
-        if (!supportsTelemetry(this._productService, this._environmentService)) {
-            return 0 ;
-        }
-        return this._telemetryService.telemetryLevel;
-    }
-    $publicLog(eventName, data = Object.create(null)) {
-        data[MainThreadTelemetry_1._name] = true;
-        this._telemetryService.publicLog(eventName, data);
-    }
-    $publicLog2(eventName, data) {
-        this.$publicLog(eventName, data);
-    }
-};
-MainThreadTelemetry = MainThreadTelemetry_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTelemetry),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, IProductService))
-], MainThreadTelemetry);
-export { MainThreadTelemetry };

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.js

@@ -1,410 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, MutableDisposable, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { TerminalLocation, TerminalExitReason } from '../../../platform/terminal/common/terminal.js';
-import { TerminalDataBufferer } from '../../../platform/terminal/common/terminalDataBuffering.js';
-import { ITerminalService, ITerminalGroupService, ITerminalEditorService } from '../../contrib/terminal/browser/terminal.js';
-import { TerminalProcessExtHostProxy } from '../../contrib/terminal/browser/terminalProcessExtHostProxy.js';
-import { IEnvironmentVariableService } from '../../contrib/terminal/common/environmentVariable.js';
-import { serializeEnvironmentVariableCollection, deserializeEnvironmentVariableCollection, deserializeEnvironmentDescriptionMap } from '../../../platform/terminal/common/environmentVariableShared.js';
-import { ITerminalProfileResolverService, ITerminalProfileService } from '../../contrib/terminal/common/terminal.js';
-import { IRemoteAgentService } from '../../services/remote/common/remoteAgentService.js';
-import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ITerminalLinkProviderService } from '../../contrib/terminalContrib/links/browser/links.js';
-import { ITerminalQuickFixService, TerminalQuickFixType } from '../../contrib/terminalContrib/quickFix/browser/quickFix.js';
-let MainThreadTerminalService = class MainThreadTerminalService {
-    constructor(_extHostContext, _terminalService, _terminalLinkProviderService, _terminalQuickFixService, _instantiationService, _environmentVariableService, _logService, _terminalProfileResolverService, remoteAgentService, _terminalGroupService, _terminalEditorService, _terminalProfileService) {
-        this._extHostContext = _extHostContext;
-        this._terminalService = _terminalService;
-        this._terminalLinkProviderService = _terminalLinkProviderService;
-        this._terminalQuickFixService = _terminalQuickFixService;
-        this._instantiationService = _instantiationService;
-        this._environmentVariableService = _environmentVariableService;
-        this._logService = _logService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._terminalGroupService = _terminalGroupService;
-        this._terminalEditorService = _terminalEditorService;
-        this._terminalProfileService = _terminalProfileService;
-        this._store = ( new DisposableStore());
-        this._extHostTerminals = ( new Map());
-        this._terminalProcessProxies = ( new Map());
-        this._profileProviders = ( new Map());
-        this._quickFixProviders = ( new Map());
-        this._dataEventTracker = ( new MutableDisposable());
-        this._sendCommandEventListener = ( new MutableDisposable());
-        this._os = OS;
-        this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostTerminalService));
-        this._store.add(_terminalService.onDidCreateInstance((instance) => {
-            this._onTerminalOpened(instance);
-            this._onInstanceDimensionsChanged(instance);
-        }));
-        this._store.add(_terminalService.onDidDisposeInstance(instance => this._onTerminalDisposed(instance)));
-        this._store.add(_terminalService.onDidReceiveProcessId(instance => this._onTerminalProcessIdReady(instance)));
-        this._store.add(_terminalService.onDidChangeInstanceDimensions(instance => this._onInstanceDimensionsChanged(instance)));
-        this._store.add(_terminalService.onDidMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance)));
-        this._store.add(_terminalService.onDidRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e)));
-        this._store.add(_terminalService.onDidChangeActiveInstance(instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)));
-        this._store.add(_terminalService.onDidChangeInstanceTitle(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
-        this._store.add(_terminalService.onDidInputInstanceData(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId)));
-        this._store.add(_terminalService.onDidChangeSelection(instance => this._proxy.$acceptTerminalSelection(instance.instanceId, instance.selection)));
-        for (const instance of this._terminalService.instances) {
-            this._onTerminalOpened(instance);
-            instance.processReady.then(() => this._onTerminalProcessIdReady(instance));
-        }
-        const activeInstance = this._terminalService.activeInstance;
-        if (activeInstance) {
-            this._proxy.$acceptActiveTerminalChanged(activeInstance.instanceId);
-        }
-        if (this._environmentVariableService.collections.size > 0) {
-            const collectionAsArray = [...this._environmentVariableService.collections.entries()];
-            const serializedCollections = ( collectionAsArray.map(e => {
-                return [e[0], serializeEnvironmentVariableCollection(e[1].map)];
-            }));
-            this._proxy.$initEnvironmentVariableCollections(serializedCollections);
-        }
-        remoteAgentService.getEnvironment().then(async (env) => {
-            this._os = env?.os || OS;
-            this._updateDefaultProfile();
-        });
-        this._store.add(this._terminalProfileService.onDidChangeAvailableProfiles(() => this._updateDefaultProfile()));
-    }
-    dispose() {
-        this._store.dispose();
-        this._linkProvider?.dispose();
-        for (const provider of ( this._profileProviders.values())) {
-            provider.dispose();
-        }
-        for (const provider of ( this._quickFixProviders.values())) {
-            provider.dispose();
-        }
-    }
-    async _updateDefaultProfile() {
-        const remoteAuthority = this._extHostContext.remoteAuthority ?? undefined;
-        const defaultProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os });
-        const defaultAutomationProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os, allowAutomationShell: true });
-        this._proxy.$acceptDefaultProfile(...(await Promise.all([defaultProfile, defaultAutomationProfile])));
-    }
-    async _getTerminalInstance(id) {
-        if (typeof id === 'string') {
-            return this._extHostTerminals.get(id);
-        }
-        return this._terminalService.getInstanceFromId(id);
-    }
-    async $createTerminal(extHostTerminalId, launchConfig) {
-        const shellLaunchConfig = {
-            name: launchConfig.name,
-            executable: launchConfig.shellPath,
-            args: launchConfig.shellArgs,
-            cwd: typeof launchConfig.cwd === 'string' ? launchConfig.cwd : URI.revive(launchConfig.cwd),
-            icon: launchConfig.icon,
-            color: launchConfig.color,
-            initialText: launchConfig.initialText,
-            waitOnExit: launchConfig.waitOnExit,
-            ignoreConfigurationCwd: true,
-            env: launchConfig.env,
-            strictEnv: launchConfig.strictEnv,
-            hideFromUser: launchConfig.hideFromUser,
-            customPtyImplementation: launchConfig.isExtensionCustomPtyTerminal
-                ? (id, cols, rows) => ( new TerminalProcessExtHostProxy(id, cols, rows, this._terminalService))
-                : undefined,
-            extHostTerminalId,
-            isFeatureTerminal: launchConfig.isFeatureTerminal,
-            isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal,
-            useShellEnvironment: launchConfig.useShellEnvironment,
-            isTransient: launchConfig.isTransient
-        };
-        const terminal = Promises.withAsyncBody(async (r) => {
-            const terminal = await this._terminalService.createTerminal({
-                config: shellLaunchConfig,
-                location: await this._deserializeParentTerminal(launchConfig.location)
-            });
-            r(terminal);
-        });
-        this._extHostTerminals.set(extHostTerminalId, terminal);
-        const terminalInstance = await terminal;
-        this._store.add(terminalInstance.onDisposed(() => {
-            this._extHostTerminals.delete(extHostTerminalId);
-        }));
-    }
-    async _deserializeParentTerminal(location) {
-        if (typeof location === 'object' && 'parentTerminal' in location) {
-            const parentTerminal = await this._extHostTerminals.get(( location.parentTerminal.toString()));
-            return parentTerminal ? { parentTerminal } : undefined;
-        }
-        return location;
-    }
-    async $show(id, preserveFocus) {
-        const terminalInstance = await this._getTerminalInstance(id);
-        if (terminalInstance) {
-            this._terminalService.setActiveInstance(terminalInstance);
-            if (terminalInstance.target === TerminalLocation.Editor) {
-                await this._terminalEditorService.revealActiveEditor(preserveFocus);
-            }
-            else {
-                await this._terminalGroupService.showPanel(!preserveFocus);
-            }
-        }
-    }
-    async $hide(id) {
-        const instanceToHide = await this._getTerminalInstance(id);
-        const activeInstance = this._terminalService.activeInstance;
-        if (activeInstance && activeInstance.instanceId === instanceToHide?.instanceId && activeInstance.target !== TerminalLocation.Editor) {
-            this._terminalGroupService.hidePanel();
-        }
-    }
-    async $dispose(id) {
-        (await this._getTerminalInstance(id))?.dispose(TerminalExitReason.Extension);
-    }
-    async $sendText(id, text, addNewLine) {
-        const instance = await this._getTerminalInstance(id);
-        await instance?.sendText(text, addNewLine);
-    }
-    $sendProcessExit(terminalId, exitCode) {
-        this._terminalProcessProxies.get(terminalId)?.emitExit(exitCode);
-    }
-    $startSendingDataEvents() {
-        if (!this._dataEventTracker.value) {
-            this._dataEventTracker.value = this._instantiationService.createInstance(TerminalDataEventTracker, (id, data) => {
-                this._onTerminalData(id, data);
-            });
-            for (const instance of this._terminalService.instances) {
-                for (const data of instance.initialDataEvents || []) {
-                    this._onTerminalData(instance.instanceId, data);
-                }
-            }
-        }
-    }
-    $stopSendingDataEvents() {
-        this._dataEventTracker.clear();
-    }
-    $startSendingCommandEvents() {
-        this._logService.info('$startSendingCommandEvents');
-        if (this._sendCommandEventListener.value) {
-            return;
-        }
-        const multiplexer = this._terminalService.onInstanceCapabilityEvent(2 , capability => capability.onCommandFinished);
-        multiplexer.event(e => {
-            this._onDidExecuteCommand(e.instance.instanceId, {
-                commandLine: e.data.command,
-                cwd: e.data.cwd,
-                exitCode: e.data.exitCode,
-                output: e.data.getOutput()
-            });
-        });
-        this._sendCommandEventListener.value = multiplexer;
-    }
-    $stopSendingCommandEvents() {
-        this._logService.info('$stopSendingCommandEvents');
-        this._sendCommandEventListener.clear();
-    }
-    $startLinkProvider() {
-        this._linkProvider?.dispose();
-        this._linkProvider = this._terminalLinkProviderService.registerLinkProvider(( new ExtensionTerminalLinkProvider(this._proxy)));
-    }
-    $stopLinkProvider() {
-        this._linkProvider?.dispose();
-        this._linkProvider = undefined;
-    }
-    $registerProcessSupport(isSupported) {
-        this._terminalService.registerProcessSupport(isSupported);
-    }
-    $registerProfileProvider(id, extensionIdentifier) {
-        this._profileProviders.set(id, this._terminalProfileService.registerTerminalProfileProvider(extensionIdentifier, id, {
-            createContributedTerminalProfile: async (options) => {
-                return this._proxy.$createContributedProfileTerminal(id, options);
-            }
-        }));
-    }
-    $unregisterProfileProvider(id) {
-        this._profileProviders.get(id)?.dispose();
-        this._profileProviders.delete(id);
-    }
-    async $registerQuickFixProvider(id, extensionId) {
-        this._quickFixProviders.set(id, this._terminalQuickFixService.registerQuickFixProvider(id, {
-            provideTerminalQuickFixes: async (terminalCommand, lines, options, token) => {
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                if (options.outputMatcher?.length && options.outputMatcher.length > 40) {
-                    options.outputMatcher.length = 40;
-                    this._logService.warn('Cannot exceed output matcher length of 40');
-                }
-                const commandLineMatch = terminalCommand.command.match(options.commandLineMatcher);
-                if (!commandLineMatch || !lines) {
-                    return;
-                }
-                const outputMatcher = options.outputMatcher;
-                let outputMatch;
-                if (outputMatcher) {
-                    outputMatch = getOutputMatchForLines(lines, outputMatcher);
-                }
-                if (!outputMatch) {
-                    return;
-                }
-                const matchResult = { commandLineMatch, outputMatch, commandLine: terminalCommand.command };
-                if (matchResult) {
-                    const result = await this._proxy.$provideTerminalQuickFixes(id, matchResult, token);
-                    if (result && Array.isArray(result)) {
-                        return ( result.map(r => parseQuickFix(id, extensionId, r)));
-                    }
-                    else if (result) {
-                        return parseQuickFix(id, extensionId, result);
-                    }
-                }
-                return;
-            }
-        }));
-    }
-    $unregisterQuickFixProvider(id) {
-        this._quickFixProviders.get(id)?.dispose();
-        this._quickFixProviders.delete(id);
-    }
-    _onActiveTerminalChanged(terminalId) {
-        this._proxy.$acceptActiveTerminalChanged(terminalId);
-    }
-    _onTerminalData(terminalId, data) {
-        this._proxy.$acceptTerminalProcessData(terminalId, data);
-    }
-    _onDidExecuteCommand(terminalId, command) {
-        this._proxy.$acceptDidExecuteCommand(terminalId, command);
-    }
-    _onTitleChanged(terminalId, name) {
-        this._proxy.$acceptTerminalTitleChange(terminalId, name);
-    }
-    _onTerminalDisposed(terminalInstance) {
-        this._proxy.$acceptTerminalClosed(terminalInstance.instanceId, terminalInstance.exitCode, terminalInstance.exitReason ?? TerminalExitReason.Unknown);
-    }
-    _onTerminalOpened(terminalInstance) {
-        const extHostTerminalId = terminalInstance.shellLaunchConfig.extHostTerminalId;
-        const shellLaunchConfigDto = {
-            name: terminalInstance.shellLaunchConfig.name,
-            executable: terminalInstance.shellLaunchConfig.executable,
-            args: terminalInstance.shellLaunchConfig.args,
-            cwd: terminalInstance.shellLaunchConfig.cwd,
-            env: terminalInstance.shellLaunchConfig.env,
-            hideFromUser: terminalInstance.shellLaunchConfig.hideFromUser
-        };
-        this._proxy.$acceptTerminalOpened(terminalInstance.instanceId, extHostTerminalId, terminalInstance.title, shellLaunchConfigDto);
-    }
-    _onTerminalProcessIdReady(terminalInstance) {
-        if (terminalInstance.processId === undefined) {
-            return;
-        }
-        this._proxy.$acceptTerminalProcessId(terminalInstance.instanceId, terminalInstance.processId);
-    }
-    _onInstanceDimensionsChanged(instance) {
-        this._proxy.$acceptTerminalDimensions(instance.instanceId, instance.cols, instance.rows);
-    }
-    _onInstanceMaximumDimensionsChanged(instance) {
-        this._proxy.$acceptTerminalMaximumDimensions(instance.instanceId, instance.maxCols, instance.maxRows);
-    }
-    _onRequestStartExtensionTerminal(request) {
-        const proxy = request.proxy;
-        this._terminalProcessProxies.set(proxy.instanceId, proxy);
-        const initialDimensions = request.cols && request.rows ? {
-            columns: request.cols,
-            rows: request.rows
-        } : undefined;
-        this._proxy.$startExtensionTerminal(proxy.instanceId, initialDimensions).then(request.callback);
-        proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.instanceId, data));
-        proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.instanceId, immediate));
-        proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.instanceId));
-        proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.instanceId));
-    }
-    $sendProcessData(terminalId, data) {
-        this._terminalProcessProxies.get(terminalId)?.emitData(data);
-    }
-    $sendProcessReady(terminalId, pid, cwd, windowsPty) {
-        this._terminalProcessProxies.get(terminalId)?.emitReady(pid, cwd, windowsPty);
-    }
-    $sendProcessProperty(terminalId, property) {
-        if (property.type === "title" ) {
-            const instance = this._terminalService.getInstanceFromId(terminalId);
-            instance?.rename(property.value);
-        }
-        this._terminalProcessProxies.get(terminalId)?.emitProcessProperty(property);
-    }
-    $setEnvironmentVariableCollection(extensionIdentifier, persistent, collection, descriptionMap) {
-        if (collection) {
-            const translatedCollection = {
-                persistent,
-                map: deserializeEnvironmentVariableCollection(collection),
-                descriptionMap: deserializeEnvironmentDescriptionMap(descriptionMap)
-            };
-            this._environmentVariableService.set(extensionIdentifier, translatedCollection);
-        }
-        else {
-            this._environmentVariableService.delete(extensionIdentifier);
-        }
-    }
-};
-MainThreadTerminalService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTerminalService),
-    ( __param(1, ITerminalService)),
-    ( __param(2, ITerminalLinkProviderService)),
-    ( __param(3, ITerminalQuickFixService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IEnvironmentVariableService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ITerminalProfileResolverService)),
-    ( __param(8, IRemoteAgentService)),
-    ( __param(9, ITerminalGroupService)),
-    ( __param(10, ITerminalEditorService)),
-    ( __param(11, ITerminalProfileService))
-], MainThreadTerminalService);
-let TerminalDataEventTracker = class TerminalDataEventTracker extends Disposable {
-    constructor(_callback, _terminalService) {
-        super();
-        this._callback = _callback;
-        this._terminalService = _terminalService;
-        this._register(this._bufferer = ( new TerminalDataBufferer(this._callback)));
-        for (const instance of this._terminalService.instances) {
-            this._registerInstance(instance);
-        }
-        this._register(this._terminalService.onDidCreateInstance(instance => this._registerInstance(instance)));
-        this._register(this._terminalService.onDidDisposeInstance(instance => this._bufferer.stopBuffering(instance.instanceId)));
-    }
-    _registerInstance(instance) {
-        this._register(this._bufferer.startBuffering(instance.instanceId, instance.onData));
-    }
-};
-TerminalDataEventTracker = ( __decorate([
-    ( __param(1, ITerminalService))
-], TerminalDataEventTracker));
-class ExtensionTerminalLinkProvider {
-    constructor(_proxy) {
-        this._proxy = _proxy;
-    }
-    async provideLinks(instance, line) {
-        const proxy = this._proxy;
-        const extHostLinks = await proxy.$provideLinks(instance.instanceId, line);
-        return ( extHostLinks.map(dto => ({
-            id: dto.id,
-            startIndex: dto.startIndex,
-            length: dto.length,
-            label: dto.label,
-            activate: () => proxy.$activateLink(instance.instanceId, dto.id)
-        })));
-    }
-}
-function getOutputMatchForLines(lines, outputMatcher) {
-    const match = lines.join('\n').match(outputMatcher.lineMatcher);
-    return match ? { regexMatch: match, outputLines: lines } : undefined;
-}
-function parseQuickFix(id, source, fix) {
-    let type = TerminalQuickFixType.TerminalCommand;
-    if ('uri' in fix) {
-        fix.uri = URI.revive(fix.uri);
-        type = TerminalQuickFixType.Opener;
-    }
-    else if ('id' in fix) {
-        type = TerminalQuickFixType.VscodeCommand;
-    }
-    return { id, type, source, ...fix };
-}
-export { MainThreadTerminalService, getOutputMatchForLines };

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -1,180 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, MutableDisposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { MutableObservableValue } from '../../contrib/testing/common/observableValue.js';
-import { ITestItem, ITestMessage, TestsDiffOp } from '../../contrib/testing/common/testTypes.js';
-import { TestCoverage } from '../../contrib/testing/common/testCoverage.js';
-import { ITestProfileService } from '../../contrib/testing/common/testProfileService.js';
-import { LiveTestResult } from '../../contrib/testing/common/testResult.js';
-import { ITestResultService } from '../../contrib/testing/common/testResultService.js';
-import { ITestService } from '../../contrib/testing/common/testService.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { WellDefinedPrefixTree } from '../../../base/common/prefixTree.js';
-import { TestId } from '../../contrib/testing/common/testId.js';
-let MainThreadTesting = class MainThreadTesting extends Disposable {
-    constructor(extHostContext, testService, testProfiles, resultService) {
-        super();
-        this.testService = testService;
-        this.testProfiles = testProfiles;
-        this.resultService = resultService;
-        this.diffListener = this._register(( new MutableDisposable()));
-        this.testProviderRegistrations = ( new Map());
-        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTesting));
-        this._register(this.testService.onDidCancelTestRun(({ runId }) => {
-            this.proxy.$cancelExtensionTestRun(runId);
-        }));
-        this._register(resultService.onResultsChanged(evt => {
-            const results = 'completed' in evt ? evt.completed : ('inserted' in evt ? evt.inserted : undefined);
-            const serialized = results?.toJSONWithMessages();
-            if (serialized) {
-                this.proxy.$publishTestResults([serialized]);
-            }
-        }));
-    }
-    $markTestRetired(testIds) {
-        let tree;
-        if (testIds) {
-            tree = ( new WellDefinedPrefixTree());
-            for (const id of testIds) {
-                tree.insert(TestId.fromString(id).path, undefined);
-            }
-        }
-        for (const result of this.resultService.results) {
-            if (result instanceof LiveTestResult) {
-                result.markRetired(tree);
-            }
-        }
-    }
-    $publishTestRunProfile(profile) {
-        const controller = this.testProviderRegistrations.get(profile.controllerId);
-        if (controller) {
-            this.testProfiles.addProfile(controller.instance, profile);
-        }
-    }
-    $updateTestRunConfig(controllerId, profileId, update) {
-        this.testProfiles.updateProfile(controllerId, profileId, update);
-    }
-    $removeTestProfile(controllerId, profileId) {
-        this.testProfiles.removeProfile(controllerId, profileId);
-    }
-    $addTestsToRun(controllerId, runId, tests) {
-        this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(ITestItem.deserialize))));
-    }
-    $signalCoverageAvailable(runId, taskId) {
-        this.withLiveRun(runId, run => {
-            const task = run.tasks.find(t => t.id === taskId);
-            if (!task) {
-                return;
-            }
-            task.coverage.value = ( new TestCoverage({
-                provideFileCoverage: async (token) => revive(await this.proxy.$provideFileCoverage(runId, taskId, token)),
-                resolveFileCoverage: (i, token) => this.proxy.$resolveFileCoverage(runId, taskId, i, token),
-            }));
-        });
-    }
-    $startedExtensionTestRun(req) {
-        this.resultService.createLiveResult(req);
-    }
-    $startedTestRunTask(runId, task) {
-        this.withLiveRun(runId, r => r.addTask(task));
-    }
-    $finishedTestRunTask(runId, taskId) {
-        this.withLiveRun(runId, r => r.markTaskComplete(taskId));
-    }
-    $finishedExtensionTestRun(runId) {
-        this.withLiveRun(runId, r => r.markComplete());
-    }
-    $updateTestStateInRun(runId, taskId, testId, state, duration) {
-        this.withLiveRun(runId, r => r.updateState(testId, taskId, state, duration));
-    }
-    $appendOutputToRun(runId, taskId, output, locationDto, testId) {
-        const location = locationDto && {
-            uri: URI.revive(locationDto.uri),
-            range: Range.lift(locationDto.range)
-        };
-        this.withLiveRun(runId, r => r.appendOutput(output, taskId, location, testId));
-    }
-    $appendTestMessagesInRun(runId, taskId, testId, messages) {
-        const r = this.resultService.getResult(runId);
-        if (r && r instanceof LiveTestResult) {
-            for (const message of messages) {
-                r.appendMessage(testId, taskId, ITestMessage.deserialize(message));
-            }
-        }
-    }
-    $registerTestController(controllerId, labelStr, canRefreshValue) {
-        const disposable = ( new DisposableStore());
-        const label = disposable.add(( new MutableObservableValue(labelStr)));
-        const canRefresh = disposable.add(( new MutableObservableValue(canRefreshValue)));
-        const controller = {
-            id: controllerId,
-            label,
-            canRefresh,
-            syncTests: () => this.proxy.$syncTests(),
-            refreshTests: token => this.proxy.$refreshTests(controllerId, token),
-            configureRunProfile: id => this.proxy.$configureRunProfile(controllerId, id),
-            runTests: (reqs, token) => this.proxy.$runControllerTests(reqs, token),
-            startContinuousRun: (reqs, token) => this.proxy.$startContinuousRun(reqs, token),
-            expandTest: (testId, levels) => this.proxy.$expandTest(testId, isFinite(levels) ? levels : -1),
-        };
-        disposable.add(toDisposable(() => this.testProfiles.removeProfile(controllerId)));
-        disposable.add(this.testService.registerTestController(controllerId, controller));
-        this.testProviderRegistrations.set(controllerId, {
-            instance: controller,
-            label,
-            canRefresh,
-            disposable
-        });
-    }
-    $updateController(controllerId, patch) {
-        const controller = this.testProviderRegistrations.get(controllerId);
-        if (!controller) {
-            return;
-        }
-        if (patch.label !== undefined) {
-            controller.label.value = patch.label;
-        }
-        if (patch.canRefresh !== undefined) {
-            controller.canRefresh.value = patch.canRefresh;
-        }
-    }
-    $unregisterTestController(controllerId) {
-        this.testProviderRegistrations.get(controllerId)?.disposable.dispose();
-        this.testProviderRegistrations.delete(controllerId);
-    }
-    $subscribeToDiffs() {
-        this.proxy.$acceptDiff(( this.testService.collection.getReviverDiff().map(TestsDiffOp.serialize)));
-        this.diffListener.value = this.testService.onDidProcessDiff(this.proxy.$acceptDiff, this.proxy);
-    }
-    $unsubscribeFromDiffs() {
-        this.diffListener.clear();
-    }
-    $publishDiff(controllerId, diff) {
-        this.testService.publishDiff(controllerId, ( diff.map(TestsDiffOp.deserialize)));
-    }
-    async $runTests(req, token) {
-        const result = await this.testService.runResolvedTests(req, token);
-        return result.id;
-    }
-    dispose() {
-        super.dispose();
-        for (const subscription of ( this.testProviderRegistrations.values())) {
-            subscription.disposable.dispose();
-        }
-        this.testProviderRegistrations.clear();
-    }
-    withLiveRun(runId, fn) {
-        const r = this.resultService.getResult(runId);
-        return r && r instanceof LiveTestResult ? fn(r) : undefined;
-    }
-};
-MainThreadTesting = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTesting),
-    ( __param(1, ITestService)),
-    ( __param(2, ITestProfileService)),
-    ( __param(3, ITestResultService))
-], MainThreadTesting);
-export { MainThreadTesting };

package/vscode/src/vs/workbench/api/browser/mainThreadTheming.js

@@ -1,22 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-let MainThreadTheming = class MainThreadTheming {
-    constructor(extHostContext, themeService) {
-        this._themeService = themeService;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTheming));
-        this._themeChangeListener = this._themeService.onDidColorThemeChange(e => {
-            this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
-        });
-        this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
-    }
-    dispose() {
-        this._themeChangeListener.dispose();
-    }
-};
-MainThreadTheming = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTheming),
-    ( __param(1, IThemeService))
-], MainThreadTheming);
-export { MainThreadTheming };