@codingame/monaco-vscode-api 26.2.1 → 27.0.0

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.config.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.config.contribution.js

@@ -0,0 +1,32 @@
+
+import { localize } from '../../../nls.js';
+import { Extensions, ConfigurationScope } from '../../configuration/common/configurationRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "network",
+    order: 14,
+    title: ( localize(2037, "Network")),
+    type: "object",
+    properties: {
+        "network.meteredConnection": {
+            type: "string",
+            enum: ["auto", "on", "off"],
+            enumDescriptions: [( localize(
+                2038,
+                "Automatically detect metered connections using the operating system's network status."
+            )), ( localize(
+                2039,
+                "Always treat the network connection as metered. Automatic updates and downloads will be postponed."
+            )), ( localize(2040, "Never treat the network connection as metered."))],
+            default: "auto",
+            scope: ConfigurationScope.APPLICATION,
+            description: ( localize(
+                2041,
+                "Controls whether the current network connection should be treated as metered. When metered, automatic updates, extension downloads, and other background network activity will be postponed to reduce data usage."
+            )),
+            tags: ["usesOnlineServices"]
+        }
+    }
+});

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.d.ts

@@ -0,0 +1,44 @@
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../configuration/common/configuration.service.js";
+import { IMeteredConnectionService } from "./meteredConnection.service.js";
+export declare const METERED_CONNECTION_SETTING_KEY = "network.meteredConnection";
+export type MeteredConnectionSettingValue = "on" | "off" | "auto";
+/**
+ * Network Information API
+ * See https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API
+ */
+export interface NetworkInformation {
+    saveData?: boolean;
+    metered?: boolean;
+    effectiveType?: "slow-2g" | "2g" | "3g" | "4g";
+    addEventListener(type: "change", listener: () => void): void;
+    removeEventListener(type: "change", listener: () => void): void;
+}
+/**
+ * Extended Navigator interface for Network Information API
+ */
+export interface NavigatorWithConnection {
+    readonly connection?: NetworkInformation;
+}
+/**
+ * Check if the current network connection is metered according to the Network Information API.
+ */
+export declare function getIsBrowserConnectionMetered(): boolean;
+/**
+ * Abstract base class for metered connection services.
+ */
+export declare abstract class AbstractMeteredConnectionService extends Disposable implements IMeteredConnectionService {
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeIsConnectionMetered;
+    readonly onDidChangeIsConnectionMetered: import("../../../base/common/event.js").Event<boolean>;
+    private _isConnectionMetered;
+    private _isBrowserConnectionMetered;
+    private _meteredConnectionSetting;
+    constructor(configurationService: IConfigurationService, isBrowserConnectionMetered: boolean);
+    get isConnectionMetered(): boolean;
+    protected get isBrowserConnectionMetered(): boolean;
+    setIsBrowserConnectionMetered(value: boolean): void;
+    protected onChangeBrowserConnection(): void;
+    protected onUpdated(): void;
+    protected onChangeIsConnectionMetered(): void;
+}

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.js

