@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -0,0 +1,51 @@
+import { isWeb, isMacintosh, isLinux, isWindows, isIOS, isMobile } from '../../../base/common/platform.js';
+import { localizeWithPath } from '../../../nls.js';
+import { RawContextKey } from './contextkey.js';
+const IsMacContext = ( new RawContextKey('isMac', isMacintosh, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isMac',
+ "Whether the operating system is macOS"
+))));
+const IsLinuxContext = ( new RawContextKey('isLinux', isLinux, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isLinux',
+ "Whether the operating system is Linux"
+))));
+const IsWindowsContext = ( new RawContextKey('isWindows', isWindows, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isWindows',
+ "Whether the operating system is Windows"
+))));
+const IsWebContext = ( new RawContextKey('isWeb', isWeb, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isWeb',
+ "Whether the platform is a web browser"
+))));
+const IsMacNativeContext = ( new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isMacNative',
+ "Whether the operating system is macOS on a non-browser platform"
+))));
+const IsIOSContext = ( new RawContextKey('isIOS', isIOS, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isIOS',
+ "Whether the operating system is iOS"
+))));
+const IsMobileContext = ( new RawContextKey('isMobile', isMobile, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'isMobile',
+ "Whether the platform is a mobile web browser"
+))));
+const IsDevelopmentContext = ( new RawContextKey('isDevelopment', false, true));
+const ProductQualityContext = ( new RawContextKey('productQualityType', '', ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'productQualityType',
+ "Quality type of VS Code"
+))));
+const InputFocusedContextKey = 'inputFocus';
+const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localizeWithPath(
+ 'vs/platform/contextkey/common/contextkeys',
+ 'inputFocus',
+ "Whether keyboard focus is inside an input box"
+))));
+export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -0,0 +1,284 @@
+import { illegalState } from '../../../base/common/errors.js';
+import { localizeWithPath } from '../../../nls.js';
+function hintDidYouMean(...meant) {
+    switch (meant.length) {
+        case 1:
+            return ( localizeWithPath(
+                'vs/platform/contextkey/common/scanner',
+                'contextkey.scanner.hint.didYouMean1',
+                "Did you mean {0}?",
+                meant[0]
+            ));
+        case 2:
+            return ( localizeWithPath(
+                'vs/platform/contextkey/common/scanner',
+                'contextkey.scanner.hint.didYouMean2',
+                "Did you mean {0} or {1}?",
+                meant[0],
+                meant[1]
+            ));
+        case 3:
+            return ( localizeWithPath(
+                'vs/platform/contextkey/common/scanner',
+                'contextkey.scanner.hint.didYouMean3',
+                "Did you mean {0}, {1} or {2}?",
+                meant[0],
+                meant[1],
+                meant[2]
+            ));
+        default:
+            return undefined;
+    }
+}
+const hintDidYouForgetToOpenOrCloseQuote = ( localizeWithPath(
+    'vs/platform/contextkey/common/scanner',
+    'contextkey.scanner.hint.didYouForgetToOpenOrCloseQuote',
+    "Did you forget to open or close the quote?"
+));
+const hintDidYouForgetToEscapeSlash = ( localizeWithPath(
+    'vs/platform/contextkey/common/scanner',
+    'contextkey.scanner.hint.didYouForgetToEscapeSlash',
+    "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/\'."
+));
+class Scanner {
+    constructor() {
+        this._input = '';
+        this._start = 0;
+        this._current = 0;
+        this._tokens = [];
+        this._errors = [];
+        this.stringRe = /[a-zA-Z0-9_<>\-\./\\:\*\?\+\[\]\^,#@;"%\$\p{L}-]+/uy;
+    }
+    static getLexeme(token) {
+        switch (token.type) {
+            case 0 :
+                return '(';
+            case 1 :
+                return ')';
+            case 2 :
+                return '!';
+            case 3 :
+                return token.isTripleEq ? '===' : '==';
+            case 4 :
+                return token.isTripleEq ? '!==' : '!=';
+            case 5 :
+                return '<';
+            case 6 :
+                return '<=';
+            case 7 :
+                return '>=';
+            case 8 :
+                return '>=';
+            case 9 :
+                return '=~';
+            case 10 :
+                return token.lexeme;
+            case 11 :
+                return 'true';
+            case 12 :
+                return 'false';
+            case 13 :
+                return 'in';
+            case 14 :
+                return 'not';
+            case 15 :
+                return '&&';
+            case 16 :
+                return '||';
+            case 17 :
+                return token.lexeme;
+            case 18 :
+                return token.lexeme;
+            case 19 :
+                return token.lexeme;
+            case 20 :
+                return 'EOF';
+            default:
+                throw illegalState(`unhandled token type: ${JSON.stringify(token)}; have you forgotten to add a case?`);
+        }
+    }
+    static { this._regexFlags = ( new Set(( ['i', 'g', 's', 'm', 'y', 'u'].map(ch => ch.charCodeAt(0))))); }
+    static { this._keywords = ( new Map([
+        ['not', 14 ],
+        ['in', 13 ],
+        ['false', 12 ],
+        ['true', 11 ],
+    ])); }
+    get errors() {
+        return this._errors;
+    }
+    reset(value) {
+        this._input = value;
+        this._start = 0;
+        this._current = 0;
+        this._tokens = [];
+        this._errors = [];
+        return this;
+    }
+    scan() {
+        while (!this._isAtEnd()) {
+            this._start = this._current;
+            const ch = this._advance();
+            switch (ch) {
+                case 40 :
+                    this._addToken(0 );
+                    break;
+                case 41 :
+                    this._addToken(1 );
+                    break;
+                case 33 :
+                    if (this._match(61 )) {
+                        const isTripleEq = this._match(61 );
+                        this._tokens.push({ type: 4 , offset: this._start, isTripleEq });
+                    }
+                    else {
+                        this._addToken(2 );
+                    }
+                    break;
+                case 39 :
+                    this._quotedString();
+                    break;
+                case 47 :
+                    this._regex();
+                    break;
+                case 61 :
+                    if (this._match(61 )) {
+                        const isTripleEq = this._match(61 );
+                        this._tokens.push({ type: 3 , offset: this._start, isTripleEq });
+                    }
+                    else if (this._match(126 )) {
+                        this._addToken(9 );
+                    }
+                    else {
+                        this._error(hintDidYouMean('==', '=~'));
+                    }
+                    break;
+                case 60 :
+                    this._addToken(this._match(61 ) ? 6  : 5 );
+                    break;
+                case 62 :
+                    this._addToken(this._match(61 ) ? 8  : 7 );
+                    break;
+                case 38 :
+                    if (this._match(38 )) {
+                        this._addToken(15 );
+                    }
+                    else {
+                        this._error(hintDidYouMean('&&'));
+                    }
+                    break;
+                case 124 :
+                    if (this._match(124 )) {
+                        this._addToken(16 );
+                    }
+                    else {
+                        this._error(hintDidYouMean('||'));
+                    }
+                    break;
+                case 32 :
+                case 13 :
+                case 9 :
+                case 10 :
+                case 160 :
+                    break;
+                default:
+                    this._string();
+            }
+        }
+        this._start = this._current;
+        this._addToken(20 );
+        return Array.from(this._tokens);
+    }
+    _match(expected) {
+        if (this._isAtEnd()) {
+            return false;
+        }
+        if (this._input.charCodeAt(this._current) !== expected) {
+            return false;
+        }
+        this._current++;
+        return true;
+    }
+    _advance() {
+        return this._input.charCodeAt(this._current++);
+    }
+    _peek() {
+        return this._isAtEnd() ? 0  : this._input.charCodeAt(this._current);
+    }
+    _addToken(type) {
+        this._tokens.push({ type, offset: this._start });
+    }
+    _error(additional) {
+        const offset = this._start;
+        const lexeme = this._input.substring(this._start, this._current);
+        const errToken = { type: 19 , offset: this._start, lexeme };
+        this._errors.push({ offset, lexeme, additionalInfo: additional });
+        this._tokens.push(errToken);
+    }
+    _string() {
+        this.stringRe.lastIndex = this._start;
+        const match = this.stringRe.exec(this._input);
+        if (match) {
+            this._current = this._start + match[0].length;
+            const lexeme = this._input.substring(this._start, this._current);
+            const keyword = Scanner._keywords.get(lexeme);
+            if (keyword) {
+                this._addToken(keyword);
+            }
+            else {
+                this._tokens.push({ type: 17 , lexeme, offset: this._start });
+            }
+        }
+    }
+    _quotedString() {
+        while (this._peek() !== 39  && !this._isAtEnd()) {
+            this._advance();
+        }
+        if (this._isAtEnd()) {
+            this._error(hintDidYouForgetToOpenOrCloseQuote);
+            return;
+        }
+        this._advance();
+        this._tokens.push({ type: 18 , lexeme: this._input.substring(this._start + 1, this._current - 1), offset: this._start + 1 });
+    }
+    _regex() {
+        let p = this._current;
+        let inEscape = false;
+        let inCharacterClass = false;
+        while (true) {
+            if (p >= this._input.length) {
+                this._current = p;
+                this._error(hintDidYouForgetToEscapeSlash);
+                return;
+            }
+            const ch = this._input.charCodeAt(p);
+            if (inEscape) {
+                inEscape = false;
+            }
+            else if (ch === 47  && !inCharacterClass) {
+                p++;
+                break;
+            }
+            else if (ch === 91 ) {
+                inCharacterClass = true;
+            }
+            else if (ch === 92 ) {
+                inEscape = true;
+            }
+            else if (ch === 93 ) {
+                inCharacterClass = false;
+            }
+            p++;
+        }
+        while (p < this._input.length && ( Scanner._regexFlags.has(this._input.charCodeAt(p)))) {
+            p++;
+        }
+        this._current = p;
+        const lexeme = this._input.substring(this._start, this._current);
+        this._tokens.push({ type: 10 , lexeme, offset: this._start });
+    }
+    _isAtEnd() {
+        return this._current >= this._input.length;
+    }
+}
+export { Scanner };

package/vscode/src/vs/platform/contextview/browser/contextMenuHandler.js

@@ -0,0 +1,117 @@
+import { getActiveElement, $, addDisposableListener, EventType, getWindow, isAncestor } from '../../../base/browser/dom.js';
+import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
+import { Menu } from '../../../base/browser/ui/menu/menu.js';
+import { ActionRunner } from '../../../base/common/actions.js';
+import { isCancellationError } from '../../../base/common/errors.js';
+import { combinedDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { defaultMenuStyles } from '../../theme/browser/defaultStyles.js';
+class ContextMenuHandler {
+    constructor(contextViewService, telemetryService, notificationService, keybindingService) {
+        this.contextViewService = contextViewService;
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.keybindingService = keybindingService;
+        this.focusToReturn = null;
+        this.lastContainer = null;
+        this.block = null;
+        this.blockDisposable = null;
+        this.options = { blockMouse: true };
+    }
+    configure(options) {
+        this.options = options;
+    }
+    showContextMenu(delegate) {
+        const actions = delegate.getActions();
+        if (!actions.length) {
+            return;
+        }
+        this.focusToReturn = getActiveElement();
+        let menu;
+        const shadowRootElement = delegate.domForShadowRoot instanceof HTMLElement ? delegate.domForShadowRoot : undefined;
+        this.contextViewService.showContextView({
+            getAnchor: () => delegate.getAnchor(),
+            canRelayout: false,
+            anchorAlignment: delegate.anchorAlignment,
+            anchorAxisAlignment: delegate.anchorAxisAlignment,
+            render: (container) => {
+                this.lastContainer = container;
+                const className = delegate.getMenuClassName ? delegate.getMenuClassName() : '';
+                if (className) {
+                    container.className += ' ' + className;
+                }
+                if (this.options.blockMouse) {
+                    this.block = container.appendChild($('.context-view-block'));
+                    this.block.style.position = 'fixed';
+                    this.block.style.cursor = 'initial';
+                    this.block.style.left = '0';
+                    this.block.style.top = '0';
+                    this.block.style.width = '100%';
+                    this.block.style.height = '100%';
+                    this.block.style.zIndex = '-1';
+                    this.blockDisposable?.dispose();
+                    this.blockDisposable = addDisposableListener(this.block, EventType.MOUSE_DOWN, e => e.stopPropagation());
+                }
+                const menuDisposables = ( new DisposableStore());
+                const actionRunner = delegate.actionRunner || ( new ActionRunner());
+                actionRunner.onWillRun(evt => this.onActionRun(evt, !delegate.skipTelemetry), this, menuDisposables);
+                actionRunner.onDidRun(this.onDidActionRun, this, menuDisposables);
+                menu = ( new Menu(container, actions, {
+                    actionViewItemProvider: delegate.getActionViewItem,
+                    context: delegate.getActionsContext ? delegate.getActionsContext() : null,
+                    actionRunner,
+                    getKeyBinding: delegate.getKeyBinding ? delegate.getKeyBinding : action => this.keybindingService.lookupKeybinding(action.id)
+                }, defaultMenuStyles));
+                menu.onDidCancel(() => this.contextViewService.hideContextView(true), null, menuDisposables);
+                menu.onDidBlur(() => this.contextViewService.hideContextView(true), null, menuDisposables);
+                const targetWindow = getWindow(container);
+                menuDisposables.add(addDisposableListener(targetWindow, EventType.BLUR, () => this.contextViewService.hideContextView(true)));
+                menuDisposables.add(addDisposableListener(targetWindow, EventType.MOUSE_DOWN, (e) => {
+                    if (e.defaultPrevented) {
+                        return;
+                    }
+                    const event = ( new StandardMouseEvent(targetWindow, e));
+                    let element = event.target;
+                    if (event.rightButton) {
+                        return;
+                    }
+                    while (element) {
+                        if (element === container) {
+                            return;
+                        }
+                        element = element.parentElement;
+                    }
+                    this.contextViewService.hideContextView(true);
+                }));
+                return combinedDisposable(menuDisposables, menu);
+            },
+            focus: () => {
+                menu?.focus(!!delegate.autoSelectFirstItem);
+            },
+            onHide: (didCancel) => {
+                delegate.onHide?.(!!didCancel);
+                if (this.block) {
+                    this.block.remove();
+                    this.block = null;
+                }
+                this.blockDisposable?.dispose();
+                this.blockDisposable = null;
+                if (!!this.lastContainer && (getActiveElement() === this.lastContainer || isAncestor(getActiveElement(), this.lastContainer))) {
+                    this.focusToReturn?.focus();
+                }
+                this.lastContainer = null;
+            }
+        }, shadowRootElement, !!shadowRootElement);
+    }
+    onActionRun(e, logTelemetry) {
+        if (logTelemetry) {
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'contextMenu' });
+        }
+        this.contextViewService.hideContextView(false);
+    }
+    onDidActionRun(e) {
+        if (e.error && !isCancellationError(e.error)) {
+            this.notificationService.error(e.error);
+        }
+    }
+}
+export { ContextMenuHandler };

