@codingame/monaco-vscode-extensions-service-override 4.0.0 → 4.1.0

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

@@ -1,560 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
-import { CommentsPanel } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsView';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
-import { IViewDescriptorService, Extensions } from 'vscode/vscode/vs/workbench/common/views';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
-
-class MainThreadCommentThread {
-    get input() {
-        return this._input;
-    }
-    set input(value) {
-        this._input = value;
-        this._onDidChangeInput.fire(value);
-    }
-    get onDidChangeInput() { return this._onDidChangeInput.event; }
-    get label() {
-        return this._label;
-    }
-    set label(label) {
-        this._label = label;
-        this._onDidChangeLabel.fire(this._label);
-    }
-    get contextValue() {
-        return this._contextValue;
-    }
-    set contextValue(context) {
-        this._contextValue = context;
-    }
-    get comments() {
-        return this._comments;
-    }
-    set comments(newComments) {
-        this._comments = newComments;
-        this._onDidChangeComments.fire(this._comments);
-    }
-    get onDidChangeComments() { return this._onDidChangeComments.event; }
-    set range(range) {
-        this._range = range;
-        this._onDidChangeRange.fire(this._range);
-    }
-    get range() {
-        return this._range;
-    }
-    get onDidChangeCanReply() { return this._onDidChangeCanReply.event; }
-    set canReply(state) {
-        this._canReply = state;
-        this._onDidChangeCanReply.fire(this._canReply);
-    }
-    get canReply() {
-        return this._canReply;
-    }
-    get collapsibleState() {
-        return this._collapsibleState;
-    }
-    set collapsibleState(newState) {
-        this._collapsibleState = newState;
-        this._onDidChangeCollapsibleState.fire(this._collapsibleState);
-    }
-    get initialCollapsibleState() {
-        return this._initialCollapsibleState;
-    }
-    set initialCollapsibleState(initialCollapsibleState) {
-        this._initialCollapsibleState = initialCollapsibleState;
-        if (this.collapsibleState === undefined) {
-            this.collapsibleState = this.initialCollapsibleState;
-        }
-        this._onDidChangeInitialCollapsibleState.fire(initialCollapsibleState);
-    }
-    get isDisposed() {
-        return this._isDisposed;
-    }
-    isDocumentCommentThread() {
-        return this._range === undefined || Range.isIRange(this._range);
-    }
-    get state() {
-        return this._state;
-    }
-    set state(newState) {
-        this._state = newState;
-        this._onDidChangeState.fire(this._state);
-    }
-    get applicability() {
-        return this._applicability;
-    }
-    set applicability(value) {
-        this._applicability = value;
-        this._onDidChangeApplicability.fire(value);
-    }
-    get isTemplate() {
-        return this._isTemplate;
-    }
-    constructor(commentThreadHandle, controllerHandle, extensionId, threadId, resource, _range, _canReply, _isTemplate) {
-        this.commentThreadHandle = commentThreadHandle;
-        this.controllerHandle = controllerHandle;
-        this.extensionId = extensionId;
-        this.threadId = threadId;
-        this.resource = resource;
-        this._range = _range;
-        this._canReply = _canReply;
-        this._isTemplate = _isTemplate;
-        this._onDidChangeInput = ( new Emitter());
-        this._onDidChangeLabel = ( new Emitter());
-        this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this._onDidChangeComments = ( new Emitter());
-        this._onDidChangeCanReply = ( new Emitter());
-        this._onDidChangeRange = ( new Emitter());
-        this.onDidChangeRange = this._onDidChangeRange.event;
-        this._onDidChangeCollapsibleState = ( new Emitter());
-        this.onDidChangeCollapsibleState = this._onDidChangeCollapsibleState.event;
-        this._onDidChangeInitialCollapsibleState = ( new Emitter());
-        this.onDidChangeInitialCollapsibleState = this._onDidChangeInitialCollapsibleState.event;
-        this._onDidChangeApplicability = ( new Emitter());
-        this.onDidChangeApplicability = this._onDidChangeApplicability.event;
-        this._onDidChangeState = ( new Emitter());
-        this.onDidChangeState = this._onDidChangeState.event;
-        this._isDisposed = false;
-        if (_isTemplate) {
-            this.comments = [];
-        }
-    }
-    batchUpdate(changes) {
-        const modified = (value) => Object.prototype.hasOwnProperty.call(changes, value);
-        if (modified('range')) {
-            this._range = changes.range;
-        }
-        if (modified('label')) {
-            this._label = changes.label;
-        }
-        if (modified('contextValue')) {
-            this._contextValue = changes.contextValue === null ? undefined : changes.contextValue;
-        }
-        if (modified('comments')) {
-            this._comments = changes.comments;
-        }
-        if (modified('collapseState')) {
-            this.initialCollapsibleState = changes.collapseState;
-        }
-        if (modified('canReply')) {
-            this.canReply = changes.canReply;
-        }
-        if (modified('state')) {
-            this.state = changes.state;
-        }
-        if (modified('applicability')) {
-            this.applicability = changes.applicability;
-        }
-        if (modified('isTemplate')) {
-            this._isTemplate = changes.isTemplate;
-        }
-    }
-    dispose() {
-        this._isDisposed = true;
-        this._onDidChangeCollapsibleState.dispose();
-        this._onDidChangeComments.dispose();
-        this._onDidChangeInput.dispose();
-        this._onDidChangeLabel.dispose();
-        this._onDidChangeRange.dispose();
-        this._onDidChangeState.dispose();
-    }
-    toJSON() {
-        return {
-            $mid: 7 ,
-            commentControlHandle: this.controllerHandle,
-            commentThreadHandle: this.commentThreadHandle,
-        };
-    }
-}
-class MainThreadCommentController {
-    get handle() {
-        return this._handle;
-    }
-    get id() {
-        return this._id;
-    }
-    get contextValue() {
-        return this._id;
-    }
-    get proxy() {
-        return this._proxy;
-    }
-    get label() {
-        return this._label;
-    }
-    get reactions() {
-        return this._reactions;
-    }
-    set reactions(reactions) {
-        this._reactions = reactions;
-    }
-    get options() {
-        return this._features.options;
-    }
-    get features() {
-        return this._features;
-    }
-    get owner() {
-        return this._id;
-    }
-    constructor(_proxy, _commentService, _handle, _uniqueId, _id, _label, _features) {
-        this._proxy = _proxy;
-        this._commentService = _commentService;
-        this._handle = _handle;
-        this._uniqueId = _uniqueId;
-        this._id = _id;
-        this._label = _label;
-        this._features = _features;
-        this._threads = ( new Map());
-    }
-    async setActiveCommentAndThread(commentInfo) {
-        return this._proxy.$setActiveComment(this._handle, commentInfo ? { commentThreadHandle: commentInfo.thread.commentThreadHandle, uniqueIdInThread: commentInfo.comment?.uniqueIdInThread } : undefined);
-    }
-    updateFeatures(features) {
-        this._features = features;
-    }
-    createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, isTemplate) {
-        const thread = ( new MainThreadCommentThread(commentThreadHandle, this.handle, extensionId, threadId, ( URI.revive(resource).toString()), range, true, isTemplate));
-        this._threads.set(commentThreadHandle, thread);
-        if (thread.isDocumentCommentThread()) {
-            this._commentService.updateComments(this._uniqueId, {
-                added: [thread],
-                removed: [],
-                changed: [],
-                pending: []
-            });
-        }
-        else {
-            this._commentService.updateNotebookComments(this._uniqueId, {
-                added: [thread],
-                removed: [],
-                changed: [],
-                pending: []
-            });
-        }
-        return thread;
-    }
-    updateCommentThread(commentThreadHandle, threadId, resource, changes) {
-        const thread = this.getKnownThread(commentThreadHandle);
-        thread.batchUpdate(changes);
-        if (thread.isDocumentCommentThread()) {
-            this._commentService.updateComments(this._uniqueId, {
-                added: [],
-                removed: [],
-                changed: [thread],
-                pending: []
-            });
-        }
-        else {
-            this._commentService.updateNotebookComments(this._uniqueId, {
-                added: [],
-                removed: [],
-                changed: [thread],
-                pending: []
-            });
-        }
-    }
-    deleteCommentThread(commentThreadHandle) {
-        const thread = this.getKnownThread(commentThreadHandle);
-        this._threads.delete(commentThreadHandle);
-        thread.dispose();
-        if (thread.isDocumentCommentThread()) {
-            this._commentService.updateComments(this._uniqueId, {
-                added: [],
-                removed: [thread],
-                changed: [],
-                pending: []
-            });
-        }
-        else {
-            this._commentService.updateNotebookComments(this._uniqueId, {
-                added: [],
-                removed: [thread],
-                changed: [],
-                pending: []
-            });
-        }
-    }
-    deleteCommentThreadMain(commentThreadId) {
-        this._threads.forEach(thread => {
-            if (thread.threadId === commentThreadId) {
-                this._proxy.$deleteCommentThread(this._handle, thread.commentThreadHandle);
-            }
-        });
-    }
-    updateInput(input) {
-        const thread = this.activeEditingCommentThread;
-        if (thread && thread.input) {
-            const commentInput = thread.input;
-            commentInput.value = input;
-            thread.input = commentInput;
-        }
-    }
-    updateCommentingRanges(resourceHints) {
-        this._commentService.updateCommentingRanges(this._uniqueId, resourceHints);
-    }
-    getKnownThread(commentThreadHandle) {
-        const thread = this._threads.get(commentThreadHandle);
-        if (!thread) {
-            throw new Error('unknown thread');
-        }
-        return thread;
-    }
-    async getDocumentComments(resource, token) {
-        if (resource.scheme === Schemas.vscodeNotebookCell) {
-            return {
-                uniqueOwner: this._uniqueId,
-                label: this.label,
-                threads: [],
-                commentingRanges: {
-                    resource: resource,
-                    ranges: [],
-                    fileComments: false
-                }
-            };
-        }
-        const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
-            const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
-                ret.push(commentThread);
-            }
-        }
-        const commentingRanges = await this._proxy.$provideCommentingRanges(this.handle, resource, token);
-        return {
-            uniqueOwner: this._uniqueId,
-            label: this.label,
-            threads: ret,
-            commentingRanges: {
-                resource: resource,
-                ranges: commentingRanges?.ranges || [],
-                fileComments: commentingRanges?.fileComments
-            }
-        };
-    }
-    async getNotebookComments(resource, token) {
-        if (resource.scheme !== Schemas.vscodeNotebookCell) {
-            return {
-                uniqueOwner: this._uniqueId,
-                label: this.label,
-                threads: []
-            };
-        }
-        const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
-            const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
-                ret.push(commentThread);
-            }
-        }
-        return {
-            uniqueOwner: this._uniqueId,
-            label: this.label,
-            threads: ret
-        };
-    }
-    async toggleReaction(uri, thread, comment, reaction, token) {
-        return this._proxy.$toggleReaction(this._handle, thread.commentThreadHandle, uri, comment, reaction);
-    }
-    getAllComments() {
-        const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
-            ret.push(this._threads.get(thread));
-        }
-        return ret;
-    }
-    createCommentThreadTemplate(resource, range) {
-        return this._proxy.$createCommentThreadTemplate(this.handle, resource, range);
-    }
-    async updateCommentThreadTemplate(threadHandle, range) {
-        await this._proxy.$updateCommentThreadTemplate(this.handle, threadHandle, range);
-    }
-    toJSON() {
-        return {
-            $mid: 6 ,
-            handle: this.handle
-        };
-    }
-}
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(
-    'vs/workbench/api/browser/mainThreadComments',
-    'commentsViewIcon',
-    'View icon of the comments view.'
-)));
-let MainThreadComments = class MainThreadComments extends Disposable {
-    constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
-        super();
-        this._commentService = _commentService;
-        this._viewsService = _viewsService;
-        this._viewDescriptorService = _viewDescriptorService;
-        this._handlers = ( new Map());
-        this._commentControllers = ( new Map());
-        this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
-        this._openViewListener = null;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
-        this._commentService.unregisterCommentController();
-        this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
-            const handle = thread.controllerHandle;
-            const controller = this._commentControllers.get(handle);
-            if (!controller) {
-                return;
-            }
-            this._activeEditingCommentThreadDisposables.clear();
-            this._activeEditingCommentThread = thread;
-            controller.activeEditingCommentThread = this._activeEditingCommentThread;
-        }));
-    }
-    $registerCommentController(handle, id, label, extensionId) {
-        const providerId = `${id}-${extensionId}`;
-        this._handlers.set(handle, providerId);
-        const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
-        this._commentService.registerCommentController(providerId, provider);
-        this._commentControllers.set(handle, provider);
-        const commentsPanelAlreadyConstructed = !!this._viewDescriptorService.getViewDescriptorById(COMMENTS_VIEW_ID);
-        if (!commentsPanelAlreadyConstructed) {
-            this.registerView(commentsPanelAlreadyConstructed);
-        }
-        this.registerViewListeners(commentsPanelAlreadyConstructed);
-        this._commentService.setWorkspaceComments(String(handle), []);
-    }
-    $unregisterCommentController(handle) {
-        const providerId = this._handlers.get(handle);
-        this._handlers.delete(handle);
-        this._commentControllers.delete(handle);
-        if (typeof providerId !== 'string') {
-            return;
-        }
-        else {
-            this._commentService.unregisterCommentController(providerId);
-        }
-    }
-    $updateCommentControllerFeatures(handle, features) {
-        const provider = this._commentControllers.get(handle);
-        if (!provider) {
-            return undefined;
-        }
-        provider.updateFeatures(features);
-    }
-    $createCommentThread(handle, commentThreadHandle, threadId, resource, range, extensionId, isTemplate) {
-        const provider = this._commentControllers.get(handle);
-        if (!provider) {
-            return undefined;
-        }
-        return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range, isTemplate);
-    }
-    $updateCommentThread(handle, commentThreadHandle, threadId, resource, changes) {
-        const provider = this._commentControllers.get(handle);
-        if (!provider) {
-            return undefined;
-        }
-        return provider.updateCommentThread(commentThreadHandle, threadId, resource, changes);
-    }
-    $deleteCommentThread(handle, commentThreadHandle) {
-        const provider = this._commentControllers.get(handle);
-        if (!provider) {
-            return;
-        }
-        return provider.deleteCommentThread(commentThreadHandle);
-    }
-    $updateCommentingRanges(handle, resourceHints) {
-        const provider = this._commentControllers.get(handle);
-        if (!provider) {
-            return;
-        }
-        provider.updateCommentingRanges(resourceHints);
-    }
-    registerView(commentsViewAlreadyRegistered) {
-        if (!commentsViewAlreadyRegistered) {
-            const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
-                id: COMMENTS_VIEW_ID,
-                title: COMMENTS_VIEW_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(
-                    ViewPaneContainer,
-                    [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-                )),
-                storageId: COMMENTS_VIEW_STORAGE_ID,
-                hideIfEmpty: true,
-                icon: commentsViewIcon,
-                order: 10,
-            }, 1 );
-            ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
-                    id: COMMENTS_VIEW_ID,
-                    name: COMMENTS_VIEW_TITLE,
-                    canToggleVisibility: false,
-                    ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
-                    canMoveView: true,
-                    containerIcon: commentsViewIcon,
-                    focusCommand: {
-                        id: 'workbench.action.focusCommentsPanel'
-                    }
-                }], VIEW_CONTAINER);
-        }
-    }
-    setComments() {
-        [...( this._commentControllers.keys())].forEach(handle => {
-            const threads = this._commentControllers.get(handle).getAllComments();
-            if (threads.length) {
-                const providerId = this.getHandler(handle);
-                this._commentService.setWorkspaceComments(providerId, threads);
-            }
-        });
-    }
-    registerViewOpenedListener() {
-        if (!this._openViewListener) {
-            this._openViewListener = this._viewsService.onDidChangeViewVisibility(e => {
-                if (e.id === COMMENTS_VIEW_ID && e.visible) {
-                    this.setComments();
-                    if (this._openViewListener) {
-                        this._openViewListener.dispose();
-                        this._openViewListener = null;
-                    }
-                }
-            });
-        }
-    }
-    registerViewListeners(commentsPanelAlreadyConstructed) {
-        if (!commentsPanelAlreadyConstructed) {
-            this.registerViewOpenedListener();
-        }
-        this._register(this._viewDescriptorService.onDidChangeContainer(e => {
-            if (e.views.find(view => view.id === COMMENTS_VIEW_ID)) {
-                this.setComments();
-                this.registerViewOpenedListener();
-            }
-        }));
-        this._register(this._viewDescriptorService.onDidChangeContainerLocation(e => {
-            const commentsContainer = this._viewDescriptorService.getViewContainerByViewId(COMMENTS_VIEW_ID);
-            if (e.viewContainer.id === commentsContainer?.id) {
-                this.setComments();
-                this.registerViewOpenedListener();
-            }
-        }));
-    }
-    getHandler(handle) {
-        if (!( this._handlers.has(handle))) {
-            throw new Error('Unknown handler');
-        }
-        return this._handlers.get(handle);
-    }
-};
-MainThreadComments = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadComments),
-    ( __param(1, ICommentService)),
-    ( __param(2, IViewsService)),
-    ( __param(3, IViewDescriptorService))
-], MainThreadComments);
-
-export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };

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