@@ -0,0 +1,62 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+
+const METERED_CONNECTION_SETTING_KEY = "network.meteredConnection";
+function getIsBrowserConnectionMetered() {
+    const connection = navigator.connection;
+    if (!connection) {
+        return false;
+    }
+    if (connection.saveData || connection.metered) {
+        return true;
+    }
+    const effectiveType = connection.effectiveType;
+    return effectiveType === "2g" || effectiveType === "slow-2g";
+}
+class AbstractMeteredConnectionService extends Disposable {
+    constructor(configurationService, isBrowserConnectionMetered) {
+        super();
+        this._onDidChangeIsConnectionMetered = this._register(( new Emitter()));
+        this.onDidChangeIsConnectionMetered = this._onDidChangeIsConnectionMetered.event;
+        this._isBrowserConnectionMetered = isBrowserConnectionMetered;
+        this._meteredConnectionSetting = configurationService.getValue(METERED_CONNECTION_SETTING_KEY);
+        this._isConnectionMetered = this._meteredConnectionSetting === "on" || (this._meteredConnectionSetting !== "off" && this._isBrowserConnectionMetered);
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(METERED_CONNECTION_SETTING_KEY)) {
+                const value = configurationService.getValue(METERED_CONNECTION_SETTING_KEY);
+                if (value !== this._meteredConnectionSetting) {
+                    this._meteredConnectionSetting = value;
+                    this.onUpdated();
+                }
+            }
+        }));
+    }
+    get isConnectionMetered() {
+        return this._isConnectionMetered;
+    }
+    get isBrowserConnectionMetered() {
+        return this._isBrowserConnectionMetered;
+    }
+    setIsBrowserConnectionMetered(value) {
+        if (value !== this._isBrowserConnectionMetered) {
+            this._isBrowserConnectionMetered = value;
+            this.onChangeBrowserConnection();
+        }
+    }
+    onChangeBrowserConnection() {
+        this.onUpdated();
+    }
+    onUpdated() {
+        const value = this._meteredConnectionSetting === "on" || (this._meteredConnectionSetting !== "off" && this._isBrowserConnectionMetered);
+        if (value !== this._isConnectionMetered) {
+            this._isConnectionMetered = value;
+            this.onChangeIsConnectionMetered();
+        }
+    }
+    onChangeIsConnectionMetered() {
+        this._onDidChangeIsConnectionMetered.fire(this._isConnectionMetered);
+    }
+}
+
+export { AbstractMeteredConnectionService, METERED_CONNECTION_SETTING_KEY, getIsBrowserConnectionMetered };

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.service.d.ts

@@ -0,0 +1,18 @@
+import { Event } from "../../../base/common/event.js";
+export declare const IMeteredConnectionService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IMeteredConnectionService>;
+/**
+* Service to report on metered connection status.
+*/
+export interface IMeteredConnectionService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Whether the current network connection is metered.
+    * Always returns `false` if the `network.meteredConnection` setting is `off`.
+    * Always returns `true` if the `network.meteredConnection` setting is `on`.
+    */
+    readonly isConnectionMetered: boolean;
+    /**
+    * Event that fires when the metered connection status changes.
+    */
+    readonly onDidChangeIsConnectionMetered: Event<boolean>;
+}

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IMeteredConnectionService = ( createDecorator("meteredConnectionService"));
+
+export { IMeteredConnectionService };

package/vscode/src/vs/platform/native/common/native.d.ts

@@ -8,6 +8,18 @@ import { IV8Profile } from "../../profiling/common/profiling.js";
 import { AuthInfo, Credentials } from "../../request/common/request.js";
 import { IPartsSplash } from "../../theme/common/themeService.js";
 import { IColorScheme, IOpenedAuxiliaryWindow, IOpenedMainWindow, IOpenEmptyWindowOptions, IOpenWindowOptions, IPoint, IRectangle, IWindowOpenable } from "../../window/common/window.js";
