@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/api/browser/mainThreadLanguages.js

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { ILanguageStatusService } from '../../services/languageStatus/common/languageStatusService.js';
+import { DisposableStore, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+let MainThreadLanguages = class MainThreadLanguages {
+    constructor(_extHostContext, _languageService, _modelService, _resolverService, _languageStatusService) {
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._resolverService = _resolverService;
+        this._languageStatusService = _languageStatusService;
+        this._disposables = ( new DisposableStore());
+        this._status = ( new DisposableMap());
+        this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostLanguages));
+        this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
+        this._disposables.add(_languageService.onDidChange(_ => {
+            this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._status.dispose();
+    }
+    async $changeLanguage(resource, languageId) {
+        if (!this._languageService.isRegisteredLanguageId(languageId)) {
+            return Promise.reject(( new Error(`Unknown language id: ${languageId}`)));
+        }
+        const uri = URI.revive(resource);
+        const ref = await this._resolverService.createModelReference(uri);
+        try {
+            ref.object.textEditorModel.setLanguage(this._languageService.createById(languageId));
+        }
+        finally {
+            ref.dispose();
+        }
+    }
+    async $tokensAtPosition(resource, position) {
+        const uri = URI.revive(resource);
+        const model = this._modelService.getModel(uri);
+        if (!model) {
+            return undefined;
+        }
+        model.tokenization.tokenizeIfCheap(position.lineNumber);
+        const tokens = model.tokenization.getLineTokens(position.lineNumber);
+        const idx = tokens.findTokenIndexAtOffset(position.column - 1);
+        return {
+            type: tokens.getStandardTokenType(idx),
+            range: ( new Range(
+                position.lineNumber,
+                1 + tokens.getStartOffset(idx),
+                position.lineNumber,
+                1 + tokens.getEndOffset(idx)
+            ))
+        };
+    }
+    $setLanguageStatus(handle, status) {
+        this._status.get(handle)?.dispose();
+        this._status.set(handle, this._languageStatusService.addStatus(status));
+    }
+    $removeLanguageStatus(handle) {
+        this._status.get(handle)?.dispose();
+    }
+};
+MainThreadLanguages = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLanguages),
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ITextModelService)),
+    ( __param(4, ILanguageStatusService))
+], MainThreadLanguages);
+export { MainThreadLanguages };

package/dist/vscode/vs/workbench/api/browser/mainThreadMessageService.js

@@ -0,0 +1,114 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+let MainThreadMessageService = class MainThreadMessageService {
+    constructor(extHostContext, _notificationService, _commandService, _dialogService) {
+        this._notificationService = _notificationService;
+        this._commandService = _commandService;
+        this._dialogService = _dialogService;
+    }
+    dispose() {
+    }
+    $showMessage(severity, message, options, commands) {
+        if (options.modal) {
+            return this._showModalMessage(severity, message, options.detail, commands, options.useCustom);
+        }
+        else {
+            return this._showMessage(severity, message, commands, options);
+        }
+    }
+    _showMessage(severity, message, commands, options) {
+        return ( new Promise(resolve => {
+            const primaryActions = ( commands.map(command => toAction({
+                id: `_extension_message_handle_${command.handle}`,
+                label: command.title,
+                enabled: true,
+                run: () => {
+                    resolve(command.handle);
+                    return Promise.resolve();
+                }
+            })));
+            let source;
+            if (options.source) {
+                source = {
+                    label: ( nls.localize('extensionSource', "{0} (Extension)", options.source.label)),
+                    id: options.source.identifier.value
+                };
+            }
+            if (!source) {
+                source = ( nls.localize('defaultSource', "Extension"));
+            }
+            const secondaryActions = [];
+            if (options.source) {
+                secondaryActions.push(toAction({
+                    id: options.source.identifier.value,
+                    label: ( nls.localize('manageExtension', "Manage Extension")),
+                    run: () => {
+                        return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                    }
+                }));
+            }
+            const messageHandle = this._notificationService.notify({
+                severity,
+                message,
+                actions: { primary: primaryActions, secondary: secondaryActions },
+                source
+            });
+            Event.once(messageHandle.onDidClose)(() => {
+                resolve(undefined);
+            });
+        }));
+    }
+    async _showModalMessage(severity, message, detail, commands, useCustom) {
+        const buttons = [];
+        let cancelButton = undefined;
+        for (const command of commands) {
+            const button = {
+                label: command.title,
+                run: () => command.handle
+            };
+            if (command.isCloseAffordance) {
+                cancelButton = button;
+            }
+            else {
+                buttons.push(button);
+            }
+        }
+        if (!cancelButton) {
+            if (buttons.length > 0) {
+                cancelButton = {
+                    label: ( nls.localize('cancel', "Cancel")),
+                    run: () => undefined
+                };
+            }
+            else {
+                cancelButton = {
+                    label: ( nls.localize({ key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK")),
+                    run: () => undefined
+                };
+            }
+        }
+        const { result } = await this._dialogService.prompt({
+            type: severity,
+            message,
+            detail,
+            buttons,
+            cancelButton,
+            custom: useCustom
+        });
+        return result;
+    }
+};
+MainThreadMessageService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadMessageService),
+    ( __param(1, INotificationService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IDialogService))
+], MainThreadMessageService);
+export { MainThreadMessageService };

