@codingame/monaco-vscode-api 3.0.0 → 3.1.1

package/vscode/src/vs/workbench/browser/actions/media/actions.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .quick-input-list .quick-input-list-entry.has-actions:hover .quick-input-list-entry-action-bar .action-label.dirty-workspace:before{content:\"\\ea76\"}.monaco-workbench .screencast-mouse{border-radius:50%;border-style:solid;border-width:2px;content:\" \";display:none;pointer-events:none;position:absolute;z-index:100000}.monaco-workbench .screencast-keyboard{background-color:rgba(0,0,0,.5);color:#eee;left:0;line-height:1.75em;overflow:hidden;pointer-events:none;position:absolute;text-align:center;text-overflow:ellipsis;white-space:nowrap;width:100%;z-index:100000}.monaco-workbench:not(.reduce-motion) .screencast-keyboard{transition:opacity .3s ease-out}.monaco-workbench .screencast-keyboard:empty{opacity:0}.monaco-workbench .screencast-keyboard>.key{background-color:hsla(0,0%,100%,.05);border:1px solid hsla(0,0%,80%,.4);border-radius:5px;box-shadow:inset 0 -3px 0 hsla(0,0%,73%,.4);margin-right:6px;padding:0 8px}.monaco-workbench .screencast-keyboard>.title{font-weight:600}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/browser/actions/navigationActions.js

@@ -0,0 +1,300 @@
+import { localize2WithPath } from '../../../nls.js';
+import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
+import { IWorkbenchLayoutService } from '../../services/layout/browser/layoutService.js';
+import { registerAction2, Action2 } from '../../../platform/actions/common/actions.js';
+import { Categories } from '../../../platform/action/common/actionCommonCategories.js';
+import { IEditorService } from '../../services/editor/common/editorService.js';
+import { IPaneCompositePartService } from '../../services/panecomposite/browser/panecomposite.js';
+import { getActiveWindow } from '../../../base/browser/dom.js';
+import { isAuxiliaryWindow } from '../../../base/browser/window.js';
+class BaseNavigationAction extends Action2 {
+    constructor(options, direction) {
+        super(options);
+        this.direction = direction;
+    }
+    run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const isEditorFocus = layoutService.hasFocus("workbench.parts.editor" );
+        const isPanelFocus = layoutService.hasFocus("workbench.parts.panel" );
+        const isSidebarFocus = layoutService.hasFocus("workbench.parts.sidebar" );
+        const isAuxiliaryBarFocus = layoutService.hasFocus("workbench.parts.auxiliarybar" );
+        let neighborPart;
+        if (isEditorFocus) {
+            const didNavigate = this.navigateAcrossEditorGroup(this.toGroupDirection(this.direction), editorGroupService);
+            if (didNavigate) {
+                return;
+            }
+            neighborPart = layoutService.getVisibleNeighborPart("workbench.parts.editor" , this.direction);
+        }
+        if (isPanelFocus) {
+            neighborPart = layoutService.getVisibleNeighborPart("workbench.parts.panel" , this.direction);
+        }
+        if (isSidebarFocus) {
+            neighborPart = layoutService.getVisibleNeighborPart("workbench.parts.sidebar" , this.direction);
+        }
+        if (isAuxiliaryBarFocus) {
+            neighborPart = neighborPart = layoutService.getVisibleNeighborPart("workbench.parts.auxiliarybar" , this.direction);
+        }
+        if (neighborPart === "workbench.parts.editor" ) {
+            if (!this.navigateBackToEditorGroup(this.toGroupDirection(this.direction), editorGroupService)) {
+                this.navigateToEditorGroup(this.direction === 3  ? 0  : 1 , editorGroupService);
+            }
+        }
+        else if (neighborPart === "workbench.parts.sidebar" ) {
+            this.navigateToSidebar(layoutService, paneCompositeService);
+        }
+        else if (neighborPart === "workbench.parts.panel" ) {
+            this.navigateToPanel(layoutService, paneCompositeService);
+        }
+        else if (neighborPart === "workbench.parts.auxiliarybar" ) {
+            this.navigateToAuxiliaryBar(layoutService, paneCompositeService);
+        }
+    }
+    async navigateToPanel(layoutService, paneCompositeService) {
+        if (!layoutService.isVisible("workbench.parts.panel" )) {
+            return false;
+        }
+        const activePanel = paneCompositeService.getActivePaneComposite(1 );
+        if (!activePanel) {
+            return false;
+        }
+        const activePanelId = activePanel.getId();
+        const res = await paneCompositeService.openPaneComposite(activePanelId, 1 , true);
+        if (!res) {
+            return false;
+        }
+        return res;
+    }
+    async navigateToSidebar(layoutService, paneCompositeService) {
+        if (!layoutService.isVisible("workbench.parts.sidebar" )) {
+            return false;
+        }
+        const activeViewlet = paneCompositeService.getActivePaneComposite(0 );
+        if (!activeViewlet) {
+            return false;
+        }
+        const activeViewletId = activeViewlet.getId();
+        const viewlet = await paneCompositeService.openPaneComposite(activeViewletId, 0 , true);
+        return !!viewlet;
+    }
+    async navigateToAuxiliaryBar(layoutService, paneCompositeService) {
+        if (!layoutService.isVisible("workbench.parts.auxiliarybar" )) {
+            return false;
+        }
+        const activePanel = paneCompositeService.getActivePaneComposite(2 );
+        if (!activePanel) {
+            return false;
+        }
+        const activePanelId = activePanel.getId();
+        const res = await paneCompositeService.openPaneComposite(activePanelId, 2 , true);
+        if (!res) {
+            return false;
+        }
+        return res;
+    }
+    navigateAcrossEditorGroup(direction, editorGroupService) {
+        return this.doNavigateToEditorGroup({ direction }, editorGroupService);
+    }
+    navigateToEditorGroup(location, editorGroupService) {
+        return this.doNavigateToEditorGroup({ location }, editorGroupService);
+    }
+    navigateBackToEditorGroup(direction, editorGroupService) {
+        if (!editorGroupService.activeGroup) {
+            return false;
+        }
+        const oppositeDirection = this.toOppositeDirection(direction);
+        const groupInBetween = editorGroupService.findGroup({ direction: oppositeDirection }, editorGroupService.activeGroup);
+        if (!groupInBetween) {
+            editorGroupService.activeGroup.focus();
+            return true;
+        }
+        return false;
+    }
+    toGroupDirection(direction) {
+        switch (direction) {
+            case 1 : return 1 ;
+            case 2 : return 2 ;
+            case 3 : return 3 ;
+            case 0 : return 0 ;
+        }
+    }
+    toOppositeDirection(direction) {
+        switch (direction) {
+            case 0 : return 1 ;
+            case 3 : return 2 ;
+            case 2 : return 3 ;
+            case 1 : return 0 ;
+        }
+    }
+    doNavigateToEditorGroup(scope, editorGroupService) {
+        const targetGroup = editorGroupService.findGroup(scope, editorGroupService.activeGroup);
+        if (targetGroup) {
+            targetGroup.focus();
+            return true;
+        }
+        return false;
+    }
+}
+registerAction2(class extends BaseNavigationAction {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateLeft',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'navigateLeft',
+                'Navigate to the View on the Left'
+            )),
+            category: Categories.View,
+            f1: true
+        }, 2 );
+    }
+});
+registerAction2(class extends BaseNavigationAction {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateRight',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'navigateRight',
+                'Navigate to the View on the Right'
+            )),
+            category: Categories.View,
+            f1: true
+        }, 3 );
+    }
+});
+registerAction2(class extends BaseNavigationAction {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateUp',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'navigateUp',
+                'Navigate to the View Above'
+            )),
+            category: Categories.View,
+            f1: true
+        }, 0 );
+    }
+});
+registerAction2(class extends BaseNavigationAction {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateDown',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'navigateDown',
+                'Navigate to the View Below'
+            )),
+            category: Categories.View,
+            f1: true
+        }, 1 );
+    }
+});
+class BaseFocusAction extends Action2 {
+    constructor(options, focusNext) {
+        super(options);
+        this.focusNext = focusNext;
+    }
+    run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        const editorService = accessor.get(IEditorService);
+        this.focusNextOrPreviousPart(layoutService, editorService, this.focusNext);
+    }
+    findVisibleNeighbour(layoutService, part, next) {
+        const activeWindow = getActiveWindow();
+        const windowIsAuxiliary = isAuxiliaryWindow(activeWindow);
+        let neighbour;
+        if (windowIsAuxiliary) {
+            switch (part) {
+                case "workbench.parts.editor" :
+                    neighbour = "workbench.parts.statusbar" ;
+                    break;
+                default:
+                    neighbour = "workbench.parts.editor" ;
+            }
+        }
+        else {
+            switch (part) {
+                case "workbench.parts.editor" :
+                    neighbour = next ? "workbench.parts.panel"  : "workbench.parts.sidebar" ;
+                    break;
+                case "workbench.parts.panel" :
+                    neighbour = next ? "workbench.parts.statusbar"  : "workbench.parts.editor" ;
+                    break;
+                case "workbench.parts.statusbar" :
+                    neighbour = next ? "workbench.parts.activitybar"  : "workbench.parts.panel" ;
+                    break;
+                case "workbench.parts.activitybar" :
+                    neighbour = next ? "workbench.parts.sidebar"  : "workbench.parts.statusbar" ;
+                    break;
+                case "workbench.parts.sidebar" :
+                    neighbour = next ? "workbench.parts.editor"  : "workbench.parts.activitybar" ;
+                    break;
+                default:
+                    neighbour = "workbench.parts.editor" ;
+            }
+        }
+        if (layoutService.isVisible(neighbour, activeWindow) || neighbour === "workbench.parts.editor" ) {
+            return neighbour;
+        }
+        return this.findVisibleNeighbour(layoutService, neighbour, next);
+    }
+    focusNextOrPreviousPart(layoutService, editorService, next) {
+        let currentlyFocusedPart;
+        if (editorService.activeEditorPane?.hasFocus() || layoutService.hasFocus("workbench.parts.editor" )) {
+            currentlyFocusedPart = "workbench.parts.editor" ;
+        }
+        else if (layoutService.hasFocus("workbench.parts.activitybar" )) {
+            currentlyFocusedPart = "workbench.parts.activitybar" ;
+        }
+        else if (layoutService.hasFocus("workbench.parts.statusbar" )) {
+            currentlyFocusedPart = "workbench.parts.statusbar" ;
+        }
+        else if (layoutService.hasFocus("workbench.parts.sidebar" )) {
+            currentlyFocusedPart = "workbench.parts.sidebar" ;
+        }
+        else if (layoutService.hasFocus("workbench.parts.panel" )) {
+            currentlyFocusedPart = "workbench.parts.panel" ;
+        }
+        layoutService.focusPart(currentlyFocusedPart ? this.findVisibleNeighbour(layoutService, currentlyFocusedPart, next) : "workbench.parts.editor" , getActiveWindow());
+    }
+}
+registerAction2(class extends BaseFocusAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusNextPart',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'focusNextPart',
+                'Focus Next Part'
+            )),
+            category: Categories.View,
+            f1: true,
+            keybinding: {
+                primary: 64 ,
+                weight: 200
+            }
+        }, true);
+    }
+});
+registerAction2(class extends BaseFocusAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusPreviousPart',
+            title: ( localize2WithPath(
+                'vs/workbench/browser/actions/navigationActions',
+                'focusPreviousPart',
+                'Focus Previous Part'
+            )),
+            category: Categories.View,
+            f1: true,
+            keybinding: {
+                primary: 1024  | 64 ,
+                weight: 200
+            }
+        }, false);
+    }
+});