package/vscode/src/vs/platform/contextview/browser/contextMenuService.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ModifierKeyEmitter } from '../../../base/browser/dom.js';
+import { Separator } from '../../../base/common/actions.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { createAndFillInContextMenuActions } from '../../actions/browser/menuEntryActionViewItem.js';
+import { IMenuService, MenuId } from '../../actions/common/actions.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.js';
+import { INotificationService } from '../../notification/common/notification.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+import { ContextMenuHandler } from './contextMenuHandler.js';
+import { IContextViewService } from './contextView.js';
+let ContextMenuService = class ContextMenuService extends Disposable {
+    get contextMenuHandler() {
+        if (!this._contextMenuHandler) {
+            this._contextMenuHandler = ( new ContextMenuHandler(
+                this.contextViewService,
+                this.telemetryService,
+                this.notificationService,
+                this.keybindingService
+            ));
+        }
+        return this._contextMenuHandler;
+    }
+    constructor(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.contextViewService = contextViewService;
+        this.keybindingService = keybindingService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this._contextMenuHandler = undefined;
+        this._onDidShowContextMenu = this._store.add(( new Emitter()));
+        this.onDidShowContextMenu = this._onDidShowContextMenu.event;
+        this._onDidHideContextMenu = this._store.add(( new Emitter()));
+        this.onDidHideContextMenu = this._onDidHideContextMenu.event;
+    }
+    configure(options) {
+        this.contextMenuHandler.configure(options);
+    }
+    showContextMenu(delegate) {
+        delegate = ContextMenuMenuDelegate.transform(delegate, this.menuService, this.contextKeyService);
+        this.contextMenuHandler.showContextMenu({
+            ...delegate,
+            onHide: (didCancel) => {
+                delegate.onHide?.(didCancel);
+                this._onDidHideContextMenu.fire();
+            }
+        });
+        ModifierKeyEmitter.getInstance().resetKeyStatus();
+        this._onDidShowContextMenu.fire();
+    }
+};
+ContextMenuService = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, INotificationService)),
+    ( __param(2, IContextViewService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IMenuService)),
+    ( __param(5, IContextKeyService))
+], ContextMenuService));
+var ContextMenuMenuDelegate;
+( (function(ContextMenuMenuDelegate) {
+    function is(thing) {
+        return thing && thing.menuId instanceof MenuId;
+    }
+    function transform(delegate, menuService, globalContextKeyService) {
+        if (!is(delegate)) {
+            return delegate;
+        }
+        const { menuId, menuActionOptions, contextKeyService } = delegate;
+        return {
+            ...delegate,
+            getActions: () => {
+                const target = [];
+                if (menuId) {
+                    const menu = menuService.createMenu(menuId, contextKeyService ?? globalContextKeyService);
+                    createAndFillInContextMenuActions(menu, menuActionOptions, target);
+                    menu.dispose();
+                }
+                if (!delegate.getActions) {
+                    return target;
+                }
+                else {
+                    return Separator.join(delegate.getActions(), target);
+                }
+            }
+        };
+    }
+    ContextMenuMenuDelegate.transform = transform;
+})(ContextMenuMenuDelegate || (ContextMenuMenuDelegate = {})));
+export { ContextMenuMenuDelegate, ContextMenuService };