@@ -1,80 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { getScopes, Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-
-let MainThreadConfiguration = class MainThreadConfiguration {
-    constructor(extHostContext, _workspaceContextService, configurationService, _environmentService) {
-        this._workspaceContextService = _workspaceContextService;
-        this.configurationService = configurationService;
-        this._environmentService = _environmentService;
-        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostConfiguration));
-        proxy.$initializeConfiguration(this._getConfigurationData());
-        this._configurationListener = configurationService.onDidChangeConfiguration(e => {
-            proxy.$acceptConfigurationChanged(this._getConfigurationData(), e.change);
-        });
-    }
-    _getConfigurationData() {
-        const configurationData = { ...(this.configurationService.getConfigurationData()), configurationScopes: [] };
-        if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
-            configurationData.configurationScopes = getScopes();
-        }
-        return configurationData;
-    }
-    dispose() {
-        this._configurationListener.dispose();
-    }
-    $updateConfigurationOption(target, key, value, overrides, scopeToLanguage) {
-        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
-        return this.writeConfiguration(target, key, value, overrides, scopeToLanguage);
-    }
-    $removeConfigurationOption(target, key, overrides, scopeToLanguage) {
-        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
-        return this.writeConfiguration(target, key, undefined, overrides, scopeToLanguage);
-    }
-    writeConfiguration(target, key, value, overrides, scopeToLanguage) {
-        target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
-        const configurationValue = this.configurationService.inspect(key, overrides);
-        switch (target) {
-            case 8 :
-                return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
-            case 6 :
-                return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
-            case 5 :
-                return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
-            case 4 :
-                return this._updateValue(key, value, target, configurationValue?.userRemote?.override, overrides, scopeToLanguage);
-            default:
-                return this._updateValue(key, value, target, configurationValue?.userLocal?.override, overrides, scopeToLanguage);
-        }
-    }
-    _updateValue(key, value, configurationTarget, overriddenValue, overrides, scopeToLanguage) {
-        overrides = scopeToLanguage === true ? overrides
-            : scopeToLanguage === false ? { resource: overrides.resource }
-                : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
-                    : { resource: overrides.resource };
-        return this.configurationService.updateValue(key, value, overrides, configurationTarget, { donotNotifyError: true });
-    }
-    deriveConfigurationTarget(key, overrides) {
-        if (overrides.resource && this._workspaceContextService.getWorkbenchState() === 3 ) {
-            const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-            if (configurationProperties[key] && ((configurationProperties[key].scope === 4  || configurationProperties[key].scope === 5) )) {
-                return 6 ;
-            }
-        }
-        return 5 ;
-    }
-};
-MainThreadConfiguration = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadConfiguration),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEnvironmentService))
-], MainThreadConfiguration);
-
-export { MainThreadConfiguration };

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

@@ -1,35 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { log } from '../../../base/common/console.js';
-import { logRemoteEntry, logRemoteEntryIfError } from '../../services/extensions/common/remoteConsoleUtil.js';
-import { parseExtensionDevOptions } from '../../services/extensions/common/extensionDevOptions.js';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-
-let MainThreadConsole = class MainThreadConsole {
-    constructor(_extHostContext, _environmentService, _logService) {
-        this._environmentService = _environmentService;
-        this._logService = _logService;
-        const devOpts = parseExtensionDevOptions(this._environmentService);
-        this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
-    }
-    dispose() {
-    }
-    $logExtensionHostMessage(entry) {
-        if (this._isExtensionDevTestFromCli) {
-            logRemoteEntry(this._logService, entry);
-        }
-        else {
-            logRemoteEntryIfError(this._logService, entry, 'Extension Host');
-            log(entry, 'Extension Host');
-        }
-    }
-};
-MainThreadConsole = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadConsole),
-    ( __param(1, IEnvironmentService)),
-    ( __param(2, ILogService))
-], MainThreadConsole);
-
-export { MainThreadConsole };