+export interface IToastOptions {
+    readonly id: string;
+    readonly title: string;
+    readonly body?: string;
+    readonly actions?: readonly string[];
+    readonly silent?: boolean;
+}
+export interface IToastResult {
+    readonly supported: boolean;
+    readonly clicked: boolean;
+    readonly actionIndex?: number;
+}
 export interface ICPUProperties {
     model: string;
     speed: number;
@@ -64,7 +76,14 @@ export interface ICommonNativeHostService {
     readonly onDidFocusMainOrAuxiliaryWindow: Event<number>;
     readonly onDidBlurMainOrAuxiliaryWindow: Event<number>;
     readonly onDidChangeDisplay: Event<void>;
+    readonly onDidSuspendOS: Event<void>;
     readonly onDidResumeOS: Event<unknown>;
+    readonly onDidChangeOnBatteryPower: Event<boolean>;
+    readonly onDidChangeThermalState: Event<ThermalState>;
+    readonly onDidChangeSpeedLimit: Event<number>;
+    readonly onWillShutdownOS: Event<void>;
+    readonly onDidLockScreen: Event<void>;
+    readonly onDidUnlockScreen: Event<void>;
     readonly onDidChangeColorScheme: Event<IColorScheme>;
     readonly onDidChangePassword: Event<{
         readonly service: string;
@@ -87,6 +106,7 @@ export interface ICommonNativeHostService {
     getNativeWindowHandle(windowId: number): Promise<VSBuffer | undefined>;
     openWindow(options?: IOpenEmptyWindowOptions): Promise<void>;
     openWindow(toOpen: IWindowOpenable[], options?: IOpenWindowOptions): Promise<void>;
+    openSessionsWindow(): Promise<void>;
     isFullScreen(options?: INativeHostOptions): Promise<boolean>;
     toggleFullScreen(options?: INativeHostOptions): Promise<void>;
     getCursorScreenPoint(): Promise<{
@@ -102,15 +122,11 @@ export interface ICommonNativeHostService {
     isWindowAlwaysOnTop(options?: INativeHostOptions): Promise<boolean>;
     toggleWindowAlwaysOnTop(options?: INativeHostOptions): Promise<void>;
     setWindowAlwaysOnTop(alwaysOnTop: boolean, options?: INativeHostOptions): Promise<void>;
-    /**
-     * Only supported on Windows and macOS. Updates the window controls to match the title bar size.
-     *
-     * @param options `backgroundColor` and `foregroundColor` are only supported on Windows
-     */
     updateWindowControls(options: INativeHostOptions & {
         height?: number;
         backgroundColor?: string;
         foregroundColor?: string;
+        dimmed?: boolean;
     }): Promise<void>;
     updateWindowAccentColor(color: "default" | "off" | string, inactiveColor: string | undefined): Promise<void>;
     setMinimumSize(width: number | undefined, height: number | undefined): Promise<void>;
@@ -192,6 +208,9 @@ export interface ICommonNativeHostService {
     isPortFree(port: number): Promise<boolean>;
     findFreePort(startPort: number, giveUpAfter: number, timeout: number, stride?: number): Promise<number>;
     windowsGetStringRegKey(hive: "HKEY_CURRENT_USER" | "HKEY_LOCAL_MACHINE" | "HKEY_CLASSES_ROOT" | "HKEY_USERS" | "HKEY_CURRENT_CONFIG", path: string, name: string): Promise<string | undefined>;
+    showToast(options: IToastOptions): Promise<IToastResult>;
+    clearToast(id: string): Promise<void>;
+    clearToasts(): Promise<void>;
     /**
      * Creates a zip file at the specified path containing the provided files.
      *
@@ -202,4 +221,23 @@ export interface ICommonNativeHostService {
         path: string;
         contents: string;
     }[]): Promise<void>;
+    getSystemIdleState(idleThreshold: number): Promise<SystemIdleState>;
+    getSystemIdleTime(): Promise<number>;
+    getCurrentThermalState(): Promise<ThermalState>;
+    isOnBatteryPower(): Promise<boolean>;
+    startPowerSaveBlocker(type: PowerSaveBlockerType): Promise<number>;
+    stopPowerSaveBlocker(id: number): Promise<boolean>;
+    isPowerSaveBlockerStarted(id: number): Promise<boolean>;
 }
+/**
+ * Represents the system's idle state.
+ */
+export type SystemIdleState = "active" | "idle" | "locked" | "unknown";
+/**
+ * Represents the system's thermal state.
+ */
+export type ThermalState = "unknown" | "nominal" | "fair" | "serious" | "critical";
+/**
+ * The type of power save blocker.
+ */
+export type PowerSaveBlockerType = "prevent-app-suspension" | "prevent-display-sleep";

package/vscode/src/vs/platform/notification/common/notification.js

@@ -47,12 +47,12 @@ class NoOpProgress {
 }
 function withSeverityPrefix(label, severity) {
     if (severity === Severity$1.Error) {
-        return localize(2006, "Error: {0}", label);
+        return localize(2042, "Error: {0}", label);
     }
     if (severity === Severity$1.Warning) {
-        return localize(2007, "Warning: {0}", label);
+        return localize(2043, "Warning: {0}", label);
     }
-    return localize(2008, "Info: {0}", label);
+    return localize(2044, "Info: {0}", label);
 }
 
 export { NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter, Severity$1 as Severity, isNotificationSource, withSeverityPrefix };

package/vscode/src/vs/platform/observable/common/platformObservableUtils.js

@@ -1,7 +1,7 @@
 
 import { DisposableStore } from '../../../base/common/lifecycle.js';
 import '../../../base/common/observableInternal/index.js';
-import { observableFromEventOpts } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableFromEventOpts, observableFromEvent } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { DebugLocation } from '../../../base/common/observableInternal/debugLocation.js';
 import { derivedOpts } from '../../../base/common/observableInternal/observables/derived.js';
 
@@ -31,5 +31,13 @@ function bindContextKey(key, service, computeValue, debugLocation = DebugLocatio
     }, debugLocation).recomputeInitiallyAndOnChange(store);
     return store;
 }
+function observableContextKey(key, contextKeyService, debugLocation = DebugLocation.ofCaller()) {
+    return observableFromEvent(
+        undefined,
+        contextKeyService.onDidChangeContext,
+        () => contextKeyService.getContextKeyValue(key),
+        debugLocation
+    );
+}
 
-export { bindContextKey, observableConfigValue };
+export { bindContextKey, observableConfigValue, observableContextKey };

package/vscode/src/vs/platform/product/common/product.js

@@ -4,9 +4,9 @@ import productJson from '../../../../../product.json.js';
 var product = {
   ...productJson,
   quality: 'stable',
-  version: '1.109.3',
-  commit: 'b6a47e94e326b5c209d118cf0f994d6065585705',
-  date: '2026-02-23T13:31:10.887Z',
+  version: '1.110.0',
+  commit: '0870c2a0c7c0564e7631bfed2675573a94ba4455',
+  date: '2026-03-05T17:53:39.389Z',
   ...(globalThis._VSCODE_PRODUCT_JSON ?? {})
 };
 

package/vscode/src/vs/platform/quickinput/browser/media/quickInput.css

@@ -20,6 +20,11 @@
 	border-top-left-radius: 5px;
 }
 
+.quick-input-widget.no-drag .quick-input-titlebar,
+.quick-input-widget.no-drag .quick-input-title,
+.quick-input-widget.no-drag .quick-input-header {
+	cursor: default;
+}
 .quick-input-widget .monaco-inputbox .monaco-action-bar {
 	top: 0;
 }

package/vscode/src/vs/platform/quickinput/browser/quickInput.js

@@ -25,26 +25,26 @@ import { observableValue } from '../../../base/common/observableInternal/observa
 
 registerCss(quickInput);
 const inQuickInputContextKeyValue = "inQuickInput";
-const InQuickInputContextKey = ( new RawContextKey(inQuickInputContextKeyValue, false, ( localize(2017, "Whether keyboard focus is inside the quick input control"))));
+const InQuickInputContextKey = ( new RawContextKey(inQuickInputContextKeyValue, false, ( localize(2053, "Whether keyboard focus is inside the quick input control"))));
 const inQuickInputContext = ( ContextKeyExpr.has(inQuickInputContextKeyValue));
 const quickInputAlignmentContextKeyValue = "quickInputAlignment";
-const QuickInputAlignmentContextKey = ( new RawContextKey(quickInputAlignmentContextKeyValue, "top", ( localize(2018, "The alignment of the quick input"))));
+const QuickInputAlignmentContextKey = ( new RawContextKey(quickInputAlignmentContextKeyValue, "top", ( localize(2054, "The alignment of the quick input"))));
 const quickInputTypeContextKeyValue = "quickInputType";
-const QuickInputTypeContextKey = ( new RawContextKey(quickInputTypeContextKeyValue, undefined, ( localize(2019, "The type of the currently visible quick input"))));
+const QuickInputTypeContextKey = ( new RawContextKey(quickInputTypeContextKeyValue, undefined, ( localize(2055, "The type of the currently visible quick input"))));
 const endOfQuickInputBoxContextKeyValue = "cursorAtEndOfQuickInputBox";
 const EndOfQuickInputBoxContextKey = ( new RawContextKey(endOfQuickInputBoxContextKeyValue, false, ( localize(
-    2020,
+    2056,
     "Whether the cursor in the quick input is at the end of the input box"
 ))));
 const endOfQuickInputBoxContext = ( ContextKeyExpr.has(endOfQuickInputBoxContextKeyValue));
 const backButton = {
     iconClass: ThemeIcon.asClassName(Codicon.quickInputBack),
-    tooltip: ( localize(2021, "Back")),
+    tooltip: ( localize(2057, "Back")),
     handle: -1
 };
 class QuickInput extends Disposable {
     static {
-        this.noPromptMessage = ( localize(2022, "Press 'Enter' to confirm your input or 'Escape' to cancel"));
+        this.noPromptMessage = ( localize(2058, "Press 'Enter' to confirm your input or 'Escape' to cancel"));
     }
     constructor(ui) {
         super();
@@ -320,7 +320,7 @@ class QuickInput extends Disposable {
     }
     getSteps() {
         if (this.step && this.totalSteps) {
-            return localize(2023, "{0}/{1}", this.step, this.totalSteps);
+            return localize(2059, "{0}/{1}", this.step, this.totalSteps);
         }
         if (this.step) {
             return String(this.step);
@@ -350,7 +350,7 @@ class QuickInput extends Disposable {
 }
 class QuickPick extends QuickInput {
     static {
-        this.DEFAULT_ARIA_LABEL = ( localize(2024, "Type to narrow down results."));
+        this.DEFAULT_ARIA_LABEL = ( localize(2060, "Type to narrow down results."));
     }
     constructor(ui) {
         super(ui);
@@ -590,7 +590,7 @@ class QuickPick extends QuickInput {
         this.update();
     }
     get okLabel() {
-        return this._okLabel ?? ( localize(2025, "OK"));
+        return this._okLabel ?? ( localize(2061, "OK"));
     }
     set okLabel(okLabel) {
         this._okLabel = okLabel;
@@ -949,7 +949,7 @@ class InputBox extends QuickInput {
     }
     set prompt(prompt) {
         this._prompt = prompt;
-        this.noValidationMessage = prompt ? ( localize(2026, "{0} (Press 'Enter' to confirm or 'Escape' to cancel)", prompt)) : QuickInput.noPromptMessage;
+        this.noValidationMessage = prompt ? ( localize(2062, "{0} (Press 'Enter' to confirm or 'Escape' to cancel)", prompt)) : QuickInput.noPromptMessage;
         this.update();
     }
     show() {

package/vscode/src/vs/platform/quickinput/browser/quickInputActions.js

@@ -15,7 +15,7 @@ function registerQuickInputCommandAndKeybindingRule(rule, options = {}) {
         when: inQuickInputContext,
         metadata: {
             description: ( localize(
-                2027,
+                2063,
                 "Used while in the context of any kind of quick input. If you change one keybinding for this command, you should change all of the other keybindings (modifier variants) of this command as well."
             ))
         },
@@ -30,7 +30,7 @@ function registerQuickPickCommandAndKeybindingRule(rule, options = {}) {
         ContextKeyExpr.equals(quickInputTypeContextKeyValue, QuickInputType.QuickPick)), ( ContextKeyExpr.equals(quickInputTypeContextKeyValue, QuickInputType.QuickTree)))), inQuickInputContext)),
         metadata: {
             description: ( localize(
-                2028,
+                2064,
                 "Used while in the context of the quick pick. If you change one keybinding for this command, you should change all of the other keybindings (modifier variants) of this command as well."
             ))
         },
@@ -124,11 +124,11 @@ registerQuickPickCommandAndKeybindingRule({
     withCtrlMod: true
 });
 const nextSeparatorFallbackDesc = ( localize(
-    2029,
+    2065,
     "If we're in quick access mode, this will navigate to the next item. If we are not in quick access mode, this will navigate to the next separator."
 ));
 const prevSeparatorFallbackDesc = ( localize(
-    2030,
+    2066,
     "If we're in quick access mode, this will navigate to the previous item. If we are not in quick access mode, this will navigate to the previous separator."
 ));
 if (isMacintosh) {
@@ -200,7 +200,7 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     ContextKeyExpr.notEquals(quickInputTypeContextKeyValue, QuickInputType.QuickWidget)), inQuickInputContext, ContextKeyExpr.not("isComposing"))),
     metadata: {
         description: ( localize(
-            2031,
+            2067,
             "Used while in the context of some quick input. If you change one keybinding for this command, you should change all of the other keybindings (modifier variants) of this command as well."
         ))
     },

package/vscode/src/vs/platform/quickinput/browser/quickInputBox.d.ts

@@ -8,6 +8,7 @@ export declare class QuickInputBox extends Disposable {
     private parent;
     private container;
     private findInput;
+    private _listFocusMode;
     constructor(parent: HTMLElement, inputBoxStyles: IInputBoxStyles, toggleStyles: IToggleStyles);
     get onKeyDown(): import("../../../base/common/event.js").Event<import("../../../base/browser/keyboardEvent.js").IKeyboardEvent>;
     get onMouseDown(): import("../../../base/common/event.js").Event<import("../../../base/browser/mouseEvent.js").IMouseEvent>;
@@ -31,6 +32,14 @@ export declare class QuickInputBox extends Disposable {
     hasFocus(): boolean;
     setAttribute(name: string, value: string): void;
     removeAttribute(name: string): void;
+    /**
+     * Controls the ARIA popup mode for screen readers.
+     * When enabled (hasActiveDescendant=true), indicates a list popup is active.
+     * When disabled, removes ARIA attributes to allow normal text input behavior.
+     * Only updates attributes when the state actually changes to avoid
+     * unnecessary screen reader re-announcements.
+     */
+    setListFocusMode(hasActiveDescendant: boolean): void;
     showDecoration(decoration: Severity): void;
     stylesForType(decoration: Severity): {
         border: string | undefined;

package/vscode/src/vs/platform/quickinput/browser/quickInputBox.js

@@ -14,6 +14,7 @@ class QuickInputBox extends Disposable {
     constructor(parent, inputBoxStyles, toggleStyles) {
         super();
         this.parent = parent;
+        this._listFocusMode = false;
         this.onDidChange = handler => {
             return this.findInput.onDidChange(handler);
         };
@@ -25,10 +26,6 @@ class QuickInputBox extends Disposable {
             actionViewItemProvider: createToggleActionViewItemProvider(toggleStyles),
             hideHoverOnValueChange: true
         })));
-        const input = this.findInput.inputBox.inputElement;
-        input.role = "textbox";
-        input.ariaHasPopup = "menu";
-        input.ariaAutoComplete = "list";
     }
     get onKeyDown() {
         return this.findInput.onKeyDown;
@@ -93,6 +90,20 @@ class QuickInputBox extends Disposable {
     removeAttribute(name) {
         this.findInput.inputBox.inputElement.removeAttribute(name);
     }
+    setListFocusMode(hasActiveDescendant) {
+        if (this._listFocusMode === hasActiveDescendant) {
+            return;
+        }
+        this._listFocusMode = hasActiveDescendant;
+        const input = this.findInput.inputBox.inputElement;
+        if (hasActiveDescendant) {
+            input.setAttribute("aria-haspopup", "listbox");
+            input.setAttribute("aria-autocomplete", "list");
+        } else {
+            input.removeAttribute("aria-haspopup");
+            input.removeAttribute("aria-autocomplete");
+        }
+    }
     showDecoration(decoration) {
         if (decoration === Severity$1.Ignore) {
             this.findInput.clearMessage();