@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

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

@@ -0,0 +1,234 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Dimension, getWindow, EventType, addDisposableListener, findParentWithClass } from 'vscode/vscode/vs/base/browser/dom';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { MutableDisposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { ViewPane, ViewPaneShowActions } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ExtensionKeyedWebviewOriginStore } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview.service';
+import { WebviewWindowDragMonitor } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor';
+import { IWebviewViewService } from 'vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService.service';
+import { NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+
+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.activity = this._register(( new MutableDisposable()));
+        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, getWindow(this.element), 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(getWindow(this.element), () => 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;
+        }
+        this.badge = badge;
+        if (badge) {
+            const activity = {
+                badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
+                priority: 150
+            };
+            this.activity.value = 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 };

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

@@ -0,0 +1,45 @@
+import { promiseWithResolvers } from 'vscode/vscode/vs/base/common/async';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+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');
+            }
+            const { promise, resolve } = promiseWithResolvers();
+            this._awaitingRevival.set(viewType, { webview, resolve });
+            return promise;
+        }
+        return resolver.resolve(webview, cancellation);
+    }
+}
+
+export { WebviewViewService };

package/vscode/src/vs/workbench/services/activity/browser/activityService.js

@@ -0,0 +1,145 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { ACCOUNTS_ACTIVITY_ID, GLOBAL_ACTIVITY_ID } from 'vscode/vscode/vs/workbench/common/activity';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { isUndefined } from 'vscode/vscode/vs/base/common/types';
+
+let ViewContainerActivityByView = class ViewContainerActivityByView extends Disposable {
+    constructor(viewId, viewDescriptorService, activityService) {
+        super();
+        this.viewId = viewId;
+        this.viewDescriptorService = viewDescriptorService;
+        this.activityService = activityService;
+        this.activity = undefined;
+        this.activityDisposable = Disposable.None;
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeContainer, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeLocation, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+    }
+    setActivity(activity) {
+        this.activity = activity;
+        this.update();
+    }
+    clearActivity() {
+        this.activity = undefined;
+        this.update();
+    }
+    update() {
+        this.activityDisposable.dispose();
+        const container = this.viewDescriptorService.getViewContainerByViewId(this.viewId);
+        if (container && this.activity) {
+            this.activityDisposable = this.activityService.showViewContainerActivity(container.id, this.activity);
+        }
+    }
+    dispose() {
+        this.activityDisposable.dispose();
+        super.dispose();
+    }
+};
+ViewContainerActivityByView = ( __decorate([
+    ( __param(1, IViewDescriptorService)),
+    ( __param(2, IActivityService))
+], ViewContainerActivityByView));
+let ActivityService = class ActivityService extends Disposable {
+    constructor(viewDescriptorService, instantiationService) {
+        super();
+        this.viewDescriptorService = viewDescriptorService;
+        this.instantiationService = instantiationService;
+        this.viewActivities = ( new Map());
+        this._onDidChangeActivity = this._register(( new Emitter()));
+        this.onDidChangeActivity = this._onDidChangeActivity.event;
+        this.viewContainerActivities = ( new Map());
+        this.globalActivities = ( new Map());
+    }
+    showViewContainerActivity(viewContainerId, activity) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        if (viewContainer) {
+            let activities = this.viewContainerActivities.get(viewContainerId);
+            if (!activities) {
+                activities = [];
+                this.viewContainerActivities.set(viewContainerId, activities);
+            }
+            for (let i = 0; i <= activities.length; i++) {
+                if (i === activities.length || isUndefined(activity.priority)) {
+                    activities.push(activity);
+                    break;
+                }
+                else if (isUndefined(activities[i].priority) || activities[i].priority <= activity.priority) {
+                    activities.splice(i, 0, activity);
+                    break;
+                }
+            }
+            this._onDidChangeActivity.fire(viewContainer);
+            return toDisposable(() => {
+                activities.splice(activities.indexOf(activity), 1);
+                if (activities.length === 0) {
+                    this.viewContainerActivities.delete(viewContainerId);
+                }
+                this._onDidChangeActivity.fire(viewContainer);
+            });
+        }
+        return Disposable.None;
+    }
+    getViewContainerActivities(viewContainerId) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        if (viewContainer) {
+            return this.viewContainerActivities.get(viewContainerId) ?? [];
+        }
+        return [];
+    }
+    showViewActivity(viewId, activity) {
+        let maybeItem = this.viewActivities.get(viewId);
+        if (maybeItem) {
+            maybeItem.id++;
+        }
+        else {
+            maybeItem = {
+                id: 1,
+                activity: this.instantiationService.createInstance(ViewContainerActivityByView, viewId)
+            };
+            this.viewActivities.set(viewId, maybeItem);
+        }
+        const id = maybeItem.id;
+        maybeItem.activity.setActivity(activity);
+        const item = maybeItem;
+        return toDisposable(() => {
+            if (item.id === id) {
+                item.activity.dispose();
+                this.viewActivities.delete(viewId);
+            }
+        });
+    }
+    showAccountsActivity(activity) {
+        return this.showActivity(ACCOUNTS_ACTIVITY_ID, activity);
+    }
+    showGlobalActivity(activity) {
+        return this.showActivity(GLOBAL_ACTIVITY_ID, activity);
+    }
+    getActivity(id) {
+        return this.globalActivities.get(id) ?? [];
+    }
+    showActivity(id, activity) {
+        let activities = this.globalActivities.get(id);
+        if (!activities) {
+            activities = [];
+            this.globalActivities.set(id, activities);
+        }
+        activities.push(activity);
+        this._onDidChangeActivity.fire(id);
+        return toDisposable(() => {
+            activities.splice(activities.indexOf(activity), 1);
+            if (activities.length === 0) {
+                this.globalActivities.delete(id);
+            }
+            this._onDidChangeActivity.fire(id);
+        });
+    }
+};
+ActivityService = ( __decorate([
+    ( __param(0, IViewDescriptorService)),
+    ( __param(1, IInstantiationService))
+], ActivityService));
+
+export { ActivityService };