package/vscode/src/vs/workbench/browser/actions/textInputActions.js

@@ -0,0 +1,83 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Action, Separator } from '../../../base/common/actions.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IWorkbenchLayoutService } from '../../services/layout/browser/layoutService.js';
+import { IContextMenuService } from '../../../platform/contextview/browser/contextView.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { getActiveDocument, addDisposableListener, EventHelper, getWindow } from '../../../base/browser/dom.js';
+import { registerWorkbenchContribution2 } from '../../common/contributions.js';
+import { isNative } from '../../../base/common/platform.js';
+import { IClipboardService } from '../../../platform/clipboard/common/clipboardService.js';
+import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
+import { Event as Event$1 } from '../../../base/common/event.js';
+import { Lazy } from '../../../base/common/lazy.js';
+let TextInputActionsProvider = class TextInputActionsProvider extends Disposable {
+    static { this.ID = 'workbench.contrib.textInputActionsProvider'; }
+    constructor(layoutService, contextMenuService, clipboardService) {
+        super();
+        this.layoutService = layoutService;
+        this.contextMenuService = contextMenuService;
+        this.clipboardService = clipboardService;
+        this.textInputActions = ( new Lazy(() => this.createActions()));
+        this.registerListeners();
+    }
+    createActions() {
+        return [
+            (
+            new Action('undo', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'undo', "Undo")), undefined, true, async () => getActiveDocument().execCommand('undo'))),
+            ( new Action('redo', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'redo', "Redo")), undefined, true, async () => getActiveDocument().execCommand('redo'))),
+            ( new Separator()),
+            (
+            new Action('editor.action.clipboardCutAction', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'cut', "Cut")), undefined, true, async () => getActiveDocument().execCommand('cut'))),
+            ( new Action('editor.action.clipboardCopyAction', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'copy', "Copy")), undefined, true, async () => getActiveDocument().execCommand('copy'))),
+            ( new Action('editor.action.clipboardPasteAction', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'paste', "Paste")), undefined, true, async (element) => {
+                if (isNative) {
+                    getActiveDocument().execCommand('paste');
+                }
+                else {
+                    const clipboardText = await this.clipboardService.readText();
+                    if (element instanceof HTMLTextAreaElement ||
+                        element instanceof HTMLInputElement) {
+                        const selectionStart = element.selectionStart || 0;
+                        const selectionEnd = element.selectionEnd || 0;
+                        element.value = `${element.value.substring(0, selectionStart)}${clipboardText}${element.value.substring(selectionEnd, element.value.length)}`;
+                        element.selectionStart = selectionStart + clipboardText.length;
+                        element.selectionEnd = element.selectionStart;
+                        element.dispatchEvent(( new Event('input', { bubbles: true, cancelable: true })));
+                    }
+                }
+            })),
+            ( new Separator()),
+            (
+            new Action('editor.action.selectAll', ( localizeWithPath('vs/workbench/browser/actions/textInputActions', 'selectAll', "Select All")), undefined, true, async () => getActiveDocument().execCommand('selectAll')))
+        ];
+    }
+    registerListeners() {
+        this._register(Event$1.runAndSubscribe(this.layoutService.onDidAddContainer, ({ container, disposables }) => {
+            disposables.add(addDisposableListener(container, 'contextmenu', e => this.onContextMenu(getWindow(container), e)));
+        }, { container: this.layoutService.mainContainer, disposables: this._store }));
+    }
+    onContextMenu(targetWindow, e) {
+        if (e.defaultPrevented) {
+            return;
+        }
+        const target = e.target;
+        if (!(target instanceof HTMLElement) || (target.nodeName.toLowerCase() !== 'input' && target.nodeName.toLowerCase() !== 'textarea')) {
+            return;
+        }
+        EventHelper.stop(e, true);
+        const event = ( new StandardMouseEvent(targetWindow, e));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => event,
+            getActions: () => this.textInputActions.value,
+            getActionsContext: () => target,
+        });
+    }
+};
+TextInputActionsProvider = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IClipboardService))
+], TextInputActionsProvider));
+registerWorkbenchContribution2(TextInputActionsProvider.ID, TextInputActionsProvider, 2 );
+export { TextInputActionsProvider };

package/vscode/src/vs/workbench/browser/dnd.js

@@ -4,7 +4,7 @@ import { onDidRegisterWindow, addDisposableListener, DragAndDropObserver, EventT
 import { coalesce } from '../../base/common/arrays.js';
 import { UriList } from '../../base/common/dataTransfer.js';
 import { Event, Emitter } from '../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, markAsSingleton } from '../../base/common/lifecycle.js';
 import { stringify } from '../../base/common/marshalling.js';
 import { Mimes } from '../../base/common/mime.js';
 import { Schemas, FileAccess } from '../../base/common/network.js';
@@ -286,6 +286,7 @@ class CompositeDragAndDropObserver extends Disposable {
     static get INSTANCE() {
         if (!CompositeDragAndDropObserver.instance) {
             CompositeDragAndDropObserver.instance = ( new CompositeDragAndDropObserver());
+            markAsSingleton(CompositeDragAndDropObserver.instance);
         }
         return CompositeDragAndDropObserver.instance;
     }