@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

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

@@ -0,0 +1,130 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { deserializeWebviewMessage, serializeWebviewMessage } from '../common/extHostWebviewMessaging.js';
+import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
+let MainThreadWebviews = class MainThreadWebviews extends Disposable {
+    constructor(context, _openerService, _productService) {
+        super();
+        this._openerService = _openerService;
+        this._productService = _productService;
+        this._webviews = ( (new Map()));
+        this._proxy = ( (context.getProxy(ExtHostContext.ExtHostWebviews)));
+    }
+    addWebview(handle, webview, options) {
+        if (( (this._webviews.has(handle)))) {
+            throw new Error('Webview already registered');
+        }
+        this._webviews.set(handle, webview);
+        this.hookupWebviewEventDelegate(handle, webview, options);
+    }
+    $setHtml(handle, value) {
+        this.tryGetWebview(handle)?.setHtml(value);
+    }
+    $setOptions(handle, options) {
+        const webview = this.tryGetWebview(handle);
+        if (webview) {
+            webview.contentOptions = reviveWebviewContentOptions(options);
+        }
+    }
+    async $postMessage(handle, jsonMessage, ...buffers) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            return false;
+        }
+        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
+        return webview.postMessage(message, arrayBuffers);
+    }
+    hookupWebviewEventDelegate(handle, webview, options) {
+        const disposables = ( (new DisposableStore()));
+        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
+        disposables.add(webview.onMessage((message) => {
+            const serialized = serializeWebviewMessage(message.message, options);
+            this._proxy.$onMessage(handle, serialized.message, ( (new SerializableObjectWithBuffers(serialized.buffers))));
+        }));
+        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
+        disposables.add(webview.onDidDispose(() => {
+            disposables.dispose();
+            this._webviews.delete(handle);
+        }));
+    }
+    onDidClickLink(handle, link) {
+        const webview = this.getWebview(handle);
+        if (this.isSupportedLink(webview, ( (URI.parse(link))))) {
+            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
+        }
+    }
+    isSupportedLink(webview, link) {
+        if (( (MainThreadWebviews.standardSupportedLinkSchemes.has(link.scheme)))) {
+            return true;
+        }
+        if (!isWeb && this._productService.urlProtocol === link.scheme) {
+            return true;
+        }
+        if (link.scheme === Schemas.command) {
+            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
+                return webview.contentOptions.enableCommandUris.includes(link.path);
+            }
+            return webview.contentOptions.enableCommandUris === true;
+        }
+        return false;
+    }
+    tryGetWebview(handle) {
+        return this._webviews.get(handle);
+    }
+    getWebview(handle) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            throw new Error(`Unknown webview handle:${handle}`);
+        }
+        return webview;
+    }
+    getWebviewResolvedFailedContent(viewType) {
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
+			</head>
+			<body>${( ( localize(
+            'errorMessage',
+            "An error occurred while loading view: {0}",
+            escape(viewType)
+        )))}</body>
+		</html>`;
+    }
+};
+MainThreadWebviews.standardSupportedLinkSchemes = ( (new Set([
+    Schemas.http,
+    Schemas.https,
+    Schemas.mailto,
+    Schemas.vscode,
+    'vscode-insider',
+])));
+MainThreadWebviews = ( (__decorate([
+    ( (__param(1, IOpenerService))),
+    ( (__param(2, IProductService)))
+], MainThreadWebviews)));
+function reviveWebviewExtension(extensionData) {
+    return {
+        id: extensionData.id,
+        location: URI.revive(extensionData.location),
+    };
+}
+function reviveWebviewContentOptions(webviewOptions) {
+    return {
+        allowScripts: webviewOptions.enableScripts,
+        allowForms: webviewOptions.enableForms,
+        enableCommandUris: webviewOptions.enableCommandUris,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( (webviewOptions.localResourceRoots.map(r => URI.revive(r)))) : undefined,
+        portMapping: webviewOptions.portMapping,
+    };
+}
+export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

package/dist/vscode/vs/workbench/api/common/extHostCommands.js

@@ -1,14 +1,14 @@
 import { __classPrivateFieldSet, __classPrivateFieldGet, __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
 import { validateConstraint } from 'monaco-editor/esm/vs/base/common/types.js';
-import { Disposable, Position as Position$2, Range as Range$2, Location, NotebookRange, Selection, CallHierarchyItem, TypeHierarchyItem } from './extHostTypes.js';
-import { Range as Range$1, Position as Position$1, location, NotebookRange as NotebookRange$1, Selection as Selection$1, CallHierarchyItem as CallHierarchyItem$1, TypeHierarchyItem as TypeHierarchyItem$1, TestItem } from './extHostTypeConverters.js';
+import { Position, Range, Selection, CallHierarchyItem, TypeHierarchyItem, Disposable, Location, NotebookRange } from './extHostTypes.js';
+import { Position as Position$1, Range as Range$1, Selection as Selection$1, CallHierarchyItem as CallHierarchyItem$1, TypeHierarchyItem as TypeHierarchyItem$1, TestItem, location, NotebookRange as NotebookRange$1 } from './extHostTypeConverters.js';
 import { cloneAndChange } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { MainContext } from './extHost.protocol.js';
 import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range as Range$2 } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Position as Position$2 } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -46,13 +46,13 @@ let ExtHostCommands = class ExtHostCommands {
             {
                 processArgument(arg) {
                     return cloneAndChange(arg, function (obj) {
-                        if (Range.isIRange(obj)) {
+                        if (Range$2.isIRange(obj)) {
                             return Range$1.to(obj);
                         }
-                        if (Position.isIPosition(obj)) {
+                        if (Position$2.isIPosition(obj)) {
                             return Position$1.to(obj);
                         }
-                        if (Range.isIRange(obj.range) && URI.isUri(obj.uri)) {
+                        if (Range$2.isIRange(obj.range) && URI.isUri(obj.uri)) {
                             return location.to(obj);
                         }
                         if (obj instanceof VSBuffer) {
@@ -122,10 +122,10 @@ let ExtHostCommands = class ExtHostCommands {
         else {
             let hasBuffers = false;
             const toArgs = cloneAndChange(args, function (value) {
-                if (value instanceof Position$2) {
+                if (value instanceof Position) {
                     return Position$1.from(value);
                 }
-                else if (value instanceof Range$2) {
+                else if (value instanceof Range) {
                     return Range$1.from(value);
                 }
                 else if (value instanceof Location) {
@@ -361,13 +361,13 @@ ApiCommandArgument.Uri = ( (new ApiCommandArgument('uri', 'Uri of a text documen
 ApiCommandArgument.Position = ( (new ApiCommandArgument(
     'position',
     'A position in a text document',
-    v => Position$2.isPosition(v),
+    v => Position.isPosition(v),
     Position$1.from
 )));
 ApiCommandArgument.Range = ( (new ApiCommandArgument(
     'range',
     'A range in a text document',
-    v => Range$2.isRange(v),
+    v => Range.isRange(v),
     Range$1.from
 )));
 ApiCommandArgument.Selection = ( (new ApiCommandArgument(

package/dist/vscode/vs/workbench/api/common/extHostCustomEditors.js

@@ -0,0 +1,282 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ViewColumn } from './extHostTypeConverters.js';
+import { toExtensionData, shouldSerializeBuffersForPostMessage } from './extHostWebview.js';
+import { Cache } from './cache.js';
+import { MainContext } from './extHost.protocol.js';
+import { Disposable } from './extHostTypes.js';
+class CustomDocumentStoreEntry {
+    constructor(document, _storagePath) {
+        this.document = document;
+        this._storagePath = _storagePath;
+        this._backupCounter = 1;
+        this._edits = ( new Cache('custom documents'));
+    }
+    addEdit(item) {
+        return this._edits.add([item]);
+    }
+    async undo(editId, isDirty) {
+        await this.getEdit(editId).undo();
+        if (!isDirty) {
+            this.disposeBackup();
+        }
+    }
+    async redo(editId, isDirty) {
+        await this.getEdit(editId).redo();
+        if (!isDirty) {
+            this.disposeBackup();
+        }
+    }
+    disposeEdits(editIds) {
+        for (const id of editIds) {
+            this._edits.delete(id);
+        }
+    }
+    getNewBackupUri() {
+        if (!this._storagePath) {
+            throw new Error('Backup requires a valid storage path');
+        }
+        const fileName = hashPath(this.document.uri) + (this._backupCounter++);
+        return joinPath(this._storagePath, fileName);
+    }
+    updateBackup(backup) {
+        this._backup?.delete();
+        this._backup = backup;
+    }
+    disposeBackup() {
+        this._backup?.delete();
+        this._backup = undefined;
+    }
+    getEdit(editId) {
+        const edit = this._edits.get(editId, 0);
+        if (!edit) {
+            throw new Error('No edit found');
+        }
+        return edit;
+    }
+}
+class CustomDocumentStore {
+    constructor() {
+        this._documents = ( new Map());
+    }
+    get(viewType, resource) {
+        return this._documents.get(this.key(viewType, resource));
+    }
+    add(viewType, document, storagePath) {
+        const key = this.key(viewType, document.uri);
+        if (( this._documents.has(key))) {
+            throw new Error(`Document already exists for viewType:${viewType} resource:${document.uri}`);
+        }
+        const entry = ( new CustomDocumentStoreEntry(document, storagePath));
+        this._documents.set(key, entry);
+        return entry;
+    }
+    delete(viewType, document) {
+        const key = this.key(viewType, document.uri);
+        this._documents.delete(key);
+    }
+    key(viewType, resource) {
+        return `${viewType}@@@${resource}`;
+    }
+}
+class EditorProviderStore {
+    constructor() {
+        this._providers = ( new Map());
+    }
+    addTextProvider(viewType, extension, provider) {
+        return this.add(0 , viewType, extension, provider);
+    }
+    addCustomProvider(viewType, extension, provider) {
+        return this.add(1 , viewType, extension, provider);
+    }
+    get(viewType) {
+        return this._providers.get(viewType);
+    }
+    add(type, viewType, extension, provider) {
+        if (( this._providers.has(viewType))) {
+            throw new Error(`Provider for viewType:${viewType} already registered`);
+        }
+        this._providers.set(viewType, { type, extension, provider });
+        return new Disposable(() => this._providers.delete(viewType));
+    }
+}
+class ExtHostCustomEditors {
+    constructor(mainContext, _extHostDocuments, _extensionStoragePaths, _extHostWebview, _extHostWebviewPanels) {
+        this._extHostDocuments = _extHostDocuments;
+        this._extensionStoragePaths = _extensionStoragePaths;
+        this._extHostWebview = _extHostWebview;
+        this._extHostWebviewPanels = _extHostWebviewPanels;
+        this._editorProviders = ( new EditorProviderStore());
+        this._documents = ( new CustomDocumentStore());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadCustomEditors));
+    }
+    registerCustomEditorProvider(extension, viewType, provider, options) {
+        const disposables = ( new DisposableStore());
+        if (isCustomTextEditorProvider(provider)) {
+            disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
+            this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
+                supportsMove: !!provider.moveCustomTextEditor,
+            }, shouldSerializeBuffersForPostMessage(extension));
+        }
+        else {
+            disposables.add(this._editorProviders.addCustomProvider(viewType, extension, provider));
+            if (isCustomEditorProviderWithEditingCapability(provider)) {
+                disposables.add(provider.onDidChangeCustomDocument(e => {
+                    const entry = this.getCustomDocumentEntry(viewType, e.document.uri);
+                    if (isEditEvent(e)) {
+                        const editId = entry.addEdit(e);
+                        this._proxy.$onDidEdit(e.document.uri, viewType, editId, e.label);
+                    }
+                    else {
+                        this._proxy.$onContentChange(e.document.uri, viewType);
+                    }
+                }));
+            }
+            this._proxy.$registerCustomEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, !!options.supportsMultipleEditorsPerDocument, shouldSerializeBuffersForPostMessage(extension));
+        }
+        return Disposable.from(disposables, new Disposable(() => {
+            this._proxy.$unregisterEditorProvider(viewType);
+        }));
+    }
+    async $createCustomDocument(resource, viewType, backupId, untitledDocumentData, cancellation) {
+        const entry = this._editorProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No provider found for '${viewType}'`);
+        }
+        if (entry.type !== 1 ) {
+            throw new Error(`Invalid provide type for '${viewType}'`);
+        }
+        const revivedResource = URI.revive(resource);
+        const document = await entry.provider.openCustomDocument(revivedResource, { backupId, untitledDocumentData: untitledDocumentData?.buffer }, cancellation);
+        let storageRoot;
+        if (isCustomEditorProviderWithEditingCapability(entry.provider) && this._extensionStoragePaths) {
+            storageRoot = this._extensionStoragePaths.workspaceValue(entry.extension) ?? this._extensionStoragePaths.globalValue(entry.extension);
+        }
+        this._documents.add(viewType, document, storageRoot);
+        return { editable: isCustomEditorProviderWithEditingCapability(entry.provider) };
+    }
+    async $disposeCustomDocument(resource, viewType) {
+        const entry = this._editorProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No provider found for '${viewType}'`);
+        }
+        if (entry.type !== 1 ) {
+            throw new Error(`Invalid provider type for '${viewType}'`);
+        }
+        const revivedResource = URI.revive(resource);
+        const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
+        this._documents.delete(viewType, document);
+        document.dispose();
+    }
+    async $resolveCustomEditor(resource, handle, viewType, initData, position, cancellation) {
+        const entry = this._editorProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No provider found for '${viewType}'`);
+        }
+        const viewColumn = ViewColumn.to(position);
+        const webview = this._extHostWebview.createNewWebview(handle, initData.contentOptions, entry.extension);
+        const panel = this._extHostWebviewPanels.createNewWebviewPanel(handle, viewType, initData.title, viewColumn, initData.options, webview, initData.active);
+        const revivedResource = URI.revive(resource);
+        switch (entry.type) {
+            case 1 : {
+                const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
+                return entry.provider.resolveCustomEditor(document, panel, cancellation);
+            }
+            case 0 : {
+                const document = this._extHostDocuments.getDocument(revivedResource);
+                return entry.provider.resolveCustomTextEditor(document, panel, cancellation);
+            }
+            default: {
+                throw new Error('Unknown webview provider type');
+            }
+        }
+    }
+    $disposeEdits(resourceComponents, viewType, editIds) {
+        const document = this.getCustomDocumentEntry(viewType, resourceComponents);
+        document.disposeEdits(editIds);
+    }
+    async $onMoveCustomEditor(handle, newResourceComponents, viewType) {
+        const entry = this._editorProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No provider found for '${viewType}'`);
+        }
+        if (!entry.provider.moveCustomTextEditor) {
+            throw new Error(`Provider does not implement move '${viewType}'`);
+        }
+        const webview = this._extHostWebviewPanels.getWebviewPanel(handle);
+        if (!webview) {
+            throw new Error(`No webview found`);
+        }
+        const resource = URI.revive(newResourceComponents);
+        const document = this._extHostDocuments.getDocument(resource);
+        await entry.provider.moveCustomTextEditor(document, webview, CancellationToken.None);
+    }
+    async $undo(resourceComponents, viewType, editId, isDirty) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        return entry.undo(editId, isDirty);
+    }
+    async $redo(resourceComponents, viewType, editId, isDirty) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        return entry.redo(editId, isDirty);
+    }
+    async $revert(resourceComponents, viewType, cancellation) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        const provider = this.getCustomEditorProvider(viewType);
+        await provider.revertCustomDocument(entry.document, cancellation);
+        entry.disposeBackup();
+    }
+    async $onSave(resourceComponents, viewType, cancellation) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        const provider = this.getCustomEditorProvider(viewType);
+        await provider.saveCustomDocument(entry.document, cancellation);
+        entry.disposeBackup();
+    }
+    async $onSaveAs(resourceComponents, viewType, targetResource, cancellation) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        const provider = this.getCustomEditorProvider(viewType);
+        return provider.saveCustomDocumentAs(entry.document, URI.revive(targetResource), cancellation);
+    }
+    async $backup(resourceComponents, viewType, cancellation) {
+        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+        const provider = this.getCustomEditorProvider(viewType);
+        const backup = await provider.backupCustomDocument(entry.document, {
+            destination: entry.getNewBackupUri(),
+        }, cancellation);
+        entry.updateBackup(backup);
+        return backup.id;
+    }
+    getCustomDocumentEntry(viewType, resource) {
+        const entry = this._documents.get(viewType, URI.revive(resource));
+        if (!entry) {
+            throw new Error('No custom document found');
+        }
+        return entry;
+    }
+    getCustomEditorProvider(viewType) {
+        const entry = this._editorProviders.get(viewType);
+        const provider = entry?.provider;
+        if (!provider || !isCustomEditorProviderWithEditingCapability(provider)) {
+            throw new Error('Custom document is not editable');
+        }
+        return provider;
+    }
+}
+function isCustomEditorProviderWithEditingCapability(provider) {
+    return !!provider.onDidChangeCustomDocument;
+}
+function isCustomTextEditorProvider(provider) {
+    return typeof provider.resolveCustomTextEditor === 'function';
+}
+function isEditEvent(e) {
+    return typeof e.undo === 'function'
+        && typeof e.redo === 'function';
+}
+function hashPath(resource) {
+    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( resource.toString());
+    return hash(str) + '';
+}
+export { ExtHostCustomEditors };

package/dist/vscode/vs/workbench/api/common/extHostDialogs.js

@@ -0,0 +1,22 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+class ExtHostDialogs {
+    constructor(mainContext) {
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadDialogs));
+    }
+    showOpenDialog(extension, options) {
+        if (options?.allowUIResources) {
+            checkProposedApiEnabled(extension, 'showLocal');
+        }
+        return this._proxy.$showOpenDialog(options).then(filepaths => {
+            return filepaths ? ( filepaths.map(p => URI.revive(p))) : undefined;
+        });
+    }
+    showSaveDialog(options) {
+        return this._proxy.$showSaveDialog(options).then(filepath => {
+            return filepath ? URI.revive(filepath) : undefined;
+        });
+    }
+}
+export { ExtHostDialogs };

package/dist/vscode/vs/workbench/api/common/extHostLogService.js

@@ -0,0 +1,17 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { LogService } from 'monaco-editor/esm/vs/platform/log/common/logService.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+let ExtHostLogService = class ExtHostLogService extends LogService {
+    constructor(isWorker, loggerService, initData) {
+        const id = initData.remote.isRemote ? 'remoteexthost' : isWorker ? 'workerexthost' : 'exthost';
+        const name = initData.remote.isRemote ? ( localize('remote', "Extension Host (Remote)")) : isWorker ? ( localize('worker', "Extension Host (Worker)")) : ( localize('local', "Extension Host"));
+        super(loggerService.createLogger(id, { name }));
+    }
+};
+ExtHostLogService = ( __decorate([
+    ( __param(1, ILoggerService)),
+    ( __param(2, IExtHostInitDataService))
+], ExtHostLogService));
+export { ExtHostLogService };

package/dist/vscode/vs/workbench/api/common/extHostLoggerService.js

@@ -0,0 +1,63 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { AbstractLoggerService, AbstractMessageLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+let ExtHostLoggerService = class ExtHostLoggerService extends AbstractLoggerService {
+    constructor(rpc, initData) {
+        super(initData.logLevel, initData.logsLocation, ( initData.loggers.map(logger => revive(logger))));
+        this._proxy = ( rpc.getProxy(MainContext.MainThreadLogger));
+    }
+    $setLogLevel(logLevel, resource) {
+        if (resource) {
+            this.setLogLevel(URI.revive(resource), logLevel);
+        }
+        else {
+            this.setLogLevel(logLevel);
+        }
+    }
+    setVisibility(resource, visibility) {
+        super.setVisibility(resource, visibility);
+        this._proxy.$setVisibility(resource, visibility);
+    }
+    doCreateLogger(resource, logLevel, options) {
+        return ( new Logger(this._proxy, resource, logLevel, options));
+    }
+};
+ExtHostLoggerService = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService))
+], ExtHostLoggerService));
+class Logger extends AbstractMessageLogger {
+    constructor(proxy, file, logLevel, loggerOptions) {
+        super(loggerOptions?.logLevel === 'always');
+        this.proxy = proxy;
+        this.file = file;
+        this.isLoggerCreated = false;
+        this.buffer = [];
+        this.setLevel(logLevel);
+        this.proxy.$createLogger(file, loggerOptions)
+            .then(() => {
+            this.doLog(this.buffer);
+            this.isLoggerCreated = true;
+        });
+    }
+    log(level, message) {
+        const messages = [[level, message]];
+        if (this.isLoggerCreated) {
+            this.doLog(messages);
+        }
+        else {
+            this.buffer.push(...messages);
+        }
+    }
+    doLog(messages) {
+        this.proxy.$log(this.file, messages);
+    }
+    flush() {
+        this.proxy.$flush(this.file);
+    }
+}
+export { ExtHostLoggerService };

package/dist/vscode/vs/workbench/api/common/extHostOutput.js

@@ -3,7 +3,7 @@ import { MainContext } from './extHost.protocol.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
-import { parseLogLevel, AbstractMessageLogger, log, ILoggerService, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { parseLogLevel, ILoggerService, ILogService, AbstractMessageLogger, log } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { OutputChannelUpdateMode } from '../../services/output/common/output.js';
 import { IExtHostConsumerFileSystem } from './extHostFileSystemConsumer.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';

package/dist/vscode/vs/workbench/api/common/extHostTextEditor.js

@@ -1,7 +1,7 @@
 import { ok } from 'monaco-editor/esm/vs/base/common/assert.js';
 import { readonly, illegalArgument } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { IdGenerator } from 'monaco-editor/esm/vs/base/common/idGenerator.js';
-import { Position as Position$1, Range as Range$1, isDecorationOptionsArr, fromRangeOrRangeWithMessage, ViewColumn, EndOfLine, TextEditorLineNumbersStyle, Selection as Selection$1, DecorationRenderOptions } from './extHostTypeConverters.js';
+import { DecorationRenderOptions, Position as Position$1, Range as Range$1, isDecorationOptionsArr, fromRangeOrRangeWithMessage, ViewColumn, EndOfLine, TextEditorLineNumbersStyle, Selection as Selection$1 } from './extHostTypeConverters.js';
 import { Selection, Position, Range, TextEditorRevealType, EndOfLine as EndOfLine$1 } from './extHostTypes.js';
 class TextEditorDecorationType {
     constructor(proxy, extension, options) {

package/dist/vscode/vs/workbench/api/common/extHostTypeConverters.js

@@ -19,7 +19,7 @@ import { CellKind } from '../../contrib/notebook/common/notebookCommon.js';
 import { TestId } from '../../contrib/testing/common/testId.js';
 import { namespaceTestTag, denamespaceTestTag } from '../../contrib/testing/common/testTypes.js';
 import { SIDE_GROUP, ACTIVE_GROUP } from '../../services/editor/common/editorService.js';
-import { Position as Position$1, Selection as Selection$1, Range as Range$1, ViewColumn as ViewColumn$1, WorkspaceEdit as WorkspaceEdit$1, SnippetTextEdit, SnippetString, TextEdit as TextEdit$1, SymbolKind as SymbolKind$1, SymbolInformation, CallHierarchyItem as CallHierarchyItem$1, CallHierarchyIncomingCall as CallHierarchyIncomingCall$1, CallHierarchyOutgoingCall as CallHierarchyOutgoingCall$1, Location, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, InlayHint as InlayHint$1, DocumentLink as DocumentLink$1, ColorPresentation as ColorPresentation$1, Color as Color$1, TypeHierarchyItem as TypeHierarchyItem$1, MarkdownString as MarkdownString$1, Hover as Hover$1, DocumentHighlight as DocumentHighlight$1, CompletionItem as CompletionItem$1, InlayHintLabelPart as InlayHintLabelPart$1, FoldingRangeKind as FoldingRangeKind$1, RelativePattern, NotebookRange as NotebookRange$1, NotebookCellData as NotebookCellData$1, TestTag as TestTag$1, Diagnostic as Diagnostic$1, SymbolTag as SymbolTag$1, EndOfLine as EndOfLine$1, NotebookCellOutput as NotebookCellOutput$1, DiagnosticRelatedInformation as DiagnosticRelatedInformation$1, DiagnosticSeverity as DiagnosticSeverity$1, CompletionItemTag as CompletionItemTag$1, CompletionItemKind as CompletionItemKind$1, TextEditorLineNumbersStyle as TextEditorLineNumbersStyle$1, NotebookCellKind as NotebookCellKind$1, DataTransfer as DataTransfer$1, DiagnosticTag as DiagnosticTag$1, NotebookCellOutputItem as NotebookCellOutputItem$1, StandardTokenType, TextDocumentSaveReason as TextDocumentSaveReason$1, ProgressLocation as ProgressLocation$1, InternalFileDataTransferItem, DataTransferFile, InternalDataTransferItem, DocumentSymbol as DocumentSymbol$1, EvaluatableExpression as EvaluatableExpression$1, InlineValueContext as InlineValueContext$1, SelectionRange as SelectionRange$1, CodeActionTriggerKind as CodeActionTriggerKind$1, DecorationRangeBehavior as DecorationRangeBehavior$1, CompletionTriggerKind as CompletionTriggerKind$1 } from './extHostTypes.js';
+import { Position as Position$1, Selection as Selection$1, Range as Range$1, ViewColumn as ViewColumn$1, WorkspaceEdit as WorkspaceEdit$1, SnippetTextEdit, SnippetString, TextEdit as TextEdit$1, SymbolKind as SymbolKind$1, SymbolInformation, CallHierarchyItem as CallHierarchyItem$1, CallHierarchyIncomingCall as CallHierarchyIncomingCall$1, CallHierarchyOutgoingCall as CallHierarchyOutgoingCall$1, Location, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, InlayHint as InlayHint$1, DocumentLink as DocumentLink$1, ColorPresentation as ColorPresentation$1, Color as Color$1, TypeHierarchyItem as TypeHierarchyItem$1, MarkdownString as MarkdownString$1, Hover as Hover$1, DocumentHighlight as DocumentHighlight$1, CompletionItem as CompletionItem$1, InlayHintLabelPart as InlayHintLabelPart$1, FoldingRangeKind as FoldingRangeKind$1, NotebookCellData as NotebookCellData$1, TestTag as TestTag$1, StandardTokenType, Diagnostic as Diagnostic$1, SymbolTag as SymbolTag$1, TextDocumentSaveReason as TextDocumentSaveReason$1, TextEditorLineNumbersStyle as TextEditorLineNumbersStyle$1, EndOfLine as EndOfLine$1, ProgressLocation as ProgressLocation$1, RelativePattern, NotebookRange as NotebookRange$1, NotebookCellOutput as NotebookCellOutput$1, DataTransfer as DataTransfer$1, DiagnosticRelatedInformation as DiagnosticRelatedInformation$1, DiagnosticSeverity as DiagnosticSeverity$1, DocumentSymbol as DocumentSymbol$1, EvaluatableExpression as EvaluatableExpression$1, InlineValueContext as InlineValueContext$1, CompletionItemTag as CompletionItemTag$1, CompletionItemKind as CompletionItemKind$1, SelectionRange as SelectionRange$1, NotebookCellKind as NotebookCellKind$1, CodeActionTriggerKind as CodeActionTriggerKind$1, DiagnosticTag as DiagnosticTag$1, NotebookCellOutputItem as NotebookCellOutputItem$1, InternalFileDataTransferItem, DataTransferFile, InternalDataTransferItem, DecorationRangeBehavior as DecorationRangeBehavior$1, CompletionTriggerKind as CompletionTriggerKind$1 } from './extHostTypes.js';
 var Selection;
 ( ((function(Selection) {
     function to(selection) {