@codingame/monaco-vscode-views-service-override 2.1.4 → 2.2.0-next.2

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

@@ -1,235 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Dimension, 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';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-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';
-import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
-import { ExtensionKeyedWebviewOriginStore, IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
-import { WebviewWindowDragMonitor } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor';
-import { IWebviewViewService } from 'vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService';
-import { NumberBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-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 };

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

@@ -1,145 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
-import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { ACCOUNTS_ACTIVITY_ID, GLOBAL_ACTIVITY_ID } from 'vscode/vscode/vs/workbench/common/activity';
-import { Emitter, Event } 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 };