@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalCommands.js

@@ -1,22 +0,0 @@
-import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
-import { ITerminalGroupService } from './terminal.js';
-function setupTerminalCommands() {
-    registerOpenTerminalAtIndexCommands();
-}
-function registerOpenTerminalAtIndexCommands() {
-    for (let i = 0; i < 9; i++) {
-        const terminalIndex = i;
-        const visibleIndex = i + 1;
-        KeybindingsRegistry.registerCommandAndKeybindingRule({
-            id: `workbench.action.terminal.focusAtIndex${visibleIndex}`,
-            weight: 200 ,
-            when: undefined,
-            primary: 0,
-            handler: accessor => {
-                accessor.get(ITerminalGroupService).setActiveInstanceByIndex(terminalIndex);
-                return accessor.get(ITerminalGroupService).showPanel(true);
-            }
-        });
-    }
-}
-export { setupTerminalCommands };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalConfigHelper.js

@@ -1,215 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { TERMINAL_CONFIG_SECTION, DEFAULT_FONT_WEIGHT, DEFAULT_BOLD_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT } from '../common/terminal.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { NeverShowAgainScope, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { InstallRecommendedExtensionAction } from '../../extensions/browser/extensionsActions.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { isLinux, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-let TerminalConfigHelper = class TerminalConfigHelper extends Disposable {
-    get onConfigChanged() { return this._onConfigChanged.event; }
-    constructor(_configurationService, _extensionManagementService, _notificationService, _instantiationService, _productService) {
-        super();
-        this._configurationService = _configurationService;
-        this._extensionManagementService = _extensionManagementService;
-        this._notificationService = _notificationService;
-        this._instantiationService = _instantiationService;
-        this._productService = _productService;
-        this._linuxDistro = 1 ;
-        this._onConfigChanged = this._register(( new Emitter()));
-        this._recommendationsShown = false;
-        this._updateConfig();
-        this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(TERMINAL_CONFIG_SECTION)) {
-                this._updateConfig();
-            }
-        });
-        if (isLinux) {
-            if (navigator.userAgent.includes('Ubuntu')) {
-                this._linuxDistro = 3 ;
-            }
-            else if (navigator.userAgent.includes('Fedora')) {
-                this._linuxDistro = 2 ;
-            }
-        }
-    }
-    _updateConfig() {
-        const configValues = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
-        configValues.fontWeight = this._normalizeFontWeight(configValues.fontWeight, DEFAULT_FONT_WEIGHT);
-        configValues.fontWeightBold = this._normalizeFontWeight(configValues.fontWeightBold, DEFAULT_BOLD_FONT_WEIGHT);
-        this.config = configValues;
-        this._onConfigChanged.fire();
-    }
-    configFontIsMonospace() {
-        const fontSize = 15;
-        const fontFamily = this.config.fontFamily || this._configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily;
-        const iRect = this._getBoundingRectFor('i', fontFamily, fontSize);
-        const wRect = this._getBoundingRectFor('w', fontFamily, fontSize);
-        if (!iRect || !wRect || !iRect.width || !wRect.width) {
-            return true;
-        }
-        return iRect.width === wRect.width;
-    }
-    _createCharMeasureElementIfNecessary() {
-        if (!this.panelContainer) {
-            throw new Error('Cannot measure element when terminal is not attached');
-        }
-        if (!this._charMeasureElement || !this._charMeasureElement.parentElement) {
-            this._charMeasureElement = document.createElement('div');
-            this.panelContainer.appendChild(this._charMeasureElement);
-        }
-        return this._charMeasureElement;
-    }
-    _getBoundingRectFor(char, fontFamily, fontSize) {
-        let charMeasureElement;
-        try {
-            charMeasureElement = this._createCharMeasureElementIfNecessary();
-        }
-        catch {
-            return undefined;
-        }
-        const style = charMeasureElement.style;
-        style.display = 'inline-block';
-        style.fontFamily = fontFamily;
-        style.fontSize = fontSize + 'px';
-        style.lineHeight = 'normal';
-        charMeasureElement.innerText = char;
-        const rect = charMeasureElement.getBoundingClientRect();
-        style.display = 'none';
-        return rect;
-    }
-    _measureFont(fontFamily, fontSize, letterSpacing, lineHeight) {
-        const rect = this._getBoundingRectFor('X', fontFamily, fontSize);
-        if (this._lastFontMeasurement && (!rect || !rect.width || !rect.height)) {
-            return this._lastFontMeasurement;
-        }
-        this._lastFontMeasurement = {
-            fontFamily,
-            fontSize,
-            letterSpacing,
-            lineHeight,
-            charWidth: 0,
-            charHeight: 0
-        };
-        if (rect && rect.width && rect.height) {
-            this._lastFontMeasurement.charHeight = Math.ceil(rect.height);
-            if (this.config.gpuAcceleration === 'off') {
-                this._lastFontMeasurement.charWidth = rect.width;
-            }
-            else {
-                const deviceCharWidth = Math.floor(rect.width * window.devicePixelRatio);
-                const deviceCellWidth = deviceCharWidth + Math.round(letterSpacing);
-                const cssCellWidth = deviceCellWidth / window.devicePixelRatio;
-                this._lastFontMeasurement.charWidth = cssCellWidth - Math.round(letterSpacing) / window.devicePixelRatio;
-            }
-        }
-        return this._lastFontMeasurement;
-    }
-    getFont(xtermCore, excludeDimensions) {
-        const editorConfig = this._configurationService.getValue('editor');
-        let fontFamily = this.config.fontFamily || editorConfig.fontFamily || EDITOR_FONT_DEFAULTS.fontFamily;
-        let fontSize = this._clampInt(this.config.fontSize, 6 , 100 , EDITOR_FONT_DEFAULTS.fontSize);
-        if (!this.config.fontFamily) {
-            if (this._linuxDistro === 2 ) {
-                fontFamily = '\'DejaVu Sans Mono\'';
-            }
-            if (this._linuxDistro === 3 ) {
-                fontFamily = '\'Ubuntu Mono\'';
-                fontSize = this._clampInt(fontSize + 2, 6 , 100 , EDITOR_FONT_DEFAULTS.fontSize);
-            }
-        }
-        fontFamily += ', monospace';
-        const letterSpacing = this.config.letterSpacing ? Math.max(Math.floor(this.config.letterSpacing), MINIMUM_LETTER_SPACING) : DEFAULT_LETTER_SPACING;
-        const lineHeight = this.config.lineHeight ? Math.max(this.config.lineHeight, 1) : DEFAULT_LINE_HEIGHT;
-        if (excludeDimensions) {
-            return {
-                fontFamily,
-                fontSize,
-                letterSpacing,
-                lineHeight
-            };
-        }
-        if (xtermCore) {
-            if (xtermCore._renderService && xtermCore._renderService.dimensions?.css.cell.width && xtermCore._renderService.dimensions?.css.cell.height) {
-                return {
-                    fontFamily,
-                    fontSize,
-                    letterSpacing,
-                    lineHeight,
-                    charHeight: xtermCore._renderService.dimensions.css.cell.height / lineHeight,
-                    charWidth: xtermCore._renderService.dimensions.css.cell.width - Math.round(letterSpacing) / window.devicePixelRatio
-                };
-            }
-        }
-        return this._measureFont(fontFamily, fontSize, letterSpacing, lineHeight);
-    }
-    _clampInt(source, minimum, maximum, fallback) {
-        let r = parseInt(source, 10);
-        if (isNaN(r)) {
-            return fallback;
-        }
-        if (typeof minimum === 'number') {
-            r = Math.max(minimum, r);
-        }
-        if (typeof maximum === 'number') {
-            r = Math.min(maximum, r);
-        }
-        return r;
-    }
-    async showRecommendations(shellLaunchConfig) {
-        if (this._recommendationsShown) {
-            return;
-        }
-        this._recommendationsShown = true;
-        if (isWindows && shellLaunchConfig.executable && basename(shellLaunchConfig.executable).toLowerCase() === 'wsl.exe') {
-            const exeBasedExtensionTips = this._productService.exeBasedExtensionTips;
-            if (!exeBasedExtensionTips || !exeBasedExtensionTips.wsl) {
-                return;
-            }
-            const extId = ( Object.keys(exeBasedExtensionTips.wsl.recommendations)).find(extId => exeBasedExtensionTips.wsl.recommendations[extId].important);
-            if (extId && !(await this._isExtensionInstalled(extId))) {
-                this._notificationService.prompt(Severity.Info, ( nls.localize(
-                    'useWslExtension.title',
-                    "The '{0}' extension is recommended for opening a terminal in WSL.",
-                    exeBasedExtensionTips.wsl.friendlyName
-                )), [
-                    {
-                        label: ( nls.localize('install', 'Install')),
-                        run: () => {
-                            this._instantiationService.createInstance(InstallRecommendedExtensionAction, extId).run();
-                        }
-                    }
-                ], {
-                    sticky: true,
-                    neverShowAgain: { id: 'terminalConfigHelper/launchRecommendationsIgnore', scope: NeverShowAgainScope.APPLICATION },
-                    onCancel: () => { }
-                });
-            }
-        }
-    }
-    async _isExtensionInstalled(id) {
-        const extensions = await this._extensionManagementService.getInstalled();
-        return ( extensions.some(e => e.identifier.id === id));
-    }
-    _normalizeFontWeight(input, defaultWeight) {
-        if (input === 'normal' || input === 'bold') {
-            return input;
-        }
-        return this._clampInt(input, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, defaultWeight);
-    }
-};
-TerminalConfigHelper = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IProductService))
-], TerminalConfigHelper));
-export { TerminalConfigHelper };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalContextMenu.js

