@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { $ as $$1, onDidRegisterWindow, onWillUnregisterWindow, getWindow, EventType, addDisposableListener, append, addStandardDisposableListener, trackFocus, isAncestor, isHTMLElement, EventHelper, reset, isAncestorOfActiveElement } from '../../../base/browser/dom.js';
+import { $ as $$1, onDidRegisterWindow, onWillUnregisterWindow, getWindow, EventType, addDisposableListener, append, addStandardDisposableListener, trackFocus, isAncestor, isHTMLElement, EventHelper, reset, isAncestorOfActiveElement, addDisposableGenericMouseUpListener, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, getActiveWindow } from '../../../base/browser/dom.js';
 import { createStyleSheet } from '../../../base/browser/domStylesheets.js';
 import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
 import { Button } from '../../../base/browser/ui/button/button.js';
@@ -15,27 +15,41 @@ import { isString } from '../../../base/common/types.js';
 import { localize } from '../../../nls.js';
 import { QuickInputHideReason, QuickPickFocus } from '../common/quickInput.js';
 import { QuickInputBox } from './quickInputBox.js';
-import { InQuickInputContextKey, QuickInputTypeContextKey, EndOfQuickInputBoxContextKey, backButton, QuickPick, InputBox, QuickWidget } from './quickInput.js';
+import { InQuickInputContextKey, QuickInputTypeContextKey, EndOfQuickInputBoxContextKey, backButton, QuickPick, InputBox, QuickWidget, QuickInputAlignmentContextKey } from './quickInput.js';
 import { ILayoutService } from '../../layout/browser/layoutService.service.js';
 import { mainWindow } from '../../../base/browser/window.js';
 import { IInstantiationService } from '../../instantiation/common/instantiation.js';
 import { QuickInputTree } from './quickInputTree.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import './quickInputActions.js';
+import { observableValue } from '../../../base/common/observableInternal/base.js';
+import '../../../base/common/arrays.js';
+import { autorun } from '../../../base/common/observableInternal/autorun.js';
+import '../../../base/common/observableInternal/derived.js';
+import '../../../base/common/observableInternal/utils.js';
+import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
+import { StorageScope, StorageTarget } from '../../storage/common/storage.js';
+import { IStorageService } from '../../storage/common/storage.service.js';
+import { IConfigurationService } from '../../configuration/common/configuration.service.js';
+import { platform, Platform } from '../../../base/common/platform.js';
+import { getTitleBarStyle, TitlebarStyle } from '../../window/common/window.js';
+import { getZoomFactor } from '../../../base/browser/browser.js';
 
 var QuickInputController_1;
 const $ = $$1;
+const VIEWSTATE_STORAGE_KEY = 'workbench.quickInput.viewState';
 let QuickInputController = class QuickInputController extends Disposable {
     static { QuickInputController_1 = this; }
     static { this.MAX_WIDTH = 600; }
     get currentQuickInput() { return this.controller ?? undefined; }
     get container() { return this._container; }
-    constructor(options, layoutService, instantiationService, contextKeyService) {
+    constructor(options, layoutService, instantiationService, contextKeyService, storageService) {
         super();
         this.options = options;
         this.layoutService = layoutService;
         this.instantiationService = instantiationService;
         this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
         this.enabled = true;
         this.onDidAcceptEmitter = this._register(( new Emitter()));
         this.onDidCustomEmitter = this._register(( new Emitter()));
@@ -60,6 +74,7 @@ let QuickInputController = class QuickInputController extends Disposable {
                 this.layout(this.layoutService.mainContainerDimension, this.layoutService.mainContainerOffset.quickPickTop);
             }
         }));
