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

package/vscode/src/vs/workbench/services/hover/browser/hover.d.ts

@@ -23,7 +23,7 @@ interface IHoverService {
      * });
      * ```
      */
-    showHover(options: Readonly<IHoverOptions>, focus?: boolean): IHoverWidget | undefined;
+    showHover(options: IHoverOptions, focus?: boolean): IHoverWidget | undefined;
     /**
      * Hides the hover if it was visible. This call will be ignored if the the hover is currently
      * "locked" via the alt/option key.
@@ -51,6 +51,7 @@ interface IHoverOptions {
      * dispose method is required.
      */
     target: IHoverTarget | HTMLElement;
+    container?: HTMLElement;
     /**
      * An ID to associate with the hover to be used as an equality check. Normally when calling
      * {@link IHoverService.showHover} the options object itself is used to determine if the hover
@@ -71,27 +72,26 @@ interface IHoverOptions {
      */
     linkHandler?(url: string): void;
     /**
-     * Whether to hide the hover when the mouse leaves the `target` and enters the actual hover.
-     * This is false by default when text is an `IMarkdownString` and true when `text` is a
-     * `string`. Note that this will be ignored if any `actions` are provided as hovering is
-     * required to make them accessible.
-     *
-     * In general hiding on hover is desired for:
-     * - Regular text where selection is not important
-     * - Markdown that contains no links where selection is not important
+     * Whether to trap focus in the following ways:
+     * - When the hover closes, focus goes to the element that had focus before the hover opened
+     * - If there are elements in the hover to focus, focus stays inside of the hover when tabbing
+     * Note that this is overridden to true when in screen reader optimized mode.
      */
-    hideOnHover?: boolean;
+    trapFocus?: boolean;
     /**
-     * When {@link hideOnHover} is explicitly true or undefined and its auto value is detected to
-     * hide, show a hint at the bottom of the hover explaining how to mouse over the widget. This
-     * should be used in the cases where despite the hover having no interactive content, it's
-     * likely the user may want to interact with it somehow.
+     * Options that defines where the hover is positioned.
      */
-    showHoverHint?: boolean;
+    position?: IHoverPositionOptions;
     /**
-     * Whether to hide the hover when a key is pressed.
+     * Options that defines how long the hover is shown and when it hides.
      */
-    hideOnKeyDown?: boolean;
+    persistence?: IHoverPersistenceOptions;
+    /**
+     * Options that define how the hover looks.
+     */
+    appearance?: IHoverAppearanceOptions;
+}
+interface IHoverPositionOptions {
     /**
      * Position of the hover. The default is to show above the target. This option will be ignored
      * if there is not enough room to layout the hover in the specified position, unless the
@@ -103,27 +103,50 @@ interface IHoverOptions {
      * position.
      */
     forcePosition?: boolean;
+}
+interface IHoverPersistenceOptions {
     /**
-     * Whether to show the hover pointer
+     * Whether to hide the hover when the mouse leaves the `target` and enters the actual hover.
+     * This is false by default when text is an `IMarkdownString` and true when `text` is a
+     * `string`. Note that this will be ignored if any `actions` are provided as hovering is
+     * required to make them accessible.
+     *
+     * In general hiding on hover is desired for:
+     * - Regular text where selection is not important
+     * - Markdown that contains no links where selection is not important
+     */
+    hideOnHover?: boolean;
+    /**
+     * Whether to hide the hover when a key is pressed.
+     */
+    hideOnKeyDown?: boolean;
+    /**
+     * Whether to make the hover sticky, this means it will not be hidden when the mouse leaves the
+     * hover.
+     */
+    sticky?: boolean;
+}
+interface IHoverAppearanceOptions {
+    /**
+     * Whether to show the hover pointer, a little arrow that connects the target and the hover.
      */
     showPointer?: boolean;
     /**
-     * Whether to show a compact hover
+     * Whether to show a compact hover, reducing the font size and padding of the hover.
      */
     compact?: boolean;
+    /**
+     * When {@link hideOnHover} is explicitly true or undefined and its auto value is detected to
+     * hide, show a hint at the bottom of the hover explaining how to mouse over the widget. This
+     * should be used in the cases where despite the hover having no interactive content, it's
+     * likely the user may want to interact with it somehow.
+     */
+    showHoverHint?: boolean;
     /**
      * Whether to skip the fade in animation, this should be used when hovering from one hover to
      * another in the same group so it looks like the hover is moving from one element to the other.
      */
     skipFadeInAnimation?: boolean;
-    /**
-     * Whether to trap focus in the following ways:
-     * - When the hover closes, focus goes to the element that had focus before the hover opened
-     * - If there are elements in the hover to focus, focus stays inside of the hover when tabbing
-     * Note that this is overridden to true when in screen reader optimized mode.
-     */
-    trapFocus?: boolean;
-    container?: HTMLElement;
 }
 interface IHoverAction {
     /**
@@ -167,4 +190,4 @@ interface IHoverTarget extends IDisposable {
     y?: number;
 }
 
-export { type IHoverAction, type IHoverOptions, IHoverService, type IHoverTarget, type IHoverWidget };
+export { type IHoverAction, type IHoverAppearanceOptions, type IHoverOptions, type IHoverPersistenceOptions, type IHoverPositionOptions, IHoverService, type IHoverTarget, type IHoverWidget };

package/vscode/src/vs/workbench/services/hover/browser/hoverService.d.ts

@@ -3,20 +3,23 @@ import { IContextViewService, IContextMenuService } from '../../../../platform/c
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
 
 declare class HoverService implements IHoverService {
     private readonly _instantiationService;
     private readonly _contextViewService;
     private readonly _keybindingService;
+    private readonly _layoutService;
     private readonly _accessibilityService;
     readonly _serviceBrand: undefined;
     private _currentHoverOptions;
     private _currentHover;
     private _lastHoverOptions;
     private _lastFocusedElementBeforeOpen;
-    constructor(_instantiationService: IInstantiationService, _contextViewService: IContextViewService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService);
-    showHover(options: Readonly<IHoverOptions>, focus?: boolean, skipLastFocusedUpdate?: boolean): IHoverWidget | undefined;
+    constructor(_instantiationService: IInstantiationService, _contextViewService: IContextViewService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _accessibilityService: IAccessibilityService);
+    showHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean): IHoverWidget | undefined;
     hideHover(): void;
+    private doHideHover;
     private _intersectionChange;
     showAndFocusLastHover(): void;
     private _keyDown;

package/vscode/src/vs/workbench/services/keybinding/browser/unboundCommands.js

@@ -18,8 +18,8 @@ function getAllUnboundCommands(boundCommands) {
         }
         if (!includeCommandWithArgs) {
             const command = CommandsRegistry.getCommand(id);
-            if (command && typeof command.description === 'object'
-                && isNonEmptyArray(command.description.args)) {
+            if (command && typeof command.metadata === 'object'
+                && isNonEmptyArray(command.metadata.args)) {
                 return;
             }
         }

package/vscode/src/vs/workbench/services/languageStatus/common/languageStatusService.d.ts

@@ -12,7 +12,10 @@ interface ILanguageStatus {
     readonly name: string;
     readonly selector: LanguageSelector;
     readonly severity: Severity;
-    readonly label: string;
+    readonly label: string | {
+        value: string;
+        shortValue: string;
+    };
     readonly detail: string;
     readonly busy: boolean;
     readonly source: string;

package/vscode/src/vs/workbench/services/layout/browser/layoutService.d.ts

@@ -2,7 +2,7 @@ import { ServiceIdentifier } from '../../../../platform/instantiation/common/ins
 import { Event } from '../../../../base/common/event.js';
 import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
 import { Part } from '../../../browser/part.js';
-import { Dimension } from '../../../../base/browser/dom.js';
+import { IDimension } from '../../../../base/browser/dom.js';
 import { Direction } from '../../../../base/browser/ui/grid/grid.js';
 
 declare const enum Parts {
@@ -21,6 +21,8 @@ declare const enum Position {
     BOTTOM = 2
 }
 type PanelAlignment = 'left' | 'center' | 'right' | 'justify';
+type MULTI_WINDOW_PARTS = Parts.EDITOR_PART | Parts.STATUSBAR_PART | Parts.TITLEBAR_PART;
+type SINGLE_WINDOW_PARTS = Exclude<Parts, MULTI_WINDOW_PARTS>;
 
 declare const IWorkbenchLayoutService: ServiceIdentifier<IWorkbenchLayoutService>;
 interface IWorkbenchLayoutService extends ILayoutService {
@@ -34,9 +36,12 @@ interface IWorkbenchLayoutService extends ILayoutService {
      */
     readonly onDidChangeFullscreen: Event<boolean>;
     /**
-     * Emits when the window is maximized or unmaximized.
+     * Emits when the target window is maximized or unmaximized.
      */
-    readonly onDidChangeWindowMaximized: Event<boolean>;
+    readonly onDidChangeWindowMaximized: Event<{
+        readonly windowId: number;
+        readonly maximized: boolean;
+    }>;
     /**
      * Emits when centered layout is enabled or disabled.
      */
@@ -76,42 +81,41 @@ interface IWorkbenchLayoutService extends ILayoutService {
      */
     hasFocus(part: Parts): boolean;
     /**
-     * Focuses the part. If the part is not visible this is a noop.
+     * Focuses the part in the target window. If the part is not visible this is a noop.
      */
-    focusPart(part: Parts): void;
+    focusPart(part: SINGLE_WINDOW_PARTS): void;
+    focusPart(part: MULTI_WINDOW_PARTS, targetWindow: Window): void;
+    focusPart(part: Parts, targetWindow: Window): void;
     /**
-     * Returns the parts HTML element, if there is one.
+     * Returns the target window container or parts HTML element within, if there is one.
      */
-    getContainer(part: Parts): HTMLElement | undefined;
+    getContainer(targetWindow: Window): HTMLElement;
+    getContainer(targetWindow: Window, part: Parts): HTMLElement | undefined;
     /**
-     * Returns if the part is visible.
+     * Returns if the part is visible in the target window.
      */
-    isVisible(part: Parts): boolean;
+    isVisible(part: SINGLE_WINDOW_PARTS): boolean;
+    isVisible(part: MULTI_WINDOW_PARTS, targetWindow: Window): boolean;
+    isVisible(part: Parts, targetWindow: Window): boolean;
     /**
-     * Returns if the part is visible.
+     * Set part hidden or not in the target window.
      */
-    getDimension(part: Parts): Dimension | undefined;
-    /**
-     * Set part hidden or not
-     */
-    setPartHidden(hidden: boolean, part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>): void;
+    setPartHidden(hidden: boolean, part: Exclude<SINGLE_WINDOW_PARTS, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>): void;
+    setPartHidden(hidden: boolean, part: Exclude<MULTI_WINDOW_PARTS, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>, targetWindow: Window): void;
+    setPartHidden(hidden: boolean, part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>, targetWindow: Window): void;
     /**
      * Maximizes the panel height if the panel is not already maximized.
      * Shrinks the panel to the default starting size if the panel is maximized.
      */
     toggleMaximizedPanel(): void;
     /**
-     * Returns true if the window has a border.
-     */
-    hasWindowBorder(): boolean;
-    /**
-     * Returns the window border width.
+     * Returns true if the main window has a border.
      */
-    getWindowBorderWidth(): number;
+    hasMainWindowBorder(): boolean;
     /**
-     * Returns the window border radius if any.
+     * Returns the main window border radius if any.
      */
-    getWindowBorderRadius(): string | undefined;
+    getMainWindowBorderRadius(): string | undefined;
     /**
      * Returns true if the panel is maximized.
      */
@@ -138,23 +142,23 @@ interface IWorkbenchLayoutService extends ILayoutService {
      */
     setPanelAlignment(alignment: PanelAlignment): void;
     /**
-     * Gets the maximum possible size for editor.
+     * Gets the maximum possible size for editor in the given container.
      */
-    getMaximumEditorDimensions(): Dimension;
+    getMaximumEditorDimensions(container: HTMLElement): IDimension;
     /**
      * Toggles the workbench in and out of zen mode - parts get hidden and window goes fullscreen.
      */
     toggleZenMode(): void;
     /**
-     * Returns whether the centered editor layout is active.
+     * Returns whether the centered editor layout is active on the main editor part.
      */
-    isEditorLayoutCentered(): boolean;
+    isMainEditorLayoutCentered(): boolean;
     /**
-     * Sets the workbench in and out of centered editor layout.
+     * Sets the main editor part in and out of centered layout.
      */
-    centerEditorLayout(active: boolean): void;
+    centerMainEditorLayout(active: boolean): void;
     /**
-     * Resizes currently focused part on main access
+     * Resize the provided part in the main window.
      */
     resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void;
     /**
@@ -162,17 +166,17 @@ interface IWorkbenchLayoutService extends ILayoutService {
      */
     registerPart(part: Part): void;
     /**
-     * Returns whether the window is maximized.
+     * Returns whether the target window is maximized.
      */
-    isWindowMaximized(): boolean;
+    isWindowMaximized(targetWindow: Window): boolean;
     /**
-     * Updates the maximized state of the window.
+     * Updates the maximized state of the target window.
      */
-    updateWindowMaximizedState(maximized: boolean): void;
+    updateWindowMaximizedState(targetWindow: Window, maximized: boolean): void;
     /**
-     * Returns the next visible view part in a given direction
+     * Returns the next visible view part in a given direction in the main window.
      */
     getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
 }
 
-export { IWorkbenchLayoutService, type PanelAlignment, Parts, Position };
+export { IWorkbenchLayoutService, type MULTI_WINDOW_PARTS, type PanelAlignment, Parts, Position, type SINGLE_WINDOW_PARTS };

package/vscode/src/vs/workbench/services/panecomposite/browser/panecomposite.d.ts

@@ -4,8 +4,6 @@ import { PaneCompositeDescriptor } from '../../../browser/panecomposite.js';
 import { IProgressIndicator } from '../../../../platform/progress/common/progress.js';
 import { IPaneComposite } from '../../../common/panecomposite.js';
 import { ViewContainerLocation } from '../../../common/views.js';
-import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { IBadge } from '../../activity/common/activity.js';
 
 declare const IPaneCompositePartService: ServiceIdentifier<IPaneCompositePartService>;
 interface IPaneCompositePartService {
@@ -54,10 +52,6 @@ interface IPaneCompositePartService {
      * Return the last active viewlet id.
      */
     getLastActivePaneCompositeId(viewContainerLocation: ViewContainerLocation): string;
-    /**
-     * Show an activity in a viewlet.
-     */
-    showActivity(id: string, viewContainerLocation: ViewContainerLocation, badge: IBadge, clazz?: string, priority?: number): IDisposable;
 }
 
 export { IPaneCompositePartService };

package/vscode/src/vs/workbench/services/preferences/common/preferences.d.ts

@@ -150,6 +150,9 @@ interface ISettingsEditorOptions extends IEditorOptions {
     target?: ConfigurationTarget;
     folderUri?: URI;
     query?: string;
+    /**
+     * Only works when opening the json settings file. Use `query` for settings editor.
+     */
     revealSetting?: {
         key: string;
         edit?: boolean;

package/vscode/src/vs/workbench/services/progress/browser/progressIndicator.js

@@ -10,8 +10,8 @@ class EditorProgressIndicator extends Disposable {
     }
     registerListeners() {
         this._register(this.group.onDidModelChange(e => {
-            if (e.kind === 6  ||
-                (e.kind === 4  && this.group.isEmpty)) {
+            if (e.kind === 7  ||
+                (e.kind === 5  && this.group.isEmpty)) {
                 this.progressBar.stop().hide();
             }
         }));

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.d.ts

@@ -6,6 +6,8 @@ import { IEditableData } from '../../../common/views.js';
 import { TunnelInformation, TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
 import { URI } from '../../../../base/common/uri.js';
 import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort, TunnelSource } from './tunnelModel.js';
+import { IExtensionPointUser } from '../../extensions/common/extensionsRegistry.js';
+import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
 
 declare enum TunnelType {
     Candidate = "Candidate",
@@ -37,12 +39,25 @@ declare enum TunnelEditId {
     Label = 2,
     LocalPort = 3
 }
+interface HelpInformation {
+    extensionDescription: IExtensionDescription;
+    getStarted?: string | {
+        id: string;
+    };
+    documentation?: string;
+    issues?: string;
+    reportIssue?: string;
+    remoteName?: string[] | string;
+    virtualWorkspace?: string;
+}
 
 declare const IRemoteExplorerService: ServiceIdentifier<IRemoteExplorerService>;
 interface IRemoteExplorerService {
     readonly _serviceBrand: undefined;
     onDidChangeTargetType: Event<string[]>;
     targetType: string[];
+    onDidChangeHelpInformation: Event<readonly IExtensionPointUser<HelpInformation>[]>;
+    helpInformation: IExtensionPointUser<HelpInformation>[];
     readonly tunnelModel: TunnelModel;
     onDidChangeEditable: Event<{
         tunnel: ITunnelItem;
@@ -65,4 +80,4 @@ interface IRemoteExplorerService {
     readonly namedProcesses: Map<number, string>;
 }
 
-export { IRemoteExplorerService, type ITunnelItem, TunnelEditId, TunnelType };
+export { type HelpInformation, IRemoteExplorerService, type ITunnelItem, TunnelEditId, TunnelType };

package/vscode/src/vs/workbench/services/request/browser/requestService.js

@@ -0,0 +1,48 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { RequestChannelClient } from '../../../../platform/request/common/requestIpc.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { RequestService } from '../../../../platform/request/browser/requestService.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+let BrowserRequestService = class BrowserRequestService extends RequestService {
+    constructor(remoteAgentService, configurationService, loggerService) {
+        super(configurationService, loggerService);
+        this.remoteAgentService = remoteAgentService;
+    }
+    async request(options, token) {
+        try {
+            const context = await super.request(options, token);
+            const connection = this.remoteAgentService.getConnection();
+            if (connection && context.res.statusCode === 405) {
+                return this._makeRemoteRequest(connection, options, token);
+            }
+            return context;
+        }
+        catch (error) {
+            const connection = this.remoteAgentService.getConnection();
+            if (connection) {
+                return this._makeRemoteRequest(connection, options, token);
+            }
+            throw error;
+        }
+    }
+    _makeRemoteRequest(connection, options, token) {
+        return connection.withChannel('request', channel => ( new RequestChannelClient(channel)).request(options, token));
+    }
+};
+BrowserRequestService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ILoggerService))
+], BrowserRequestService));
+CommandsRegistry.registerCommand('_workbench.fetchJSON', async function (accessor, url, method) {
+    const result = await fetch(url, { method, headers: { Accept: 'application/json' } });
+    if (result.ok) {
+        return result.json();
+    }
+    else {
+        throw new Error(result.statusText);
+    }
+});
+export { BrowserRequestService };

package/vscode/src/vs/workbench/services/search/common/searchHelpers.js

@@ -30,7 +30,7 @@ function editorMatchesToTextSearchResults(matches, model, previewOptions) {
         return editorMatchToTextSearchResult(sameLineMatches, model, previewOptions);
     }));
 }
-function addContextToEditorMatches(matches, model, query) {
+function getTextSearchMatchWithModelContext(matches, model, query) {
     const results = [];
     let prevLine = -1;
     for (let i = 0; i < matches.length; i++) {
@@ -40,7 +40,7 @@ function addContextToEditorMatches(matches, model, query) {
             for (let b = beforeContextStartLine; b < matchStartLine; b++) {
                 results.push({
                     text: model.getLineContent(b + 1),
-                    lineNumber: b
+                    lineNumber: b + 1
                 });
             }
         }
@@ -52,7 +52,7 @@ function addContextToEditorMatches(matches, model, query) {
             for (let a = matchEndLine + 1; a <= afterContextToLine; a++) {
                 results.push({
                     text: model.getLineContent(a + 1),
-                    lineNumber: a
+                    lineNumber: a + 1
                 });
             }
         }
@@ -69,4 +69,4 @@ function getMatchStartEnd(match) {
         end: matchEndLine
     };
 }
-export { addContextToEditorMatches, editorMatchesToTextSearchResults };
+export { editorMatchesToTextSearchResults, getTextSearchMatchWithModelContext };

package/vscode/src/vs/workbench/services/statusbar/browser/statusbar.d.ts

@@ -1,68 +1,27 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
-import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { DisposableStore, IDisposable } from '../../../../base/common/lifecycle.js';
 import { ThemeColor } from '../../../../base/common/themables.js';
-import { Event } from '../../../../base/common/event.js';
 import { Command } from '../../../../editor/common/languages.js';
 import { IMarkdownString } from '../../../../base/common/htmlContent.js';
 import { ColorIdentifier } from '../../../../platform/theme/common/colorRegistry.js';
+import { IStatusbarEntryContainer, IAuxiliaryStatusbarPart } from '../../../browser/parts/statusbar/statusbarPart.js';
 
 declare const IStatusbarService: ServiceIdentifier<IStatusbarService>;
-interface IStatusbarService {
+interface IStatusbarService extends IStatusbarEntryContainer {
     readonly _serviceBrand: undefined;
     /**
-     * An event that is triggered when an entry's visibility is changed.
+     * Get the status bar part that is rooted in the provided container.
      */
-    readonly onDidChangeEntryVisibility: Event<{
-        id: string;
-        visible: boolean;
-    }>;
+    getPart(container: HTMLElement): IStatusbarEntryContainer;
     /**
-     * Adds an entry to the statusbar with the given alignment and priority. Use the returned accessor
-     * to update or remove the statusbar entry.
-     *
-     * @param id identifier of the entry is needed to allow users to hide entries via settings
-     * @param alignment either LEFT or RIGHT side in the status bar
-     * @param priority items get arranged from highest priority to lowest priority from left to right
-     * in their respective alignment slot
-     */
-    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priority?: number | IStatusbarEntryPriority): IStatusbarEntryAccessor;
-    /**
-     * Adds an entry to the statusbar with the given alignment relative to another entry. Use the returned
-     * accessor to update or remove the statusbar entry.
-     *
-     * @param id identifier of the entry is needed to allow users to hide entries via settings
-     * @param alignment either LEFT or RIGHT side in the status bar
-     * @param location a reference to another entry to position relative to
-     */
-    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, location?: IStatusbarEntryLocation): IStatusbarEntryAccessor;
-    /**
-     * Return if an entry is visible or not.
-     */
-    isEntryVisible(id: string): boolean;
-    /**
-     * Allows to update an entry's visibility with the provided ID.
-     */
-    updateEntryVisibility(id: string, visible: boolean): void;
-    /**
-     * Focused the status bar. If one of the status bar entries was focused, focuses it directly.
-     */
-    focus(preserveEntryFocus?: boolean): void;
-    /**
-     * Focuses the next status bar entry. If none focused, focuses the first.
-     */
-    focusNextEntry(): void;
-    /**
-     * Focuses the previous status bar entry. If none focused, focuses the last.
-     */
-    focusPreviousEntry(): void;
-    /**
-     *	Returns true if a status bar entry is focused.
+     * Creates a new auxililary status bar part in the provided container.
      */
-    isEntryFocused(): boolean;
+    createAuxiliaryStatusbarPart(container: HTMLElement): IAuxiliaryStatusbarPart;
     /**
-     * Temporarily override statusbar style.
+     * Create a scoped status bar service that only operates on the provided
+     * status entry container.
      */
-    overrideStyle(style: IStatusbarStyleOverride): IDisposable;
+    createScoped(statusbarEntryContainer: IStatusbarEntryContainer, disposables: DisposableStore): IStatusbarService;
 }
 declare const enum StatusbarAlignment {
     LEFT = 0,

package/vscode/src/vs/workbench/services/suggest/browser/simpleSuggestWidget.js

@@ -166,7 +166,7 @@ let SimpleSuggestWidget = class SimpleSuggestWidget {
         }
         finally {
         }
-        this._pendingLayout.value = dom.runAtThisOrScheduleAtNextAnimationFrame(() => {
+        this._pendingLayout.value = dom.runAtThisOrScheduleAtNextAnimationFrame(dom.getWindow(this.element.domNode), () => {
             this._pendingLayout.clear();
             this._layout(this.element.size);
         });
@@ -259,7 +259,7 @@ let SimpleSuggestWidget = class SimpleSuggestWidget {
         if (!this._cursorPosition) {
             return;
         }
-        const bodyBox = dom.getClientArea(document.body);
+        const bodyBox = dom.getClientArea(this._container.ownerDocument.body);
         const info = this._getLayoutInfo();
         if (!size) {
             size = info.defaultSize;

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -269,6 +269,15 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         if (!target) {
             return;
         }
+        if (this.filesConfigurationService.isReadonly(target)) {
+            const confirmed = await this.confirmMakeWriteable(target);
+            if (!confirmed) {
+                return;
+            }
+            else {
+                this.filesConfigurationService.updateReadonly(target, false);
+            }
+        }
         if (isEqual(source, target)) {
             return this.save(source, { ...options, force: true  });
         }
@@ -396,7 +405,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             )),
             detail: ( localizeWithPath(
                 'vs/workbench/services/textfile/browser/textFileService',
-                'irreversible',
+                'overwriteIrreversible',
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
@@ -409,6 +418,28 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         });
         return confirmed;
     }
+    async confirmMakeWriteable(resource) {
+        const { confirmed } = await this.dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/services/textfile/browser/textFileService',
+                'confirmMakeWriteable',
+                "'{0}' is marked as read-only. Do you want to save anyway?",
+                basename(resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/textfile/browser/textFileService',
+                'confirmMakeWriteableDetail',
+                "Paths can be configured as read-only via settings."
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/textfile/browser/textFileService',
+                { key: 'makeWriteableButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Save Anyway"
+            ))
+        });
+        return confirmed;
+    }
     async suggestSavePath(resource) {
         if (this.fileService.hasProvider(resource)) {
             return resource;