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

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewPanel.contribution.js

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { ShowWebViewEditorFindWidgetAction, HideWebViewEditorFindCommand, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand, ReloadWebviewAction } from './webviewCommands.js';
+import { WebviewEditor } from './webviewEditor.js';
+import { WebviewInput } from './webviewEditorInput.js';
+(( Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, ( localize('webview.editor.label', "webview editor"))), [( new SyncDescriptor(WebviewInput))]);
+let WebviewPanelContribution = class WebviewPanelContribution extends Disposable {
+    constructor(editorGroupService) {
+        super();
+        this.editorGroupService = editorGroupService;
+        this.editorGroupService.whenReady.then(() => this.editorGroupService.groups.forEach(group => {
+            this.registerGroupListener(group);
+        }));
+        this._register(this.editorGroupService.onDidAddGroup(group => this.registerGroupListener(group)));
+    }
+    registerGroupListener(group) {
+        const listener = group.onWillOpenEditor(e => this.onEditorOpening(e.editor, group));
+        Event.once(group.onWillDispose)(() => {
+            listener.dispose();
+        });
+    }
+    onEditorOpening(editor, group) {
+        if (!(editor instanceof WebviewInput) || editor.typeId !== WebviewInput.typeId) {
+            return undefined;
+        }
+        if (group.contains(editor)) {
+            return undefined;
+        }
+        let previousGroup;
+        const groups = this.editorGroupService.groups;
+        for (const group of groups) {
+            if (group.contains(editor)) {
+                previousGroup = group;
+                break;
+            }
+        }
+        if (!previousGroup) {
+            return undefined;
+        }
+        previousGroup.closeEditor(editor);
+    }
+};
+WebviewPanelContribution = ( __decorate([
+    ( __param(0, IEditorGroupsService))
+], WebviewPanelContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(WebviewPanelContribution, 1 );
+registerAction2(ShowWebViewEditorFindWidgetAction);
+registerAction2(HideWebViewEditorFindCommand);
+registerAction2(WebViewEditorFindNextCommand);
+registerAction2(WebViewEditorFindPreviousCommand);
+registerAction2(ReloadWebviewAction);

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.js

@@ -1,11 +1,25 @@
 import { __decorate, __classPrivateFieldGet, __classPrivateFieldSet, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { createCancelablePromise, DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable, toDisposable, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { IWebviewService } from '../../webview/browser/webview.js';
+import { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID } from './webviewEditor.js';
+import { WebviewIconManager } from './webviewIconManager.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { WebviewInput } from './webviewEditorInput.js';
 var _LazilyResolvedWebviewEditorInput_resolved, _LazilyResolvedWebviewEditorInput_resolvePromise;
 const IWebviewWorkbenchService = ( createDecorator('webviewEditorService'));
+function canRevive(reviver, webview) {
+    return reviver.canResolve(webview);
+}
 let LazilyResolvedWebviewEditorInput = class LazilyResolvedWebviewEditorInput extends WebviewInput {
     constructor(init, webview, _webviewWorkbenchService) {
         super(init, webview, _webviewWorkbenchService.iconManager);
@@ -49,4 +63,161 @@ LazilyResolvedWebviewEditorInput.__decorator = ( __decorate([
 LazilyResolvedWebviewEditorInput = ( __decorate([
     ( __param(2, IWebviewWorkbenchService))
 ], LazilyResolvedWebviewEditorInput));
-export { IWebviewWorkbenchService, LazilyResolvedWebviewEditorInput };
+class RevivalPool {
+    constructor() {
+        this._awaitingRevival = [];
+    }
+    enqueueForRestoration(input, token) {
+        const promise = ( new DeferredPromise());
+        const remove = () => {
+            const index = this._awaitingRevival.findIndex(entry => input === entry.input);
+            if (index >= 0) {
+                this._awaitingRevival.splice(index, 1);
+            }
+        };
+        const disposable = combinedDisposable(input.webview.onDidDispose(remove), token.onCancellationRequested(() => {
+            remove();
+            promise.cancel();
+        }));
+        this._awaitingRevival.push({ input, promise, disposable });
+        return promise.p;
+    }
+    reviveFor(reviver, token) {
+        const toRevive = this._awaitingRevival.filter(({ input }) => canRevive(reviver, input));
+        this._awaitingRevival = this._awaitingRevival.filter(({ input }) => !canRevive(reviver, input));
+        for (const { input, promise: resolve, disposable } of toRevive) {
+            reviver.resolveWebview(input, token).then(x => resolve.complete(x), err => resolve.error(err)).finally(() => {
+                disposable.dispose();
+            });
+        }
+    }
+}
+let WebviewEditorService = class WebviewEditorService extends Disposable {
+    constructor(contextKeyService, _editorService, _instantiationService, _webviewService) {
+        super();
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._webviewService = _webviewService;
+        this._revivers = ( new Set());
+        this._revivalPool = ( new RevivalPool());
+        this._onDidChangeActiveWebviewEditor = this._register(( new Emitter()));
+        this.onDidChangeActiveWebviewEditor = this._onDidChangeActiveWebviewEditor.event;
+        this._activeWebviewPanelIdContext = CONTEXT_ACTIVE_WEBVIEW_PANEL_ID.bindTo(contextKeyService);
+        this._iconManager = this._register(this._instantiationService.createInstance(WebviewIconManager));
+        this._register(_editorService.onDidActiveEditorChange(() => {
+            this.updateActiveWebview();
+        }));
+        this._register(_webviewService.onDidChangeActiveWebview(() => {
+            this.updateActiveWebview();
+        }));
+        this.updateActiveWebview();
+    }
+    get iconManager() {
+        return this._iconManager;
+    }
+    updateActiveWebview() {
+        const activeInput = this._editorService.activeEditor;
+        let newActiveWebview;
+        if (activeInput instanceof WebviewInput) {
+            newActiveWebview = activeInput;
+        }
+        else if (activeInput instanceof DiffEditorInput) {
+            if (activeInput.primary instanceof WebviewInput && activeInput.primary.webview === this._webviewService.activeWebview) {
+                newActiveWebview = activeInput.primary;
+            }
+            else if (activeInput.secondary instanceof WebviewInput && activeInput.secondary.webview === this._webviewService.activeWebview) {
+                newActiveWebview = activeInput.secondary;
+            }
+        }
+        if (newActiveWebview) {
+            this._activeWebviewPanelIdContext.set(newActiveWebview.webview.providedViewType ?? '');
+        }
+        else {
+            this._activeWebviewPanelIdContext.reset();
+        }
+        if (newActiveWebview !== this._activeWebview) {
+            this._activeWebview = newActiveWebview;
+            this._onDidChangeActiveWebviewEditor.fire(newActiveWebview);
+        }
+    }
+    openWebview(webviewInitInfo, viewType, title, showOptions) {
+        const webview = this._webviewService.createWebviewOverlay(webviewInitInfo);
+        const webviewInput = this._instantiationService.createInstance(WebviewInput, { viewType, name: title, providedId: webviewInitInfo.providedViewType }, webview, this.iconManager);
+        this._editorService.openEditor(webviewInput, {
+            pinned: true,
+            preserveFocus: showOptions.preserveFocus,
+            activation: showOptions.preserveFocus ? EditorActivation.RESTORE : undefined
+        }, showOptions.group);
+        return webviewInput;
+    }
+    revealWebview(webview, group, preserveFocus) {
+        const topLevelEditor = this.findTopLevelEditorForWebview(webview);
+        this._editorService.openEditor(topLevelEditor, {
+            preserveFocus,
+            activation: preserveFocus ? EditorActivation.RESTORE : undefined
+        }, group);
+    }
+    findTopLevelEditorForWebview(webview) {
+        for (const editor of this._editorService.editors) {
+            if (editor === webview) {
+                return editor;
+            }
+            if (editor instanceof DiffEditorInput) {
+                if (webview === editor.primary || webview === editor.secondary) {
+                    return editor;
+                }
+            }
+        }
+        return webview;
+    }
+    openRevivedWebview(options) {
+        const webview = this._webviewService.createWebviewOverlay(options.webviewInitInfo);
+        webview.state = options.state;
+        const webviewInput = this._instantiationService.createInstance(LazilyResolvedWebviewEditorInput, { viewType: options.viewType, providedId: options.webviewInitInfo.providedViewType, name: options.title }, webview);
+        webviewInput.iconPath = options.iconPath;
+        if (typeof options.group === 'number') {
+            webviewInput.updateGroup(options.group);
+        }
+        return webviewInput;
+    }
+    registerResolver(reviver) {
+        this._revivers.add(reviver);
+        const cts = ( new CancellationTokenSource());
+        this._revivalPool.reviveFor(reviver, cts.token);
+        return toDisposable(() => {
+            this._revivers.delete(reviver);
+            cts.dispose(true);
+        });
+    }
+    shouldPersist(webview) {
+        if (webview instanceof LazilyResolvedWebviewEditorInput) {
+            return true;
+        }
+        return ( Iterable.some(( this._revivers.values()), reviver => canRevive(reviver, webview)));
+    }
+    async tryRevive(webview, token) {
+        for (const reviver of ( this._revivers.values())) {
+            if (canRevive(reviver, webview)) {
+                await reviver.resolveWebview(webview, token);
+                return true;
+            }
+        }
+        return false;
+    }
+    async resolveWebview(webview, token) {
+        const didRevive = await this.tryRevive(webview, token);
+        if (!didRevive && !token.isCancellationRequested) {
+            return this._revivalPool.enqueueForRestoration(webview, token);
+        }
+    }
+    setIcons(id, iconPath) {
+        this._iconManager.setIcons(id, iconPath);
+    }
+};
+WebviewEditorService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IWebviewService))
+], WebviewEditorService));
+export { IWebviewWorkbenchService, LazilyResolvedWebviewEditorInput, WebviewEditorService };

package/dist/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService.js

@@ -1,3 +1,45 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IWebviewViewService = ( createDecorator('webviewViewService'));
-export { IWebviewViewService };
+class WebviewViewService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._resolvers = ( new Map());
+        this._awaitingRevival = ( new Map());
+        this._onNewResolverRegistered = this._register(( new Emitter()));
+        this.onNewResolverRegistered = this._onNewResolverRegistered.event;
+    }
+    register(viewType, resolver) {
+        if (( this._resolvers.has(viewType))) {
+            throw new Error(`View resolver already registered for ${viewType}`);
+        }
+        this._resolvers.set(viewType, resolver);
+        this._onNewResolverRegistered.fire({ viewType: viewType });
+        const pending = this._awaitingRevival.get(viewType);
+        if (pending) {
+            resolver.resolve(pending.webview, CancellationToken.None).then(() => {
+                this._awaitingRevival.delete(viewType);
+                pending.resolve();
+            });
+        }
+        return toDisposable(() => {
+            this._resolvers.delete(viewType);
+        });
+    }
+    resolve(viewType, webview, cancellation) {
+        const resolver = this._resolvers.get(viewType);
+        if (!resolver) {
+            if (( this._awaitingRevival.has(viewType))) {
+                throw new Error('View already awaiting revival');
+            }
+            let resolve;
+            const p = ( new Promise(r => resolve = r));
+            this._awaitingRevival.set(viewType, { webview, resolve: resolve });
+            return p;
+        }
+        return resolver.resolve(webview, cancellation);
+    }
+}
+export { IWebviewViewService, WebviewViewService };

package/dist/vscode/vs/workbench/services/outline/browser/outlineService.js

@@ -0,0 +1,35 @@
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class OutlineService {
+    constructor() {
+        this._factories = ( new LinkedList());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+    }
+    canCreateOutline(pane) {
+        for (const factory of this._factories) {
+            if (factory.matches(pane)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async createOutline(pane, target, token) {
+        for (const factory of this._factories) {
+            if (factory.matches(pane)) {
+                return await factory.createOutline(pane, target, token);
+            }
+        }
+        return undefined;
+    }
+    registerOutlineCreator(creator) {
+        const rm = this._factories.push(creator);
+        this._onDidChange.fire();
+        return toDisposable(() => {
+            rm();
+            this._onDidChange.fire();
+        });
+    }
+}
+export { OutlineService };

package/dist/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy.js

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
+    constructor(resource, fileService) {
+        super();
+        this.resource = resource;
+        this.fileService = fileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.orphaned = false;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this.disposed = false;
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+    }
+    isOrphaned() {
+        return this.orphaned;
+    }
+    async onDidFilesChange(e) {
+        let fileEventImpactsUs = false;
+        let newInOrphanModeGuess;
+        if (this.orphaned) {
+            const fileWorkingCopyResourceAdded = e.contains(this.resource, 1 );
+            if (fileWorkingCopyResourceAdded) {
+                newInOrphanModeGuess = false;
+                fileEventImpactsUs = true;
+            }
+        }
+        else {
+            const fileWorkingCopyResourceDeleted = e.contains(this.resource, 2 );
+            if (fileWorkingCopyResourceDeleted) {
+                newInOrphanModeGuess = true;
+                fileEventImpactsUs = true;
+            }
+        }
+        if (fileEventImpactsUs && this.orphaned !== newInOrphanModeGuess) {
+            let newInOrphanModeValidated = false;
+            if (newInOrphanModeGuess) {
+                await timeout(100);
+                if (this.isDisposed()) {
+                    newInOrphanModeValidated = true;
+                }
+                else {
+                    const exists = await this.fileService.exists(this.resource);
+                    newInOrphanModeValidated = !exists;
+                }
+            }
+            if (this.orphaned !== newInOrphanModeValidated && !this.isDisposed()) {
+                this.setOrphaned(newInOrphanModeValidated);
+            }
+        }
+    }
+    setOrphaned(orphaned) {
+        if (this.orphaned !== orphaned) {
+            this.orphaned = orphaned;
+            this._onDidChangeOrphaned.fire();
+        }
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    dispose() {
+        this.disposed = true;
+        this.orphaned = false;
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+    isModified() {
+        return this.isDirty();
+    }
+};
+ResourceWorkingCopy = ( __decorate([
+    ( __param(1, IFileService))
+], ResourceWorkingCopy));
+export { ResourceWorkingCopy };

package/dist/{vscode-services → vscode-apis}/commands.js

@@ -1,4 +1,4 @@
-import { getExtHostServices } from './extHost.js';
+import { getExtHostServices } from '../extHost.js';
 function create(getExtension) {
     return {
         registerCommand(id, command, thisArgs) {

package/dist/{vscode-services → vscode-apis}/debug.js

@@ -1,5 +1,5 @@
 import { DebugConfigurationProviderTriggerKind } from '../vscode/vs/workbench/contrib/debug/common/debug.js';
-import { getExtHostServices } from './extHost.js';
+import { getExtHostServices } from '../extHost.js';
 function create(getExtension) {
     return {
         get activeDebugSession() {

package/dist/{vscode-services → vscode-apis}/env.js

@@ -1,18 +1,16 @@
 import { matchesScheme } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { ExtHostTelemetryLogger } from '../vscode/vs/workbench/api/common/extHostTelemetry.js';
-import { IExtHostInitDataService } from '../vscode/vs/workbench/api/common/extHostInitDataService.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { getExtHostServices } from './extHost.js';
+import { getExtHostServices } from '../extHost.js';
 function create(getExtension) {
     return {
-        get machineId() { return StandaloneServices.get(IExtHostInitDataService).telemetryInfo.machineId; },
-        get sessionId() { return StandaloneServices.get(IExtHostInitDataService).telemetryInfo.sessionId; },
-        get language() { return StandaloneServices.get(IExtHostInitDataService).environment.appLanguage; },
-        get appName() { return StandaloneServices.get(IExtHostInitDataService).environment.appName; },
-        get appRoot() { return StandaloneServices.get(IExtHostInitDataService).environment.appRoot?.fsPath ?? ''; },
-        get appHost() { return StandaloneServices.get(IExtHostInitDataService).environment.appHost; },
-        get uriScheme() { return StandaloneServices.get(IExtHostInitDataService).environment.appUriScheme; },
+        get machineId() { return getExtHostServices().extHostInitData.telemetryInfo.machineId; },
+        get sessionId() { return getExtHostServices().extHostInitData.telemetryInfo.sessionId; },
+        get language() { return getExtHostServices().extHostInitData.environment.appLanguage; },
+        get appName() { return getExtHostServices().extHostInitData.environment.appName; },
+        get appRoot() { return getExtHostServices().extHostInitData.environment.appRoot?.fsPath ?? ''; },
+        get appHost() { return getExtHostServices().extHostInitData.environment.appHost; },
+        get uriScheme() { return getExtHostServices().extHostInitData.environment.appUriScheme; },
         get clipboard() {
             const { extHostClipboard } = getExtHostServices();
             return extHostClipboard.value;
@@ -23,7 +21,7 @@ function create(getExtension) {
             return extHostTerminalService.getDefaultShell(false);
         },
         get uiKind() {
-            return StandaloneServices.get(IExtHostInitDataService).uiKind;
+            return getExtHostServices().extHostInitData.uiKind;
         },
         async asExternalUri(uri) {
             const { extHostWindow } = getExtHostServices();

package/dist/{vscode-services → vscode-apis}/extensions.js

@@ -1,8 +1,9 @@
+import { ExtensionIdentifierSet } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Extension } from '../vscode/vs/workbench/api/common/extHostExtensionService.js';
-import { isProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
+import { isProposedApiEnabled, checkProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
 import { ExtensionKind } from '../vscode/vs/workbench/api/common/extHostTypes.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { getExtHostServices } from './extHost.js';
+import { getExtHostServices } from '../extHost.js';
 function create(getExtension) {
     return {
         getExtension(extensionId, includeFromDifferentExtensionHosts = false) {
@@ -33,6 +34,19 @@ function create(getExtension) {
             }
             return result;
         },
+        get allAcrossExtensionHosts() {
+            const extension = getExtension();
+            const { extHostExtensionService } = getExtHostServices();
+            const extensionInfo = extHostExtensionService.getExtensionRegistries();
+            checkProposedApiEnabled(extension, 'extensionsAny');
+            const local = new ExtensionIdentifierSet(( extensionInfo.mine.getAllExtensionDescriptions().map(desc => desc.identifier)));
+            const result = [];
+            for (const desc of extensionInfo.all.getAllExtensionDescriptions()) {
+                const isFromDifferentExtensionHost = !( local.has(desc.identifier));
+                result.push(new Extension(extHostExtensionService, extension.identifier, desc, ExtensionKind.UI, isFromDifferentExtensionHost));
+            }
+            return result;
+        },
         get onDidChange() {
             const { extHostExtensionService } = getExtHostServices();
             const extensionInfo = extHostExtensionService.getExtensionRegistries();

package/dist/{vscode-services → vscode-apis}/l10n.js

@@ -1,4 +1,4 @@
-import { getExtHostServices } from './extHost.js';
+import { getExtHostServices } from '../extHost.js';
 function create(getExtension) {
     return {
         t(...params) {

package/dist/{vscode-services → vscode-apis}/languages.js

@@ -1,6 +1,7 @@
 import { score } from 'monaco-editor/esm/vs/editor/common/languageSelector.js';
 import { LanguageSelector } from '../vscode/vs/workbench/api/common/extHostTypeConverters.js';
-import { getExtHostServices } from './extHost.js';
+import { checkProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
+import { getExtHostServices } from '../extHost.js';
 function checkSelector(selector) {
     return selector;
 }
@@ -35,6 +36,12 @@ function create(getExtension) {
             const extension = getExtension();
             return extHostLanguageFeatures.registerCodeActionProvider(extension, checkSelector(selector), provider, metadata);
         },
+        registerDocumentPasteEditProvider(selector, provider, metadata) {
+            const { extHostLanguageFeatures } = getExtHostServices();
+            const extension = getExtension();
+            checkProposedApiEnabled(extension, 'documentPaste');
+            return extHostLanguageFeatures.registerDocumentPasteEditProvider(extension, checkSelector(selector), provider, metadata);
+        },
         registerCodeLensProvider(selector, provider) {
             const { extHostLanguageFeatures } = getExtHostServices();
             const extension = getExtension();

package/dist/{vscode-services → vscode-apis}/window.js

@@ -2,7 +2,8 @@ import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ProgressLocation } from '../vscode/vs/workbench/api/common/extHostTypes.js';
-import { getExtHostServices } from './extHost.js';
+import { checkProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
+import { getExtHostServices } from '../extHost.js';
 import { unsupported } from '../tools.js';
 class TextTabInput {
     constructor(uri) {
@@ -69,9 +70,20 @@ function create(getExtension, workspace) {
             const { extHostQuickOpen } = getExtHostServices();
             return extHostQuickOpen.showWorkspaceFolderPick(options);
         },
-        showOpenDialog: unsupported,
-        showSaveDialog: unsupported,
-        createWebviewPanel: unsupported,
+        showOpenDialog(options) {
+            const extension = getExtension();
+            const { extHostDialogs } = getExtHostServices();
+            return extHostDialogs.showOpenDialog(extension, options);
+        },
+        showSaveDialog(options) {
+            const { extHostDialogs } = getExtHostServices();
+            return extHostDialogs.showSaveDialog(options);
+        },
+        createWebviewPanel(viewType, title, showOptions, options) {
+            const extension = getExtension();
+            const { extHostWebviewPanels } = getExtHostServices();
+            return extHostWebviewPanels.createWebviewPanel(extension, viewType, title, showOptions, options);
+        },
         createStatusBarItem(alignmentOrId, priorityOrAlignment, priorityArg) {
             const { extHostStatusBar } = getExtHostServices();
             const extension = getExtension();
@@ -113,7 +125,11 @@ function create(getExtension, workspace) {
             const extension = getExtension();
             return extHostTreeViews.createTreeView(viewId, options, extension);
         },
-        registerWebviewPanelSerializer: unsupported,
+        registerWebviewPanelSerializer: (viewType, serializer) => {
+            const extension = getExtension();
+            const { extHostWebviewPanels } = getExtHostServices();
+            return extHostWebviewPanels.registerWebviewPanelSerializer(extension, viewType, serializer);
+        },
         get activeTextEditor() {
             const { extHostEditors } = getExtHostServices();
             return extHostEditors.getActiveTextEditor();
@@ -176,8 +192,16 @@ function create(getExtension, workspace) {
             return extHostWindow.onDidChangeWindowState(listener, thisArg, disposables);
         },
         registerUriHandler: unsupported,
-        registerWebviewViewProvider: unsupported,
-        registerCustomEditorProvider: unsupported,
+        registerWebviewViewProvider(viewId, provider, options) {
+            const extension = getExtension();
+            const { extHostWebviewViews } = getExtHostServices();
+            return extHostWebviewViews.registerWebviewViewProvider(extension, viewId, provider, options?.webviewOptions);
+        },
+        registerCustomEditorProvider: (viewType, provider, options = {}) => {
+            const extension = getExtension();
+            const { extHostCustomEditors } = getExtHostServices();
+            return extHostCustomEditors.registerCustomEditorProvider(extension, viewType, provider, options);
+        },
         registerTerminalLinkProvider(provider) {
             const { extHostTerminalService } = getExtHostServices();
             return extHostTerminalService.registerLinkProvider(provider);
@@ -209,6 +233,12 @@ function create(getExtension, workspace) {
             return extHostEditorTabs.tabGroups;
         },
         showNotebookDocument: unsupported,
+        registerExternalUriOpener(id, opener, metadata) {
+            const extension = getExtension();
+            const { extHostUriOpeners } = getExtHostServices();
+            checkProposedApiEnabled(extension, 'externalUriOpener');
+            return extHostUriOpeners.registerExternalUriOpener(extension.identifier, id, opener, metadata);
+        },
         visibleNotebookEditors: [],
         onDidChangeVisibleNotebookEditors: Event.None,
         activeNotebookEditor: undefined,

package/dist/{vscode-services → vscode-apis}/workspace.js

@@ -2,7 +2,7 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { checkProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
-import { getExtHostServices, getConfigProvider } from './extHost.js';
+import { getExtHostServices, getConfigProvider } from '../extHost.js';
 import { unsupported } from '../tools.js';
 function create(getExtension) {
     return {
@@ -149,8 +149,8 @@ function create(getExtension) {
             return extHostWorkspace.updateWorkspaceFolders(getExtension(), index, deleteCount ?? 0, ...workspaceFoldersToAdd);
         },
         registerTextDocumentContentProvider(scheme, provider) {
-            const { extHostDocumentContentProviders } = getExtHostServices();
-            return extHostDocumentContentProviders.registerTextDocumentContentProvider(scheme, provider);
+            const { extHostDocumentContentProvider } = getExtHostServices();
+            return extHostDocumentContentProvider.registerTextDocumentContentProvider(scheme, provider);
         },
         registerTaskProvider: unsupported,
         registerFileSystemProvider(scheme, provider, options) {