package/vscode/src/vs/platform/contextview/browser/contextView.js

@@ -0,0 +1,4 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const IContextViewService = ( createDecorator('contextViewService'));
+const IContextMenuService = ( createDecorator('contextMenuService'));
+export { IContextMenuService, IContextViewService };

package/vscode/src/vs/platform/contextview/browser/contextViewService.js

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ContextView } from '../../../base/browser/ui/contextview/contextview.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { getWindow } from '../../../base/browser/dom.js';
+let ContextViewService = class ContextViewService extends Disposable {
+    constructor(layoutService) {
+        super();
+        this.layoutService = layoutService;
+        this.currentViewDisposable = Disposable.None;
+        this.contextView = this._register(( new ContextView(this.layoutService.mainContainer, 1 )));
+        this.layout();
+        this._register(layoutService.onDidLayoutContainer(() => this.layout()));
+    }
+    showContextView(delegate, container, shadowRoot) {
+        let domPosition;
+        if (container) {
+            if (container === this.layoutService.getContainer(getWindow(container))) {
+                domPosition = 1 ;
+            }
+            else if (shadowRoot) {
+                domPosition = 3 ;
+            }
+            else {
+                domPosition = 2 ;
+            }
+        }
+        else {
+            domPosition = 1 ;
+        }
+        this.contextView.setContainer(container ?? this.layoutService.activeContainer, domPosition);
+        this.contextView.show(delegate);
+        const disposable = toDisposable(() => {
+            if (this.currentViewDisposable === disposable) {
+                this.hideContextView();
+            }
+        });
+        this.currentViewDisposable = disposable;
+        return disposable;
+    }
+    getContextViewElement() {
+        return this.contextView.getViewElement();
+    }
+    layout() {
+        this.contextView.layout();
+    }
+    hideContextView(data) {
+        this.contextView.hide(data);
+    }
+    dispose() {
+        super.dispose();
+        this.currentViewDisposable.dispose();
+        this.currentViewDisposable = Disposable.None;
+    }
+};
+ContextViewService = ( __decorate([
+    ( __param(0, ILayoutService))
+], ContextViewService));
+export { ContextViewService };

package/vscode/src/vs/platform/debug/common/extensionHostDebug.js

@@ -1,3 +1,3 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IExtensionHostDebugService = ( createDecorator('extensionHostDebugService'));
 export { IExtensionHostDebugService };

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

@@ -1,4 +1,4 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const ID = 'diagnosticsService';
 const IDiagnosticsService = ( createDecorator(ID));
 class NullDiagnosticsService {

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

@@ -1,7 +1,7 @@
-import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { basename } from '../../../base/common/resources.js';
+import Severity from '../../../base/common/severity.js';
+import { localizeWithPath } from '../../../nls.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IDialogService = ( createDecorator('dialogService'));
 var DialogKind;
 ( (function(DialogKind) {