package/dist/vscode/vs/workbench/api/browser/mainThreadOutputService.js

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { OUTPUT_VIEW_ID, Extensions, OutputChannelUpdateMode, IOutputService } from '../../services/output/common/output.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 { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IViewsService } from '../../common/views.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+var MainThreadOutputService_1;
+let MainThreadOutputService = MainThreadOutputService_1 = class MainThreadOutputService extends Disposable {
+    constructor(extHostContext, outputService, viewsService) {
+        super();
+        this._outputService = outputService;
+        this._viewsService = viewsService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostOutputService));
+        const setVisibleChannel = () => {
+            const visibleChannel = this._viewsService.isViewVisible(OUTPUT_VIEW_ID) ? this._outputService.getActiveChannel() : undefined;
+            this._proxy.$setVisibleChannel(visibleChannel ? visibleChannel.id : null);
+        };
+        this._register(Event.any(this._outputService.onActiveOutputChannel, Event.filter(this._viewsService.onDidChangeViewVisibility, ({ id }) => id === OUTPUT_VIEW_ID))(() => setVisibleChannel()));
+        setVisibleChannel();
+    }
+    async $register(label, file, languageId, extensionId) {
+        const idCounter = (MainThreadOutputService_1._extensionIdPool.get(extensionId) || 0) + 1;
+        MainThreadOutputService_1._extensionIdPool.set(extensionId, idCounter);
+        const id = `extension-output-${extensionId}-#${idCounter}-${label}`;
+        const resource = URI.revive(file);
+        ( Registry.as(Extensions.OutputChannels)).registerChannel({ id, label, file: resource, log: false, languageId, extensionId });
+        this._register(toDisposable(() => this.$dispose(id)));
+        return id;
+    }
+    async $update(channelId, mode, till) {
+        const channel = this._getChannel(channelId);
+        if (channel) {
+            if (mode === OutputChannelUpdateMode.Append) {
+                channel.update(mode);
+            }
+            else if (isNumber(till)) {
+                channel.update(mode, till);
+            }
+        }
+    }
+    async $reveal(channelId, preserveFocus) {
+        const channel = this._getChannel(channelId);
+        if (channel) {
+            this._outputService.showChannel(channel.id, preserveFocus);
+        }
+    }
+    async $close(channelId) {
+        if (this._viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
+            const activeChannel = this._outputService.getActiveChannel();
+            if (activeChannel && channelId === activeChannel.id) {
+                this._viewsService.closeView(OUTPUT_VIEW_ID);
+            }
+        }
+    }
+    async $dispose(channelId) {
+        const channel = this._getChannel(channelId);
+        channel?.dispose();
+    }
+    _getChannel(channelId) {
+        return this._outputService.getChannel(channelId);
+    }
+};
+MainThreadOutputService._extensionIdPool = ( new Map());
+MainThreadOutputService = MainThreadOutputService_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadOutputService),
+    ( __param(1, IOutputService)),
+    ( __param(2, IViewsService))
+], MainThreadOutputService);
+export { MainThreadOutputService };

package/dist/vscode/vs/workbench/api/browser/mainThreadProgress.js

@@ -0,0 +1,62 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+class ManageExtensionAction extends Action {
+    constructor(extensionId, label, commandService) {
+        super(extensionId, label, undefined, true, () => {
+            return commandService.executeCommand('_extensions.manage', extensionId);
+        });
+    }
+}
+let MainThreadProgress = class MainThreadProgress {
+    constructor(extHostContext, progressService, _commandService) {
+        this._commandService = _commandService;
+        this._progress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostProgress));
+        this._progressService = progressService;
+    }
+    dispose() {
+        this._progress.forEach(handle => handle.resolve());
+        this._progress.clear();
+    }
+    async $startProgress(handle, options, extensionId) {
+        const task = this._createTask(handle);
+        if (options.location === 15  && extensionId) {
+            const notificationOptions = {
+                ...options,
+                location: 15 ,
+                secondaryActions: [( new ManageExtensionAction(extensionId, ( localize('manageExtension', "Manage Extension")), this._commandService))]
+            };
+            options = notificationOptions;
+        }
+        this._progressService.withProgress(options, task, () => this._proxy.$acceptProgressCanceled(handle));
+    }
+    $progressReport(handle, message) {
+        const entry = this._progress.get(handle);
+        entry?.progress.report(message);
+    }
+    $progressEnd(handle) {
+        const entry = this._progress.get(handle);
+        if (entry) {
+            entry.resolve();
+            this._progress.delete(handle);
+        }
+    }
+    _createTask(handle) {
+        return (progress) => {
+            return ( new Promise(resolve => {
+                this._progress.set(handle, { resolve, progress });
+            }));
+        };
+    }
+};
+MainThreadProgress = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadProgress),
+    ( __param(1, IProgressService)),
+    ( __param(2, ICommandService))
+], MainThreadProgress);
+export { MainThreadProgress };

