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

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

@@ -0,0 +1,560 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,35 @@
+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 };