@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

package/vscode/src/vs/workbench/contrib/webview/browser/webviewFindWidget.js

@@ -0,0 +1,63 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { SimpleFindWidget } from '../../codeEditor/browser/find/simpleFindWidget.js';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED } from './webview.js';
+let WebviewFindWidget = class WebviewFindWidget extends SimpleFindWidget {
+    async _getResultCount(dataChanged) {
+        return undefined;
+    }
+    constructor(_delegate, contextViewService, contextKeyService, keybindingService) {
+        super({
+            showCommonFindToggles: false,
+            checkImeCompletionState: _delegate.checkImeCompletionState,
+            enableSash: true,
+        }, contextViewService, contextKeyService, keybindingService);
+        this._delegate = _delegate;
+        this._findWidgetFocused = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED.bindTo(contextKeyService);
+        this._register(_delegate.hasFindResult(hasResult => {
+            this.updateButtons(hasResult);
+            this.focusFindBox();
+        }));
+        this._register(_delegate.onDidStopFind(() => {
+            this.updateButtons(false);
+        }));
+    }
+    find(previous) {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.find(val, previous);
+        }
+    }
+    hide(animated = true) {
+        super.hide(animated);
+        this._delegate.stopFind(true);
+        this._delegate.focus();
+    }
+    _onInputChanged() {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.updateFind(val);
+        }
+        else {
+            this._delegate.stopFind(false);
+        }
+        return false;
+    }
+    _onFocusTrackerFocus() {
+        this._findWidgetFocused.set(true);
+    }
+    _onFocusTrackerBlur() {
+        this._findWidgetFocused.reset();
+    }
+    _onFindInputFocusTrackerFocus() { }
+    _onFindInputFocusTrackerBlur() { }
+    findFirst() { }
+};
+WebviewFindWidget = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IKeybindingService))
+], WebviewFindWidget));
+export { WebviewFindWidget };