package/dist/vscode/vs/workbench/api/browser/mainThreadQuickOpen.js

@@ -0,0 +1,183 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.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';
+function reviveIconPathUris(iconPath) {
+    iconPath.dark = URI.revive(iconPath.dark);
+    if (iconPath.light) {
+        iconPath.light = URI.revive(iconPath.light);
+    }
+}
+let MainThreadQuickOpen = class MainThreadQuickOpen {
+    constructor(extHostContext, quickInputService) {
+        this._items = {};
+        this.sessions = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickOpen));
+        this._quickInputService = quickInputService;
+    }
+    dispose() {
+    }
+    $show(instance, options, token) {
+        const contents = ( new Promise((resolve, reject) => {
+            this._items[instance] = { resolve, reject };
+        }));
+        options = {
+            ...options,
+            onDidFocus: el => {
+                if (el) {
+                    this._proxy.$onItemSelected(el.handle);
+                }
+            }
+        };
+        if (options.canPickMany) {
+            return this._quickInputService.pick(contents, options, token).then(items => {
+                if (items) {
+                    return ( items.map(item => item.handle));
+                }
+                return undefined;
+            });
+        }
+        else {
+            return this._quickInputService.pick(contents, options, token).then(item => {
+                if (item) {
+                    return item.handle;
+                }
+                return undefined;
+            });
+        }
+    }
+    $setItems(instance, items) {
+        if (this._items[instance]) {
+            this._items[instance].resolve(items);
+            delete this._items[instance];
+        }
+        return Promise.resolve();
+    }
+    $setError(instance, error) {
+        if (this._items[instance]) {
+            this._items[instance].reject(error);
+            delete this._items[instance];
+        }
+        return Promise.resolve();
+    }
+    $input(options, validateInput, token) {
+        const inputOptions = Object.create(null);
+        if (options) {
+            inputOptions.title = options.title;
+            inputOptions.password = options.password;
+            inputOptions.placeHolder = options.placeHolder;
+            inputOptions.valueSelection = options.valueSelection;
+            inputOptions.prompt = options.prompt;
+            inputOptions.value = options.value;
+            inputOptions.ignoreFocusLost = options.ignoreFocusOut;
+        }
+        if (validateInput) {
+            inputOptions.validateInput = (value) => {
+                return this._proxy.$validateInput(value);
+            };
+        }
+        return this._quickInputService.input(inputOptions, token);
+    }
+    $createOrUpdate(params) {
+        const sessionId = params.id;
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            const input = params.type === 'quickPick' ? this._quickInputService.createQuickPick() : this._quickInputService.createInputBox();
+            input.onDidAccept(() => {
+                this._proxy.$onDidAccept(sessionId);
+            });
+            input.onDidTriggerButton(button => {
+                this._proxy.$onDidTriggerButton(sessionId, button.handle);
+            });
+            input.onDidChangeValue(value => {
+                this._proxy.$onDidChangeValue(sessionId, value);
+            });
+            input.onDidHide(() => {
+                this._proxy.$onDidHide(sessionId);
+            });
+            if (params.type === 'quickPick') {
+                const quickpick = input;
+                quickpick.onDidChangeActive(items => {
+                    this._proxy.$onDidChangeActive(sessionId, ( items.map(item => item.handle)));
+                });
+                quickpick.onDidChangeSelection(items => {
+                    this._proxy.$onDidChangeSelection(sessionId, ( items.map(item => item.handle)));
+                });
+                quickpick.onDidTriggerItemButton((e) => {
+                    this._proxy.$onDidTriggerItemButton(sessionId, e.item.handle, e.button.handle);
+                });
+            }
+            session = {
+                input,
+                handlesToItems: ( new Map())
+            };
+            this.sessions.set(sessionId, session);
+        }
+        const { input, handlesToItems } = session;
+        for (const param in params) {
+            if (param === 'id' || param === 'type') {
+                continue;
+            }
+            if (param === 'visible') {
+                if (params.visible) {
+                    input.show();
+                }
+                else {
+                    input.hide();
+                }
+            }
+            else if (param === 'items') {
+                handlesToItems.clear();
+                params[param].forEach((item) => {
+                    if (item.type === 'separator') {
+                        return;
+                    }
+                    if (item.buttons) {
+                        item.buttons = ( item.buttons.map((button) => {
+                            if (button.iconPath) {
+                                reviveIconPathUris(button.iconPath);
+                            }
+                            return button;
+                        }));
+                    }
+                    handlesToItems.set(item.handle, item);
+                });
+                input[param] = params[param];
+            }
+            else if (param === 'activeItems' || param === 'selectedItems') {
+                input[param] = ( params[param]
+                    .filter((handle) => handlesToItems.has(handle))
+                    .map((handle) => handlesToItems.get(handle)));
+            }
+            else if (param === 'buttons') {
+                input[param] = ( params.buttons.map(button => {
+                    if (button.handle === -1) {
+                        return this._quickInputService.backButton;
+                    }
+                    if (button.iconPath) {
+                        reviveIconPathUris(button.iconPath);
+                    }
+                    return button;
+                }));
+            }
+            else {
+                input[param] = params[param];
+            }
+        }
+        return Promise.resolve(undefined);
+    }
+    $dispose(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.input.dispose();
+            this.sessions.delete(sessionId);
+        }
+        return Promise.resolve(undefined);
+    }
+};
+MainThreadQuickOpen = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadQuickOpen),
+    ( __param(1, IQuickInputService))
+], MainThreadQuickOpen);
+export { MainThreadQuickOpen };