+        this.viewState = this.loadViewState();
     }
     registerKeyModsListeners(window, disposables) {
         const listener = (e) => {
@@ -93,7 +108,7 @@ let QuickInputController = class QuickInputController extends Disposable {
         const headerContainer = append(container, $('.quick-input-header'));
         const checkAll = append(headerContainer, $('input.quick-input-check-all'));
         checkAll.type = 'checkbox';
-        checkAll.setAttribute('aria-label', ( localize(1845, "Toggle all checkboxes")));
+        checkAll.setAttribute('aria-label', ( localize(1882, "Toggle all checkboxes")));
         this._register(addStandardDisposableListener(checkAll, EventType.CHANGE, e => {
             const checked = checkAll.checked;
             list.setAllVisibleChecked(checked);
@@ -111,21 +126,21 @@ let QuickInputController = class QuickInputController extends Disposable {
         const visibleCountContainer = append(filterContainer, $('.quick-input-visible-count'));
         visibleCountContainer.setAttribute('aria-live', 'polite');
         visibleCountContainer.setAttribute('aria-atomic', 'true');
-        const visibleCount = this._register(( new CountBadge(visibleCountContainer, { countFormat: ( localize(1846, "{0} Results")) }, this.styles.countBadge)));
+        const visibleCount = this._register(( new CountBadge(visibleCountContainer, { countFormat: ( localize(1883, "{0} Results")) }, this.styles.countBadge)));
         const countContainer = append(filterContainer, $('.quick-input-count'));
         countContainer.setAttribute('aria-live', 'polite');
-        const count = this._register(( new CountBadge(countContainer, { countFormat: ( localize(1847, "{0} Selected")) }, this.styles.countBadge)));
+        const count = this._register(( new CountBadge(countContainer, { countFormat: ( localize(1884, "{0} Selected")) }, this.styles.countBadge)));
         const inlineActionBar = this._register(( new ActionBar(headerContainer, { hoverDelegate: this.options.hoverDelegate })));
         inlineActionBar.domNode.classList.add('quick-input-inline-action-bar');
         const okContainer = append(headerContainer, $('.quick-input-action'));
         const ok = this._register(( new Button(okContainer, this.styles.button)));
-        ok.label = ( localize(1848, "OK"));
+        ok.label = ( localize(1885, "OK"));
         this._register(ok.onDidClick(e => {
             this.onDidAcceptEmitter.fire();
         }));
         const customButtonContainer = append(headerContainer, $('.quick-input-action'));
         const customButton = this._register(( new Button(customButtonContainer, { ...this.styles.button, supportIcons: true })));
-        customButton.label = ( localize(1849, "Custom"));
+        customButton.label = ( localize(1886, "Custom"));
         this._register(customButton.onDidClick(e => {
             this.onDidCustomEmitter.fire();
         }));
@@ -253,6 +268,36 @@ let QuickInputController = class QuickInputController extends Disposable {
                     break;
             }
         }));
+        this.dndController = this._register(this.instantiationService.createInstance(QuickInputDragAndDropController, this._container, container, [
+            {
+                node: titleBar,
+                includeChildren: true
+            },
+            {
+                node: headerContainer,
+                includeChildren: false
+            }
+        ], this.viewState));
+        this._register(autorun(reader => {
+            const dndViewState = this.dndController?.dndViewState.read(reader);
+            if (!dndViewState) {
+                return;
+            }
+            if (dndViewState.top !== undefined && dndViewState.left !== undefined) {
+                this.viewState = {
+                    ...this.viewState,
+                    top: dndViewState.top,
+                    left: dndViewState.left
+                };
+            }
+            else {
+                this.viewState = undefined;
+            }
+            this.updateLayout();
+            if (dndViewState.done) {
+                this.saveViewState(this.viewState);
+            }
+        }));
         this.ui = {
             container,
             styleSheet,
@@ -298,6 +343,7 @@ let QuickInputController = class QuickInputController extends Disposable {
         if (this.ui) {
             this._container = container;
             append(this._container, this.ui.container);
+            this.dndController?.reparentUI(this._container);
         }
     }
     pick(picks, options = {}, token = CancellationToken.None) {
@@ -488,6 +534,9 @@ let QuickInputController = class QuickInputController extends Disposable {
         const ui = this.getUI(true);
         return ( new InputBox(ui));
     }
+    setAlignment(alignment) {
+        this.dndController?.setAlignment(alignment);
+    }
     createQuickWidget() {
         const ui = this.getUI(true);
         return ( new QuickWidget(ui));
@@ -522,9 +571,10 @@ let QuickInputController = class QuickInputController extends Disposable {
         ui.ignoreFocusOut = false;
         ui.inputBox.toggles = undefined;
         const backKeybindingLabel = this.options.backKeybindingLabel();
-        backButton.tooltip = backKeybindingLabel ? ( localize(1850, "Back ({0})", backKeybindingLabel)) : ( localize(1851, "Back"));
+        backButton.tooltip = backKeybindingLabel ? ( localize(1887, "Back ({0})", backKeybindingLabel)) : ( localize(1888, "Back"));
         ui.container.style.display = '';
         this.updateLayout();
+        this.dndController?.layoutContainer();
         ui.inputBox.setFocus();
         this.quickInputTypeContext.set(controller.type);
     }
@@ -635,11 +685,11 @@ let QuickInputController = class QuickInputController extends Disposable {
     }
     updateLayout() {
         if (this.ui && this.isVisible()) {
-            this.ui.container.style.top = `${this.titleBarOffset}px`;
             const style = this.ui.container.style;
             const width = Math.min(this.dimension.width * 0.62 , QuickInputController_1.MAX_WIDTH);
             style.width = width + 'px';
-            style.marginLeft = '-' + (width / 2) + 'px';
+            style.top = `${this.viewState?.top ? Math.round(this.dimension.height * this.viewState.top) : this.titleBarOffset}px`;
+            style.left = `${Math.round((this.dimension.width * ((this.viewState?.left ?? 0.5) )) - (width / 2))}px`;
             this.ui.inputBox.layout();
             this.ui.list.layout(this.dimension && this.dimension.height * 0.4);
         }
@@ -696,11 +746,190 @@ let QuickInputController = class QuickInputController extends Disposable {
             }
         }
     }
+    loadViewState() {
+        try {
+            const data = JSON.parse(this.storageService.get(VIEWSTATE_STORAGE_KEY, StorageScope.APPLICATION, '{}'));
+            if (data.top !== undefined || data.left !== undefined) {
+                return data;
+            }
+        }
+        catch { }
+        return undefined;
+    }
+    saveViewState(viewState) {
+        const isMainWindow = this.layoutService.activeContainer === this.layoutService.mainContainer;
+        if (!isMainWindow) {
+            return;
+        }
+        if (viewState !== undefined) {
+            this.storageService.store(VIEWSTATE_STORAGE_KEY, JSON.stringify(viewState), StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        else {
+            this.storageService.remove(VIEWSTATE_STORAGE_KEY, StorageScope.APPLICATION);
+        }
+    }
 };
 QuickInputController = QuickInputController_1 = ( __decorate([
     ( __param(1, ILayoutService)),
     ( __param(2, IInstantiationService)),
-    ( __param(3, IContextKeyService))
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IStorageService))
 ], QuickInputController));
+let QuickInputDragAndDropController = class QuickInputDragAndDropController extends Disposable {
+    constructor(_container, _quickInputContainer, _quickInputDragAreas, initialViewState, _layoutService, _contextKeyService, configurationService) {
+        super();
+        this._container = _container;
+        this._quickInputContainer = _quickInputContainer;
+        this._quickInputDragAreas = _quickInputDragAreas;
+        this._layoutService = _layoutService;
+        this._contextKeyService = _contextKeyService;
+        this.configurationService = configurationService;
+        this.dndViewState = observableValue(this, undefined);
+        this._snapThreshold = 20;
+        this._snapLineHorizontalRatio = 0.25;
+        this._quickInputAlignmentContext = QuickInputAlignmentContextKey.bindTo(this._contextKeyService);
+        const customTitleBar = getTitleBarStyle(this.configurationService) === TitlebarStyle.CUSTOM;
+        this._controlsOnLeft = customTitleBar && platform === Platform.Mac;
+        this._controlsOnRight = customTitleBar && (platform === Platform.Windows || platform === Platform.Linux);
+        this._registerLayoutListener();
+        this.registerMouseListeners();
+        this.dndViewState.set({ ...initialViewState, done: true }, undefined);
+    }
+    reparentUI(container) {
+        this._container = container;
+    }
+    layoutContainer(dimension = this._layoutService.activeContainerDimension) {
+        const state = this.dndViewState.get();
+        const dragAreaRect = this._quickInputContainer.getBoundingClientRect();
+        if (state?.top && state?.left) {
+            const a = Math.round(state.left * 1e2) / 1e2;
+            const b = dimension.width;
+            const c = dragAreaRect.width;
+            const d = a * b - c / 2;
+            this._layout(state.top * dimension.height, d);
+        }
+    }
+    setAlignment(alignment, done = true) {
+        if (alignment === 'top') {
+            this.dndViewState.set({
+                top: this._getTopSnapValue() / this._container.clientHeight,
+                left: (this._getCenterXSnapValue() + (this._quickInputContainer.clientWidth / 2)) / this._container.clientWidth,
+                done
+            }, undefined);
+            this._quickInputAlignmentContext.set('top');
+        }
+        else if (alignment === 'center') {
+            this.dndViewState.set({
+                top: this._getCenterYSnapValue() / this._container.clientHeight,
+                left: (this._getCenterXSnapValue() + (this._quickInputContainer.clientWidth / 2)) / this._container.clientWidth,
+                done
+            }, undefined);
+            this._quickInputAlignmentContext.set('center');
+        }
+        else {
+            this.dndViewState.set({ top: alignment.top, left: alignment.left, done }, undefined);
+            this._quickInputAlignmentContext.set(undefined);
+        }
+    }
+    _registerLayoutListener() {
+        this._register(Event.filter(this._layoutService.onDidLayoutContainer, e => e.container === this._container)((e) => this.layoutContainer(e.dimension)));
+    }
+    registerMouseListeners() {
+        const dragArea = this._quickInputContainer;
+        this._register(addDisposableGenericMouseUpListener(dragArea, (event) => {
+            const originEvent = ( new StandardMouseEvent(getWindow(dragArea), event));
+            if (originEvent.detail !== 2) {
+                return;
+            }
+            if (!( this._quickInputDragAreas.some(
+                ({ node, includeChildren }) => includeChildren ? isAncestor(originEvent.target, node) : originEvent.target === node
+            ))) {
+                return;
+            }
+            this.dndViewState.set({ top: undefined, left: undefined, done: true }, undefined);
+        }));
+        this._register(addDisposableGenericMouseDownListener(dragArea, (e) => {
+            const activeWindow = getWindow(this._layoutService.activeContainer);
+            const originEvent = ( new StandardMouseEvent(activeWindow, e));
+            if (!( this._quickInputDragAreas.some(
+                ({ node, includeChildren }) => includeChildren ? isAncestor(originEvent.target, node) : originEvent.target === node
+            ))) {
+                return;
+            }
+            const dragAreaRect = this._quickInputContainer.getBoundingClientRect();
+            const dragOffsetX = originEvent.browserEvent.clientX - dragAreaRect.left;
+            const dragOffsetY = originEvent.browserEvent.clientY - dragAreaRect.top;
+            let isMovingQuickInput = false;
+            const mouseMoveListener = addDisposableGenericMouseMoveListener(activeWindow, (e) => {
+                const mouseMoveEvent = ( new StandardMouseEvent(activeWindow, e));
+                mouseMoveEvent.preventDefault();
+                if (!isMovingQuickInput) {
+                    isMovingQuickInput = true;
+                }
+                this._layout(e.clientY - dragOffsetY, e.clientX - dragOffsetX);
+            });
+            const mouseUpListener = addDisposableGenericMouseUpListener(activeWindow, (e) => {
+                if (isMovingQuickInput) {
+                    const state = this.dndViewState.get();
+                    this.dndViewState.set({ top: state?.top, left: state?.left, done: true }, undefined);
+                }
+                mouseMoveListener.dispose();
+                mouseUpListener.dispose();
+            });
+        }));
+    }
+    _layout(topCoordinate, leftCoordinate) {
+        const snapCoordinateYTop = this._getTopSnapValue();
+        const snapCoordinateY = this._getCenterYSnapValue();
+        const snapCoordinateX = this._getCenterXSnapValue();
+        topCoordinate = Math.max(0, Math.min(topCoordinate, this._container.clientHeight - this._quickInputContainer.clientHeight));
+        if (topCoordinate < this._layoutService.activeContainerOffset.top) {
+            if (this._controlsOnLeft) {
+                leftCoordinate = Math.max(leftCoordinate, 80 / getZoomFactor(getActiveWindow()));
+            }
+            else if (this._controlsOnRight) {
+                leftCoordinate = Math.min(leftCoordinate, this._container.clientWidth - this._quickInputContainer.clientWidth - (140 / getZoomFactor(getActiveWindow())));
+            }
+        }
+        const snappingToTop = Math.abs(topCoordinate - snapCoordinateYTop) < this._snapThreshold;
+        topCoordinate = snappingToTop ? snapCoordinateYTop : topCoordinate;
+        const snappingToCenter = Math.abs(topCoordinate - snapCoordinateY) < this._snapThreshold;
+        topCoordinate = snappingToCenter ? snapCoordinateY : topCoordinate;
+        const top = topCoordinate / this._container.clientHeight;
+        leftCoordinate = Math.max(0, Math.min(leftCoordinate, this._container.clientWidth - this._quickInputContainer.clientWidth));
+        const snappingToCenterX = Math.abs(leftCoordinate - snapCoordinateX) < this._snapThreshold;
+        leftCoordinate = snappingToCenterX ? snapCoordinateX : leftCoordinate;
+        const b = this._container.clientWidth;
+        const c = this._quickInputContainer.clientWidth;
+        const d = leftCoordinate;
+        const left = (d + c / 2) / b;
+        this.dndViewState.set({ top, left, done: false }, undefined);
+        if (snappingToCenterX) {
+            if (snappingToTop) {
+                this._quickInputAlignmentContext.set('top');
+                return;
+            }
+            else if (snappingToCenter) {
+                this._quickInputAlignmentContext.set('center');
+                return;
+            }
+        }
+        this._quickInputAlignmentContext.set(undefined);
+    }
+    _getTopSnapValue() {
+        return this._layoutService.activeContainerOffset.quickPickTop;
+    }
+    _getCenterYSnapValue() {
+        return Math.round(this._container.clientHeight * this._snapLineHorizontalRatio);
+    }
+    _getCenterXSnapValue() {
+        return Math.round(this._container.clientWidth / 2) - Math.round(this._quickInputContainer.clientWidth / 2);
+    }
+};
+QuickInputDragAndDropController = ( __decorate([
+    ( __param(4, ILayoutService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IConfigurationService))
+], QuickInputDragAndDropController));
 
 export { QuickInputController };

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

@@ -54,6 +54,10 @@ export declare class QuickInputService extends Themable implements IQuickInputSe
     accept(keyMods?: IKeyMods): Promise<void>;
     back(): Promise<void>;
     cancel(): Promise<void>;
+    setAlignment(alignment: "top" | "center" | {
+        top: number;
+        left: number;
+    }): void;
     updateStyles(): void;
     private computeStyles;
 }

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

@@ -154,6 +154,9 @@ let QuickInputService = class QuickInputService extends Themable {
     cancel() {
         return this.controller.cancel();
     }
+    setAlignment(alignment) {
+        this.controller.setAlignment(alignment);
+    }
     updateStyles() {
         if (this.hasController) {
             this.controller.applyStyles(this.computeStyles());

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

@@ -189,7 +189,7 @@ class QuickInputItemDelegate {
 }
 class QuickInputAccessibilityProvider {
     getWidgetAriaLabel() {
-        return localize(1852, "Quick Input");
+        return localize(1889, "Quick Input");
     }
     getAriaLabel(element) {
         return element.separator?.label

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

@@ -58,7 +58,7 @@ function renderQuickInputDescription(description, container, actionHandler) {
             let title = node.title;
             if (!title && node.href.startsWith('command:')) {
                 title = ( localize(
-                    1853,
+                    1890,
                     "Click to execute command '{0}'",
                     node.href.substring('command:'.length)
                 ));

package/vscode/src/vs/platform/quickinput/common/quickInput.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 import { IMatch } from "../../../base/common/filters.js";
-import { IItemAccessor } from "@codingame/monaco-vscode-219d9a5f-b446-507b-a188-1178a0867c75-common/vscode/vs/base/common/fuzzyScorer";
+import { IItemAccessor } from "@codingame/monaco-vscode-d0fb86d3-2a47-594e-955b-9a24631a7124-common/vscode/vs/base/common/fuzzyScorer";
 import { ResolvedKeybinding } from "../../../base/common/keybindings.js";
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import Severity from "../../../base/common/severity.js";
@@ -162,6 +162,7 @@ export interface IQuickPick<T extends IQuickPickItem, O extends {
     readonly onDidAccept: Event<IQuickPickDidAcceptEvent>;
     canAcceptInBackground: boolean;
     ok: boolean | "default";
+    okLabel: string | undefined;
     readonly onDidCustom: Event<void>;
     customButton: boolean;
     customLabel: string | undefined;

package/vscode/src/vs/platform/quickinput/common/quickInput.service.d.ts

@@ -36,4 +36,8 @@ export interface IQuickInputService {
     accept(keyMods?: IKeyMods): Promise<void>;
     cancel(): Promise<void>;
     currentQuickInput: IQuickInput | undefined;
+    setAlignment(alignment: "top" | "center" | {
+        top: number;
+        left: number;
+    }): void;
 }

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

@@ -1,7 +1,6 @@
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { IRequestContext, IRequestOptions } from "@codingame/monaco-vscode-039b5553-0838-562a-97c2-30d6e54a7b42-common/vscode/vs/base/parts/request/common/request";
-import { ConfigurationScope } from "../../configuration/common/configurationRegistry.js";
 import { ILogService } from "../../log/common/log.service.js";
 import { IRequestService } from "./request.service.js";
 export interface AuthInfo {
@@ -33,4 +32,5 @@ export declare function hasNoContent(context: IRequestContext): boolean;
 export declare function asText(context: IRequestContext): Promise<string | null>;
 export declare function asTextOrError(context: IRequestContext): Promise<string | null>;
 export declare function asJson<T = {}>(context: IRequestContext): Promise<T | null>;
-export declare function updateProxyConfigurationsScope(scope: ConfigurationScope): void;
+export declare function updateProxyConfigurationsScope(useHostProxy: boolean, useHostProxyDefault: boolean): void;
+export declare const USER_LOCAL_AND_REMOTE_SETTINGS: string[];