@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.0

package/vscode/src/vs/workbench/browser/parts/views/viewsService.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IViewDescriptorService, IViewsService } from '../../../common/views.js';
-import { FocusedViewContext, getEnabledViewContainerContextKey, getVisbileViewContextKey } from '../../../common/contextkeys.js';
+import { FocusedViewContext, getVisbileViewContextKey } from '../../../common/contextkeys.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
@@ -22,13 +22,15 @@ import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCo
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { FilterViewPaneContainer } from './viewsViewlet.js';
 import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 let ViewsService = class ViewsService extends Disposable {
-    constructor(viewDescriptorService, paneCompositeService, contextKeyService, layoutService) {
+    constructor(viewDescriptorService, paneCompositeService, contextKeyService, layoutService, editorService) {
         super();
         this.viewDescriptorService = viewDescriptorService;
         this.paneCompositeService = paneCompositeService;
         this.contextKeyService = contextKeyService;
         this.layoutService = layoutService;
+        this.editorService = editorService;
         this._onDidChangeViewVisibility = this._register(( new Emitter()));
         this.onDidChangeViewVisibility = this._onDidChangeViewVisibility.event;
         this._onDidChangeViewContainerVisibility = this._register(( new Emitter()));
@@ -36,6 +38,7 @@ let ViewsService = class ViewsService extends Disposable {
         this._onDidChangeFocusedView = this._register(( new Emitter()));
         this.onDidChangeFocusedView = this._onDidChangeFocusedView.event;
         this.viewDisposable = ( new Map());
+        this.enabledViewContainersContextKeys = ( new Map());
         this.visibleViewContextKeys = ( new Map());
         this.viewPaneContainers = ( new Map());
         this._register(toDisposable(() => {
@@ -88,6 +91,8 @@ let ViewsService = class ViewsService extends Disposable {
             this.onViewDescriptorsAdded(added, viewContainer);
             this.onViewDescriptorsRemoved(removed);
         }));
+        this.updateViewContainerEnablementContextKey(viewContainer);
+        this._register(viewContainerModel.onDidChangeActiveViewDescriptors(() => this.updateViewContainerEnablementContextKey(viewContainer)));
         this._register(this.registerOpenViewContainerAction(viewContainer));
     }
     onDidChangeContainerLocation(viewContainer, from, to) {
@@ -99,11 +104,10 @@ let ViewsService = class ViewsService extends Disposable {
         if (location === null) {
             return;
         }
-        const composite = this.getComposite(container.id, location);
         for (const viewDescriptor of views) {
             const disposables = ( new DisposableStore());
             disposables.add(this.registerOpenViewAction(viewDescriptor));
-            disposables.add(this.registerFocusViewAction(viewDescriptor, composite?.name && composite.name !== composite.id ? composite.name : Categories.View));
+            disposables.add(this.registerFocusViewAction(viewDescriptor, container.title));
             disposables.add(this.registerResetViewLocationAction(viewDescriptor));
             this.viewDisposable.set(viewDescriptor, disposables);
         }
@@ -117,6 +121,14 @@ let ViewsService = class ViewsService extends Disposable {
             }
         }
     }
+    updateViewContainerEnablementContextKey(viewContainer) {
+        let contextKey = this.enabledViewContainersContextKeys.get(viewContainer.id);
+        if (!contextKey) {
+            contextKey = this.contextKeyService.createKey(getEnabledViewContainerContextKey(viewContainer.id), false);
+            this.enabledViewContainersContextKeys.set(viewContainer.id, contextKey);
+        }
+        contextKey.set(!(viewContainer.hideIfEmpty && this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length === 0));
+    }
     async openComposite(compositeId, location, focus) {
         return this.paneCompositeService.openPaneComposite(compositeId, location, focus);
     }
@@ -188,7 +200,8 @@ let ViewsService = class ViewsService extends Disposable {
     }
     getFocusedViewName() {
         const viewId = this.contextKeyService.getContextKeyValue(FocusedViewContext.key) ?? '';
-        return this.viewDescriptorService.getViewDescriptorById(( viewId.toString()))?.name ?? '';
+        const textEditorFocused = this.editorService.activeTextEditorControl?.hasTextFocus() ? ( localizeWithPath('vs/workbench/browser/parts/views/viewsService', 'editor', "Text Editor")) : undefined;
+        return this.viewDescriptorService.getViewDescriptorById(( viewId.toString()))?.name?.value ?? textEditorFocused ?? '';
     }
     async openView(id, focus) {
         const viewContainer = this.viewDescriptorService.getViewContainerByViewId(id);
@@ -437,11 +450,11 @@ let ViewsService = class ViewsService extends Disposable {
                     'vs/workbench/browser/parts/views/viewsService',
                     { key: 'focus view', comment: ['{0} indicates the name of the view to be focused.'] },
                     "Focus on {0} View",
-                    viewDescriptor.name
+                    viewDescriptor.name.value
                 ));
                 super({
                     id: viewDescriptor.focusCommand ? viewDescriptor.focusCommand.id : `${viewDescriptor.id}.focus`,
-                    title: { original: `Focus on ${viewDescriptor.name} View`, value: title },
+                    title: { original: `Focus on ${viewDescriptor.name.original} View`, value: title },
                     category,
                     menu: [{
                             id: MenuId.CommandPalette,
@@ -456,7 +469,7 @@ let ViewsService = class ViewsService extends Disposable {
                         mac: viewDescriptor.focusCommand?.keybindings?.mac,
                         win: viewDescriptor.focusCommand?.keybindings?.win
                     },
-                    description: {
+                    metadata: {
                         description: title,
                         args: [
                             {
@@ -508,9 +521,9 @@ let ViewsService = class ViewsService extends Disposable {
                 const containerModel = viewDescriptorService.getViewContainerModel(defaultContainer);
                 if (defaultContainer.hideIfEmpty && containerModel.visibleViewDescriptors.length === 0) {
                     const defaultLocation = viewDescriptorService.getDefaultViewContainerLocation(defaultContainer);
-                    viewDescriptorService.moveViewContainerToLocation(defaultContainer, defaultLocation);
+                    viewDescriptorService.moveViewContainerToLocation(defaultContainer, defaultLocation, undefined, this.desc.id);
                 }
-                viewDescriptorService.moveViewsToContainer([viewDescriptor], viewDescriptorService.getDefaultContainerById(viewDescriptor.id));
+                viewDescriptorService.moveViewsToContainer([viewDescriptor], viewDescriptorService.getDefaultContainerById(viewDescriptor.id), undefined, this.desc.id);
                 accessor.get(IViewsService).openView(viewDescriptor.id, true);
             }
         });
@@ -572,8 +585,10 @@ ViewsService = ( __decorate([
     ( __param(0, IViewDescriptorService)),
     ( __param(1, IPaneCompositePartService)),
     ( __param(2, IContextKeyService)),
-    ( __param(3, IWorkbenchLayoutService))
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IEditorService))
 ], ViewsService));
+function getEnabledViewContainerContextKey(viewContainerId) { return `viewContainer.${viewContainerId}.enabled`; }
 function getPaneCompositeExtension(viewContainerLocation) {
     switch (viewContainerLocation) {
         case 2 :

package/vscode/src/vs/workbench/browser/parts/views/viewsViewlet.js

@@ -19,12 +19,6 @@ let FilterViewPaneContainer = class FilterViewPaneContainer extends ViewPaneCont
             this.filterValue = newFilterValue;
             this.onFilterChanged(newFilterValue);
         }));
-        this._register(this.onDidChangeViewVisibility(view => {
-            const descriptorMap = Array.from(this.allViews.entries()).find(entry => ( entry[1].has(view.id)));
-            if (descriptorMap && !this.filterValue?.includes(descriptorMap[0])) {
-                this.setFilter(descriptorMap[1].get(view.id));
-            }
-        }));
         this._register(this.viewContainerModel.onDidChangeActiveViewDescriptors(() => {
             this.updateAllViews(this.viewContainerModel.activeViewDescriptors);
         }));
@@ -93,6 +87,16 @@ let FilterViewPaneContainer = class FilterViewPaneContainer extends ViewPaneCont
         }
         return panes;
     }
+    openView(id, focus) {
+        const result = super.openView(id, focus);
+        if (result) {
+            const descriptorMap = Array.from(this.allViews.entries()).find(entry => ( entry[1].has(id)));
+            if (descriptorMap && !this.filterValue?.includes(descriptorMap[0])) {
+                this.setFilter(descriptorMap[1].get(id));
+            }
+        }
+        return result;
+    }
 };
 FilterViewPaneContainer = ( __decorate([
     ( __param(2, IConfigurationService)),

package/vscode/src/vs/workbench/browser/style.js

@@ -4,6 +4,7 @@ import { isWeb, isIOS, isWindows, isMacintosh } from 'monaco-editor/esm/vs/base/
 import { createMetaElement } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { isSafari, isStandalone } from 'monaco-editor/esm/vs/base/browser/browser.js';
 import { selectionBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
 registerThemingParticipant((theme, collector) => {
     const workbenchBackground = WORKBENCH_BACKGROUND(theme);
     collector.addRule(`.monaco-workbench { background-color: ${workbenchBackground}; }`);
@@ -15,7 +16,7 @@ registerThemingParticipant((theme, collector) => {
         const titleBackground = theme.getColor(TITLE_BAR_ACTIVE_BACKGROUND);
         if (titleBackground) {
             const metaElementId = 'monaco-workbench-meta-theme-color';
-            let metaElement = document.getElementById(metaElementId);
+            let metaElement = mainWindow.document.getElementById(metaElementId);
             if (!metaElement) {
                 metaElement = createMetaElement();
                 metaElement.name = 'theme-color';

package/vscode/src/vs/workbench/browser/web.api.d.ts

@@ -4,11 +4,11 @@ import { IURLCallbackProvider } from '../services/url/browser/urlService.js';
 import { LogLevel } from '../../platform/log/common/log.js';
 import { IUpdateProvider } from '../services/update/browser/updateService.js';
 import { Event } from '../../base/common/event.js';
-import { IWorkspaceProvider } from '../services/host/browser/browserHostService.js';
 import { IProductConfiguration } from '../../base/common/product.js';
 import { ISecretStorageProvider } from '../../platform/secrets/common/secrets.js';
 import { TunnelProviderFeatures } from '../../platform/tunnel/common/tunnel.js';
 import { ITextEditorOptions } from '../../platform/editor/common/editor.js';
+import { IWorkspaceToOpen, IFolderToOpen } from '../../platform/window/common/window.js';
 import { EditorGroupLayout } from '../services/editor/common/editorGroupsService.js';
 
 interface IWorkbenchConstructionOptions {
@@ -178,6 +178,43 @@ interface IWorkbenchConstructionOptions {
     readonly messagePorts?: ReadonlyMap<ExtensionId, MessagePort>;
     readonly developmentOptions?: IDevelopmentOptions;
 }
+/**
+ * A workspace to open in the workbench can either be:
+ * - a workspace file with 0-N folders (via `workspaceUri`)
+ * - a single folder (via `folderUri`)
+ * - empty (via `undefined`)
+ */
+type IWorkspace = IWorkspaceToOpen | IFolderToOpen | undefined;
+interface IWorkspaceProvider {
+    /**
+     * The initial workspace to open.
+     */
+    readonly workspace: IWorkspace;
+    /**
+     * Arbitrary payload from the `IWorkspaceProvider.open` call.
+     */
+    readonly payload?: object;
+    /**
+     * Return `true` if the provided [workspace](#IWorkspaceProvider.workspace) is trusted, `false` if not trusted, `undefined` if unknown.
+     */
+    readonly trusted: boolean | undefined;
+    /**
+     * Asks to open a workspace in the current or a new window.
+     *
+     * @param workspace the workspace to open.
+     * @param options optional options for the workspace to open.
+     * - `reuse`: whether to open inside the current window or a new window
+     * - `payload`: arbitrary payload that should be made available
+     * to the opening window via the `IWorkspaceProvider.payload` property.
+     * @param payload optional payload to send to the workspace to open.
+     *
+     * @returns true if successfully opened, false otherwise.
+     */
+    open(workspace: IWorkspace, options?: {
+        reuse?: boolean;
+        payload?: object;
+    }): Promise<boolean>;
+}
 interface IResourceUriProvider {
     (uri: URI): URI;
 }
@@ -552,4 +589,4 @@ interface IRemoteResourceRequest {
     respondWith(statusCode: number, body: Uint8Array, headers: Record<string, string>): void;
 }
 
-export { ColorScheme, type ExtensionId, type ICommand, type ICommonTelemetryPropertiesResolver, type IDefaultEditor, type IDefaultLayout, type IDefaultView, type IDevelopmentOptions, type IExternalUriResolver, type IHomeIndicator, type IInitialColorTheme, type IProductQualityChangeHandler, type IRemoteResourceProvider, type IRemoteResourceRequest, type IResourceUriProvider, type ISettingsSyncOptions, type IShowPortCandidate, type ITunnel, type ITunnelFactory, type ITunnelOptions, type ITunnelProvider, type IWelcomeBanner, type IWelcomeDialog, type IWelcomeLinkAction, type IWindowIndicator, type IWorkbenchConstructionOptions, type MarketplaceExtension, Menu, type TunnelCreationOptions };
+export { ColorScheme, type ExtensionId, type ICommand, type ICommonTelemetryPropertiesResolver, type IDefaultEditor, type IDefaultLayout, type IDefaultView, type IDevelopmentOptions, type IExternalUriResolver, type IHomeIndicator, type IInitialColorTheme, type IProductQualityChangeHandler, type IRemoteResourceProvider, type IRemoteResourceRequest, type IResourceUriProvider, type ISettingsSyncOptions, type IShowPortCandidate, type ITunnel, type ITunnelFactory, type ITunnelOptions, type ITunnelProvider, type IWelcomeBanner, type IWelcomeDialog, type IWelcomeLinkAction, type IWindowIndicator, type IWorkbenchConstructionOptions, type IWorkspace, type IWorkspaceProvider, type MarketplaceExtension, Menu, type TunnelCreationOptions };

package/vscode/src/vs/workbench/browser/window.js

@@ -0,0 +1,55 @@
+import { getWindowsCount, getWindows } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import '../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { isAuxiliaryWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
+class BaseWindow extends Disposable {
+    static { this.TIMEOUT_HANDLES = Number.MIN_SAFE_INTEGER; }
+    static { this.TIMEOUT_DISPOSABLES = ( new Map()); }
+    constructor(targetWindow, dom = { getWindowsCount, getWindows } ) {
+        super();
+        this.enableMultiWindowAwareTimeout(targetWindow, dom);
+    }
+    enableMultiWindowAwareTimeout(targetWindow, dom = { getWindowsCount, getWindows }) {
+        const originalSetTimeout = targetWindow.setTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalSetTimeout', { get: () => originalSetTimeout });
+        const originalClearTimeout = targetWindow.clearTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalClearTimeout', { get: () => originalClearTimeout });
+        targetWindow.setTimeout = function (handler, timeout = 0, ...args) {
+            if (dom.getWindowsCount() === 1 || typeof handler === 'string' || timeout === 0 ) {
+                return originalSetTimeout.apply(this, [handler, timeout, ...args]);
+            }
+            const timeoutDisposables = ( new Set());
+            const timeoutHandle = BaseWindow.TIMEOUT_HANDLES++;
+            BaseWindow.TIMEOUT_DISPOSABLES.set(timeoutHandle, timeoutDisposables);
+            const handlerFn = createSingleCallFunction(handler, () => {
+                dispose(timeoutDisposables);
+                BaseWindow.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            });
+            for (const { window, disposables } of dom.getWindows()) {
+                if (isAuxiliaryWindow(window) && window.document.visibilityState === 'hidden') {
+                    continue;
+                }
+                const handle = window.vscodeOriginalSetTimeout.apply(this, [handlerFn, timeout, ...args]);
+                const timeoutDisposable = toDisposable(() => {
+                    window.vscodeOriginalClearTimeout(handle);
+                    timeoutDisposables.delete(timeoutDisposable);
+                });
+                disposables.add(timeoutDisposable);
+                timeoutDisposables.add(timeoutDisposable);
+            }
+            return timeoutHandle;
+        };
+        targetWindow.clearTimeout = function (timeoutHandle) {
+            const timeoutDisposables = typeof timeoutHandle === 'number' ? BaseWindow.TIMEOUT_DISPOSABLES.get(timeoutHandle) : undefined;
+            if (timeoutDisposables) {
+                dispose(timeoutDisposables);
+                BaseWindow.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            }
+            else {
+                originalClearTimeout.apply(this, [timeoutHandle]);
+            }
+        };
+    }
+}
+export { BaseWindow };