@@ -1,16 +0,0 @@
-import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
-import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-function openContextMenu(event, parent, menu, contextMenuService, extraActions) {
-    const standardEvent = ( new StandardMouseEvent(event));
-    const actions = [];
-    createAndFillInContextMenuActions(menu, undefined, actions);
-    if (extraActions) {
-        actions.push(...extraActions);
-    }
-    contextMenuService.showContextMenu({
-        getAnchor: () => standardEvent,
-        getActions: () => actions,
-        getActionsContext: () => parent,
-    });
-}
-export { openContextMenu };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEditor.js

@@ -1,186 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
-import { MenuId, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
-import { terminalEditorId, ITerminalEditorService, ITerminalService } from './terminal.js';
-import { getTerminalActionBarArgs } from './terminalMenus.js';
-import { ITerminalProfileResolverService, ITerminalProfileService } from '../common/terminal.js';
-import { isLinux, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { openContextMenu } from './terminalContextMenu.js';
-import { ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-let TerminalEditor = class TerminalEditor extends EditorPane {
-    constructor(telemetryService, themeService, storageService, _terminalEditorService, _terminalProfileResolverService, _terminalService, contextKeyService, menuService, _instantiationService, _contextMenuService, _notificationService, _terminalProfileService, _workbenchLayoutService) {
-        super(terminalEditorId, telemetryService, themeService, storageService);
-        this._terminalEditorService = _terminalEditorService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._terminalService = _terminalService;
-        this._instantiationService = _instantiationService;
-        this._contextMenuService = _contextMenuService;
-        this._notificationService = _notificationService;
-        this._terminalProfileService = _terminalProfileService;
-        this._workbenchLayoutService = _workbenchLayoutService;
-        this._editorInput = undefined;
-        this._cancelContextMenu = false;
-        this._dropdownMenu = this._register(menuService.createMenu(MenuId.TerminalNewDropdownContext, contextKeyService));
-        this._instanceMenu = this._register(menuService.createMenu(MenuId.TerminalInstanceContext, contextKeyService));
-    }
-    async setInput(newInput, options, context, token) {
-        this._editorInput?.terminalInstance?.detachFromElement();
-        this._editorInput = newInput;
-        await super.setInput(newInput, options, context, token);
-        this._editorInput.terminalInstance?.attachToElement(this._overflowGuardElement);
-        if (this._lastDimension) {
-            this.layout(this._lastDimension);
-        }
-        this._editorInput.terminalInstance?.setVisible(this.isVisible() && this._workbenchLayoutService.isVisible("workbench.parts.editor" ));
-        if (this._editorInput.terminalInstance) {
-            this._register(this._editorInput.terminalInstance.onDidFocus(() => this._setActiveInstance()));
-            this._editorInput.setCopyLaunchConfig(this._editorInput.terminalInstance.shellLaunchConfig);
-        }
-    }
-    clearInput() {
-        super.clearInput();
-        this._editorInput?.terminalInstance?.detachFromElement();
-        this._editorInput = undefined;
-    }
-    _setActiveInstance() {
-        if (!this._editorInput?.terminalInstance) {
-            return;
-        }
-        this._terminalEditorService.setActiveInstance(this._editorInput.terminalInstance);
-    }
-    focus() {
-        this._editorInput?.terminalInstance?.focus();
-    }
-    createEditor(parent) {
-        this._editorInstanceElement = parent;
-        this._overflowGuardElement = dom.$('.terminal-overflow-guard.terminal-editor');
-        this._editorInstanceElement.appendChild(this._overflowGuardElement);
-        this._registerListeners();
-    }
-    _registerListeners() {
-        if (!this._editorInstanceElement) {
-            return;
-        }
-        this._register(dom.addDisposableListener(this._editorInstanceElement, 'mousedown', async (event) => {
-            if (this._terminalEditorService.instances.length === 0) {
-                return;
-            }
-            if (event.which === 2 && isLinux) {
-                const terminal = this._terminalEditorService.activeInstance;
-                terminal?.focus();
-            }
-            else if (event.which === 3) {
-                const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
-                if (rightClickBehavior === 'nothing') {
-                    if (!event.shiftKey) {
-                        this._cancelContextMenu = true;
-                    }
-                    return;
-                }
-                else if (rightClickBehavior === 'copyPaste' || rightClickBehavior === 'paste') {
-                    const terminal = this._terminalEditorService.activeInstance;
-                    if (!terminal) {
-                        return;
-                    }
-                    if (rightClickBehavior === 'copyPaste' && event.shiftKey) {
-                        openContextMenu(event, this._editorInstanceElement, this._instanceMenu, this._contextMenuService);
-                        return;
-                    }
-                    if (rightClickBehavior === 'copyPaste' && terminal.hasSelection()) {
-                        await terminal.copySelection();
-                        terminal.clearSelection();
-                    }
-                    else {
-                        if (BrowserFeatures.clipboard.readText) {
-                            terminal.paste();
-                        }
-                        else {
-                            this._notificationService.info(`This browser doesn't support the clipboard.readText API needed to trigger a paste, try ${isMacintosh ? '⌘' : 'Ctrl'}+V instead.`);
-                        }
-                    }
-                    if (isMacintosh) {
-                        setTimeout(() => {
-                            terminal.clearSelection();
-                        }, 0);
-                    }
-                    this._cancelContextMenu = true;
-                }
-            }
-        }));
-        this._register(dom.addDisposableListener(this._editorInstanceElement, 'contextmenu', (event) => {
-            const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
-            if (rightClickBehavior === 'nothing' && !event.shiftKey) {
-                event.preventDefault();
-                event.stopImmediatePropagation();
-                this._cancelContextMenu = false;
-                return;
-            }
-            else if (!this._cancelContextMenu && rightClickBehavior !== 'copyPaste' && rightClickBehavior !== 'paste') {
-                if (!this._cancelContextMenu) {
-                    openContextMenu(event, this._editorInstanceElement, this._instanceMenu, this._contextMenuService);
-                }
-                event.preventDefault();
-                event.stopImmediatePropagation();
-                this._cancelContextMenu = false;
-            }
-        }));
-    }
-    layout(dimension) {
-        this._editorInput?.terminalInstance?.layout(dimension);
-        this._lastDimension = dimension;
-    }
-    setVisible(visible, group) {
-        super.setVisible(visible, group);
-        this._editorInput?.terminalInstance?.setVisible(visible && this._workbenchLayoutService.isVisible("workbench.parts.editor" ));
-    }
-    getActionViewItem(action) {
-        switch (action.id) {
-            case "workbench.action.createTerminalEditor" : {
-                if (action instanceof MenuItemAction) {
-                    const location = { viewColumn: ACTIVE_GROUP };
-                    const actions = getTerminalActionBarArgs(location, this._terminalProfileService.availableProfiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
-                    const button = this._instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, actions.dropdownAction, actions.dropdownMenuActions, actions.className, this._contextMenuService, {});
-                    return button;
-                }
-            }
-        }
-        return super.getActionViewItem(action);
-    }
-    _getDefaultProfileName() {
-        let defaultProfileName;
-        try {
-            defaultProfileName = this._terminalProfileService.getDefaultProfileName();
-        }
-        catch (e) {
-            defaultProfileName = this._terminalProfileResolverService.defaultProfileName;
-        }
-        return defaultProfileName;
-    }
-};
-TerminalEditor = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IThemeService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, ITerminalEditorService)),
-    ( __param(4, ITerminalProfileResolverService)),
-    ( __param(5, ITerminalService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IInstantiationService)),
-    ( __param(9, IContextMenuService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, ITerminalProfileService)),
-    ( __param(12, IWorkbenchLayoutService))
-], TerminalEditor));
-export { TerminalEditor };