package/dist/vscode/vs/workbench/api/browser/mainThreadSaveParticipant.js

@@ -0,0 +1,43 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { shouldSynchronizeModel } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ITextFileService } from '../../services/textfile/common/textfiles.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
+class ExtHostSaveParticipant {
+    constructor(extHostContext) {
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant));
+    }
+    async participate(editorModel, env, _progress, token) {
+        if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
+            return undefined;
+        }
+        const p = ( new Promise((resolve, reject) => {
+            setTimeout(() => reject(( new Error(( localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
+            this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
+                if (!values.every(success => success)) {
+                    return Promise.reject(( new Error('listener failed')));
+                }
+                return undefined;
+            }).then(resolve, reject);
+        }));
+        return raceCancellationError(p, token);
+    }
+}
+let SaveParticipant = class SaveParticipant {
+    constructor(extHostContext, instantiationService, _textFileService) {
+        this._textFileService = _textFileService;
+        this._saveParticipantDisposable = this._textFileService.files.addSaveParticipant(instantiationService.createInstance(ExtHostSaveParticipant, extHostContext));
+    }
+    dispose() {
+        this._saveParticipantDisposable.dispose();
+    }
+};
+SaveParticipant = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextFileService))
+], SaveParticipant);
+export { SaveParticipant };

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

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../node_modules/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 = MainThreadTelemetry_1 = class MainThreadTelemetry extends Disposable {
+    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._name = 'pluginHostTelemetry';
+MainThreadTelemetry = MainThreadTelemetry_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTelemetry),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IProductService))
+], MainThreadTelemetry);
+export { MainThreadTelemetry };

package/dist/vscode/vs/workbench/api/browser/mainThreadWindow.js

@@ -0,0 +1,48 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IHostService } from '../../services/host/browser/host.js';
+let MainThreadWindow = class MainThreadWindow {
+    constructor(extHostContext, hostService, openerService) {
+        this.hostService = hostService;
+        this.openerService = openerService;
+        this.disposables = ( new DisposableStore());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
+        Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+    $getWindowVisibility() {
+        return Promise.resolve(this.hostService.hasFocus);
+    }
+    async $openUri(uriComponents, uriString, options) {
+        const uri = ( URI.from(uriComponents));
+        let target;
+        if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
+            target = uriString;
+        }
+        else {
+            target = uri;
+        }
+        return this.openerService.open(target, {
+            openExternal: true,
+            allowTunneling: options.allowTunneling,
+            allowContributedOpeners: options.allowContributedOpeners,
+        });
+    }
+    async $asExternalUri(uriComponents, options) {
+        const result = await this.openerService.resolveExternalUri(URI.revive(uriComponents), options);
+        return result.resolved;
+    }
+};
+MainThreadWindow = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadWindow),
+    ( __param(1, IHostService)),
+    ( __param(2, IOpenerService))
+], MainThreadWindow);
+export { MainThreadWindow };