package/vscode/src/vs/workbench/contrib/webview/browser/webviewService.js

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { WebviewThemeDataProvider } from './themeing.js';
+import { WebviewElement } from './webviewElement.js';
+import { OverlayWebview } from './overlayWebview.js';
+let WebviewService = class WebviewService extends Disposable {
+    constructor(_instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._webviews = ( new Set());
+        this._onDidChangeActiveWebview = this._register(( new Emitter()));
+        this.onDidChangeActiveWebview = this._onDidChangeActiveWebview.event;
+        this._webviewThemeDataProvider = this._instantiationService.createInstance(WebviewThemeDataProvider);
+    }
+    get activeWebview() { return this._activeWebview; }
+    _updateActiveWebview(value) {
+        if (value !== this._activeWebview) {
+            this._activeWebview = value;
+            this._onDidChangeActiveWebview.fire(value);
+        }
+    }
+    get webviews() {
+        return ( this._webviews.values());
+    }
+    createWebviewElement(initInfo) {
+        const webview = this._instantiationService.createInstance(WebviewElement, initInfo, this._webviewThemeDataProvider);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    createWebviewOverlay(initInfo) {
+        const webview = this._instantiationService.createInstance(OverlayWebview, initInfo);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    registerNewWebview(webview) {
+        this._webviews.add(webview);
+        webview.onDidFocus(() => {
+            this._updateActiveWebview(webview);
+        });
+        const onBlur = () => {
+            if (this._activeWebview === webview) {
+                this._updateActiveWebview(undefined);
+            }
+        };
+        webview.onDidBlur(onBlur);
+        webview.onDidDispose(() => {
+            onBlur();
+            this._webviews.delete(webview);
+        });
+    }
+};
+WebviewService = ( __decorate([
+    ( __param(0, IInstantiationService))
+], WebviewService));
+export { WebviewService };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewCommands.js

@@ -0,0 +1,140 @@
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, IWebviewService } from '../../webview/browser/webview.js';
+import { WebviewEditor } from './webviewEditor.js';
+import { WebviewInput } from './webviewEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+const webviewActiveContextKeyExpr = ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', WebviewEditor.ID)), ( EditorContextKeys.focus.toNegated() )));
+class ShowWebViewEditorFindWidgetAction extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.showFind'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.showFind',
+        "Show find"
+    )); }
+    constructor() {
+        super({
+            id: ShowWebViewEditorFindWidgetAction.ID,
+            title: ShowWebViewEditorFindWidgetAction.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED
+                )),
+                primary: 2048  | 36 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.showFind();
+    }
+}
+class HideWebViewEditorFindCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.hideFind'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.hideFind',
+        "Stop find"
+    )); }
+    constructor() {
+        super({
+            id: HideWebViewEditorFindCommand.ID,
+            title: HideWebViewEditorFindCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE
+                )),
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.hideFind();
+    }
+}
+class WebViewEditorFindNextCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.findNext'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.findNext',
+        'Find next'
+    )); }
+    constructor() {
+        super({
+            id: WebViewEditorFindNextCommand.ID,
+            title: WebViewEditorFindNextCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(false);
+    }
+}
+class WebViewEditorFindPreviousCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.findPrevious'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.findPrevious',
+        'Find previous'
+    )); }
+    constructor() {
+        super({
+            id: WebViewEditorFindPreviousCommand.ID,
+            title: WebViewEditorFindPreviousCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 1024  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(true);
+    }
+}
+class ReloadWebviewAction extends Action2 {
+    static { this.ID = 'workbench.action.webview.reloadWebviewAction'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'refreshWebviewLabel',
+        "Reload Webviews"
+    )); }
+    constructor() {
+        super({
+            id: ReloadWebviewAction.ID,
+            title: { value: ReloadWebviewAction.LABEL, original: 'Reload Webviews' },
+            category: Categories.Developer,
+            menu: [{
+                    id: MenuId.CommandPalette
+                }]
+        });
+    }
+    async run(accessor) {
+        const webviewService = accessor.get(IWebviewService);
+        for (const webview of webviewService.webviews) {
+            webview.reload();
+        }
+    }
+}
+function getActiveWebviewEditor(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const activeEditor = editorService.activeEditor;
+    return activeEditor instanceof WebviewInput ? activeEditor.webview : undefined;
+}
+export { HideWebViewEditorFindCommand, ReloadWebviewAction, ShowWebViewEditorFindWidgetAction, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditorInputSerializer.js

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { WebviewInput } from './webviewEditorInput.js';
+import { IWebviewWorkbenchService } from './webviewWorkbenchService.js';
+let WebviewEditorInputSerializer = class WebviewEditorInputSerializer {
+    static { this.ID = WebviewInput.typeId; }
+    constructor(_webviewWorkbenchService) {
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+    }
+    canSerialize(input) {
+        return this._webviewWorkbenchService.shouldPersist(input);
+    }
+    serialize(input) {
+        if (!this._webviewWorkbenchService.shouldPersist(input)) {
+            return undefined;
+        }
+        const data = this.toJson(input);
+        try {
+            return JSON.stringify(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    deserialize(_instantiationService, serializedEditorInput) {
+        const data = this.fromJson(JSON.parse(serializedEditorInput));
+        return this._webviewWorkbenchService.openRevivedWebview({
+            webviewInitInfo: {
+                providedViewType: data.providedId,
+                origin: data.origin,
+                title: data.title,
+                options: data.webviewOptions,
+                contentOptions: data.contentOptions,
+                extension: data.extension,
+            },
+            viewType: data.viewType,
+            title: data.title,
+            iconPath: data.iconPath,
+            state: data.state,
+            group: data.group
+        });
+    }
+    fromJson(data) {
+        return {
+            ...data,
+            extension: reviveWebviewExtensionDescription(data.extensionId, data.extensionLocation),
+            iconPath: reviveIconPath(data.iconPath),
+            state: reviveState(data.state),
+            webviewOptions: restoreWebviewOptions(data.options),
+            contentOptions: restoreWebviewContentOptions(data.options),
+        };
+    }
+    toJson(input) {
+        return {
+            origin: input.webview.origin,
+            viewType: input.viewType,
+            providedId: input.providedId,
+            title: input.getName(),
+            options: { ...input.webview.options, ...input.webview.contentOptions },
+            extensionLocation: input.extension?.location,
+            extensionId: input.extension?.id.value,
+            state: input.webview.state,
+            iconPath: input.iconPath ? { light: input.iconPath.light, dark: input.iconPath.dark, } : undefined,
+            group: input.group
+        };
+    }
+};
+WebviewEditorInputSerializer = ( __decorate([
+    ( __param(0, IWebviewWorkbenchService))
+], WebviewEditorInputSerializer));
+function reviveWebviewExtensionDescription(extensionId, extensionLocation) {
+    if (!extensionId) {
+        return undefined;
+    }
+    const location = reviveUri(extensionLocation);
+    if (!location) {
+        return undefined;
+    }
+    return {
+        id: ( new ExtensionIdentifier(extensionId)),
+        location,
+    };
+}
+function reviveIconPath(data) {
+    if (!data) {
+        return undefined;
+    }
+    const light = reviveUri(data.light);
+    const dark = reviveUri(data.dark);
+    return light && dark ? { light, dark } : undefined;
+}
+function reviveUri(data) {
+    if (!data) {
+        return undefined;
+    }
+    try {
+        if (typeof data === 'string') {
+            return ( URI.parse(data));
+        }
+        return ( URI.from(data));
+    }
+    catch {
+        return undefined;
+    }
+}
+function reviveState(state) {
+    return typeof state === 'string' ? state : undefined;
+}
+function restoreWebviewOptions(options) {
+    return options;
+}
+function restoreWebviewContentOptions(options) {
+    return {
+        ...options,
+        localResourceRoots: options.localResourceRoots?.map(uri => reviveUri(uri)),
+    };
+}
+export { WebviewEditorInputSerializer, restoreWebviewContentOptions, restoreWebviewOptions, reviveWebviewExtensionDescription };

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { Registry } from '../../../../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';
+import { WebviewEditorInputSerializer } from './webviewEditorInputSerializer.js';
+(( Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/webviewPanel/browser/webviewPanel.contribution',
+    '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 );
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(WebviewEditorInputSerializer.ID, WebviewEditorInputSerializer);
+registerAction2(ShowWebViewEditorFindWidgetAction);
+registerAction2(HideWebViewEditorFindCommand);
+registerAction2(WebViewEditorFindNextCommand);
+registerAction2(WebViewEditorFindPreviousCommand);
+registerAction2(ReloadWebviewAction);

package/vscode/src/vs/workbench/contrib/webviewView/browser/webviewViewPane.js

@@ -0,0 +1,233 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Dimension, EventType, addDisposableListener, findParentWithClass } from '../../../../base/browser/dom.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { MutableDisposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ViewPane, ViewPaneShowActions } from '../../../browser/parts/views/viewPane.js';
+import { Memento } from '../../../common/memento.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { ExtensionKeyedWebviewOriginStore, IWebviewService } from '../../webview/browser/webview.js';
+import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDragMonitor.js';
+import { IWebviewViewService } from './webviewViewService.js';
+import { IActivityService, NumberBadge } from '../../../services/activity/common/activity.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+var WebviewViewPane_1;
+const storageKeys = {
+    webviewState: 'webviewState',
+};
+let WebviewViewPane = class WebviewViewPane extends ViewPane {
+    static { WebviewViewPane_1 = this; }
+    static getOriginStore(storageService) {
+        this._originStore ??= ( new ExtensionKeyedWebviewOriginStore('webviewViews.origins', storageService));
+        return this._originStore;
+    }
+    constructor(options, configurationService, contextKeyService, contextMenuService, instantiationService, keybindingService, openerService, telemetryService, themeService, viewDescriptorService, activityService, extensionService, progressService, storageService, viewService, webviewService, webviewViewService) {
+        super({ ...options, titleMenuId: MenuId.ViewTitle, showActions: ViewPaneShowActions.WhenExpanded }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.activityService = activityService;
+        this.extensionService = extensionService;
+        this.progressService = progressService;
+        this.storageService = storageService;
+        this.viewService = viewService;
+        this.webviewService = webviewService;
+        this.webviewViewService = webviewViewService;
+        this._webview = this._register(( new MutableDisposable()));
+        this._webviewDisposables = this._register(( new DisposableStore()));
+        this._activated = false;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDispose = this._register(( new Emitter()));
+        this.onDispose = this._onDispose.event;
+        this.extensionId = options.fromExtensionId;
+        this.defaultTitle = this.title;
+        this.memento = ( new Memento(`webviewView.${this.id}`, storageService));
+        this.viewState = this.memento.getMemento(1 , 1 );
+        this._register(this.onDidChangeBodyVisibility(() => this.updateTreeVisibility()));
+        this._register(this.webviewViewService.onNewResolverRegistered(e => {
+            if (e.viewType === this.id) {
+                this.updateTreeVisibility();
+            }
+        }));
+        this.updateTreeVisibility();
+    }
+    dispose() {
+        this._onDispose.fire();
+        clearTimeout(this._repositionTimeout);
+        super.dispose();
+    }
+    focus() {
+        super.focus();
+        this._webview.value?.focus();
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this._container = container;
+        this._rootContainer = undefined;
+        if (!this._resizeObserver) {
+            this._resizeObserver = ( new ResizeObserver(() => {
+                setTimeout(() => {
+                    this.layoutWebview();
+                }, 0);
+            }));
+            this._register(toDisposable(() => {
+                this._resizeObserver.disconnect();
+            }));
+            this._resizeObserver.observe(container);
+        }
+    }
+    saveState() {
+        if (this._webview.value) {
+            this.viewState[storageKeys.webviewState] = this._webview.value.state;
+        }
+        this.memento.saveMemento();
+        super.saveState();
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.layoutWebview(( new Dimension(width, height)));
+    }
+    updateTreeVisibility() {
+        if (this.isBodyVisible()) {
+            this.activate();
+            this._webview.value?.claim(this, undefined);
+        }
+        else {
+            this._webview.value?.release(this);
+        }
+    }
+    activate() {
+        if (this._activated) {
+            return;
+        }
+        this._activated = true;
+        const origin = this.extensionId ? WebviewViewPane_1.getOriginStore(this.storageService).getOrigin(this.id, this.extensionId) : undefined;
+        const webview = this.webviewService.createWebviewOverlay({
+            origin,
+            providedViewType: this.id,
+            title: this.title,
+            options: { purpose: "webviewView"  },
+            contentOptions: {},
+            extension: this.extensionId ? { id: this.extensionId } : undefined
+        });
+        webview.state = this.viewState[storageKeys.webviewState];
+        this._webview.value = webview;
+        if (this._container) {
+            this.layoutWebview();
+        }
+        this._webviewDisposables.add(toDisposable(() => {
+            this._webview.value?.release(this);
+        }));
+        this._webviewDisposables.add(webview.onDidUpdateState(() => {
+            this.viewState[storageKeys.webviewState] = webview.state;
+        }));
+        for (const event of [EventType.DRAG, EventType.DRAG_END, EventType.DRAG_ENTER, EventType.DRAG_LEAVE, EventType.DRAG_START]) {
+            this._webviewDisposables.add(addDisposableListener(this._webview.value.container, event, e => {
+                e.preventDefault();
+                e.stopImmediatePropagation();
+                this.dropTargetElement.dispatchEvent(( new DragEvent(e.type, e)));
+            }));
+        }
+        this._webviewDisposables.add(( new WebviewWindowDragMonitor(() => this._webview.value)));
+        const source = this._webviewDisposables.add(( new CancellationTokenSource()));
+        this.withProgress(async () => {
+            await this.extensionService.activateByEvent(`onView:${this.id}`);
+            const self = this;
+            const webviewView = {
+                webview,
+                onDidChangeVisibility: this.onDidChangeBodyVisibility,
+                onDispose: this.onDispose,
+                get title() { return self.setTitle; },
+                set title(value) { self.updateTitle(value); },
+                get description() { return self.titleDescription; },
+                set description(value) { self.updateTitleDescription(value); },
+                get badge() { return self.badge; },
+                set badge(badge) { self.updateBadge(badge); },
+                dispose: () => {
+                    this._activated = false;
+                    this._webview.clear();
+                    this._webviewDisposables.clear();
+                },
+                show: (preserveFocus) => {
+                    this.viewService.openView(this.id, !preserveFocus);
+                }
+            };
+            await this.webviewViewService.resolve(this.id, webviewView, source.token);
+        });
+    }
+    updateTitle(value) {
+        this.setTitle = value;
+        super.updateTitle(typeof value === 'string' ? value : this.defaultTitle);
+    }
+    updateBadge(badge) {
+        if (this.badge?.value === badge?.value &&
+            this.badge?.tooltip === badge?.tooltip) {
+            return;
+        }
+        if (this.activity) {
+            this.activity.dispose();
+            this.activity = undefined;
+        }
+        this.badge = badge;
+        if (badge) {
+            const activity = {
+                badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
+                priority: 150
+            };
+            this.activityService.showViewActivity(this.id, activity);
+        }
+    }
+    async withProgress(task) {
+        return this.progressService.withProgress({ location: this.id, delay: 500 }, task);
+    }
+    onDidScrollRoot() {
+        this.layoutWebview();
+    }
+    doLayoutWebview(dimension) {
+        const webviewEntry = this._webview.value;
+        if (!this._container || !webviewEntry) {
+            return;
+        }
+        if (!this._rootContainer || !this._rootContainer.isConnected) {
+            this._rootContainer = this.findRootContainer(this._container);
+        }
+        webviewEntry.layoutWebviewOverElement(this._container, dimension, this._rootContainer);
+    }
+    layoutWebview(dimension) {
+        this.doLayoutWebview(dimension);
+        clearTimeout(this._repositionTimeout);
+        this._repositionTimeout = setTimeout(() => this.doLayoutWebview(dimension), 200);
+    }
+    findRootContainer(container) {
+        return findParentWithClass(container, 'monaco-scrollable-element') ?? undefined;
+    }
+};
+WebviewViewPane = WebviewViewPane_1 = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IOpenerService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IActivityService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, IProgressService)),
+    ( __param(13, IStorageService)),
+    ( __param(14, IViewsService)),
+    ( __param(15, IWebviewService)),
+    ( __param(16, IWebviewViewService))
+], WebviewViewPane));
+export { WebviewViewPane };