monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/dragAndDropCommand.js

@@ -0,0 +1,65 @@
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class DragAndDropCommand {
+    constructor(selection, targetPosition, copy) {
+        this.selection = selection;
+        this.targetPosition = targetPosition;
+        this.copy = copy;
+        this.targetSelection = null;
+    }
+    getEditOperations(model, builder) {
+        const text = model.getValueInRange(this.selection);
+        if (!this.copy) {
+            builder.addEditOperation(this.selection, null);
+        }
+        builder.addEditOperation(new Range(this.targetPosition.lineNumber, this.targetPosition.column, this.targetPosition.lineNumber, this.targetPosition.column), text);
+        if (this.selection.containsPosition(this.targetPosition) && !(this.copy && (this.selection.getEndPosition().equals(this.targetPosition) || this.selection.getStartPosition().equals(this.targetPosition)) // we allow users to paste content beside the selection
+        )) {
+            this.targetSelection = this.selection;
+            return;
+        }
+        if (this.copy) {
+            this.targetSelection = new Selection(this.targetPosition.lineNumber, this.targetPosition.column, this.selection.endLineNumber - this.selection.startLineNumber + this.targetPosition.lineNumber, this.selection.startLineNumber === this.selection.endLineNumber ?
+                this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                this.selection.endColumn);
+            return;
+        }
+        if (this.targetPosition.lineNumber > this.selection.endLineNumber) {
+            // Drag the selection downwards
+            this.targetSelection = new Selection(this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber, this.targetPosition.column, this.targetPosition.lineNumber, this.selection.startLineNumber === this.selection.endLineNumber ?
+                this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                this.selection.endColumn);
+            return;
+        }
+        if (this.targetPosition.lineNumber < this.selection.endLineNumber) {
+            // Drag the selection upwards
+            this.targetSelection = new Selection(this.targetPosition.lineNumber, this.targetPosition.column, this.targetPosition.lineNumber + this.selection.endLineNumber - this.selection.startLineNumber, this.selection.startLineNumber === this.selection.endLineNumber ?
+                this.targetPosition.column + this.selection.endColumn - this.selection.startColumn :
+                this.selection.endColumn);
+            return;
+        }
+        // The target position is at the same line as the selection's end position.
+        if (this.selection.endColumn <= this.targetPosition.column) {
+            // The target position is after the selection's end position
+            this.targetSelection = new Selection(this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber, this.selection.startLineNumber === this.selection.endLineNumber ?
+                this.targetPosition.column - this.selection.endColumn + this.selection.startColumn :
+                this.targetPosition.column - this.selection.endColumn + this.selection.startColumn, this.targetPosition.lineNumber, this.selection.startLineNumber === this.selection.endLineNumber ?
+                this.targetPosition.column :
+                this.selection.endColumn);
+        }
+        else {
+            // The target position is before the selection's end position. Since the selection doesn't contain the target position, the selection is one-line and target position is before this selection.
+            this.targetSelection = new Selection(this.targetPosition.lineNumber - this.selection.endLineNumber + this.selection.startLineNumber, this.targetPosition.column, this.targetPosition.lineNumber, this.targetPosition.column + this.selection.endColumn - this.selection.startColumn);
+        }
+    }
+    computeCursorState(model, helper) {
+        return this.targetSelection;
+    }
+}
+
+export { DragAndDropCommand };

package/dist/workers/dragScrolling.js

@@ -0,0 +1,174 @@
+import { scheduleAtNextAnimationFrame, getWindow } from '../../../base/browser/dom.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { Position } from '../../common/core/position.js';
+import { createEditorPagePosition, PageCoordinates, createCoordinatesRelativeToEditor } from '../editorDom.js';
+import { MouseTarget } from './mouseTarget.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class DragScrolling extends Disposable {
+    constructor(_context, _viewHelper, _mouseTargetFactory, _dispatchMouse) {
+        super();
+        this._context = _context;
+        this._viewHelper = _viewHelper;
+        this._mouseTargetFactory = _mouseTargetFactory;
+        this._dispatchMouse = _dispatchMouse;
+        this._operation = null;
+    }
+    dispose() {
+        super.dispose();
+        this.stop();
+    }
+    start(position, mouseEvent) {
+        if (this._operation) {
+            this._operation.setPosition(position, mouseEvent);
+        }
+        else {
+            this._operation = this._createDragScrollingOperation(position, mouseEvent);
+        }
+    }
+    stop() {
+        if (this._operation) {
+            this._operation.dispose();
+            this._operation = null;
+        }
+    }
+}
+class DragScrollingOperation extends Disposable {
+    constructor(_context, _viewHelper, _mouseTargetFactory, _dispatchMouse, position, mouseEvent) {
+        super();
+        this._context = _context;
+        this._viewHelper = _viewHelper;
+        this._mouseTargetFactory = _mouseTargetFactory;
+        this._dispatchMouse = _dispatchMouse;
+        this._position = position;
+        this._mouseEvent = mouseEvent;
+        this._lastTime = Date.now();
+        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseEvent.browserEvent), () => this._execute());
+    }
+    dispose() {
+        this._animationFrameDisposable.dispose();
+        super.dispose();
+    }
+    setPosition(position, mouseEvent) {
+        this._position = position;
+        this._mouseEvent = mouseEvent;
+    }
+    /**
+     * update internal state and return elapsed ms since last time
+     */
+    _tick() {
+        const now = Date.now();
+        const elapsed = now - this._lastTime;
+        this._lastTime = now;
+        return elapsed;
+    }
+}
+class TopBottomDragScrolling extends DragScrolling {
+    _createDragScrollingOperation(position, mouseEvent) {
+        return new TopBottomDragScrollingOperation(this._context, this._viewHelper, this._mouseTargetFactory, this._dispatchMouse, position, mouseEvent);
+    }
+}
+class TopBottomDragScrollingOperation extends DragScrollingOperation {
+    /**
+     * get the number of lines per second to auto-scroll
+     */
+    _getScrollSpeed() {
+        const lineHeight = this._context.configuration.options.get(75 /* EditorOption.lineHeight */);
+        const viewportInLines = this._context.configuration.options.get(165 /* EditorOption.layoutInfo */).height / lineHeight;
+        const outsideDistanceInLines = this._position.outsideDistance / lineHeight;
+        if (outsideDistanceInLines <= 1.5) {
+            return Math.max(30, viewportInLines * (1 + outsideDistanceInLines));
+        }
+        if (outsideDistanceInLines <= 3) {
+            return Math.max(60, viewportInLines * (2 + outsideDistanceInLines));
+        }
+        return Math.max(200, viewportInLines * (7 + outsideDistanceInLines));
+    }
+    _execute() {
+        const lineHeight = this._context.configuration.options.get(75 /* EditorOption.lineHeight */);
+        const scrollSpeedInLines = this._getScrollSpeed();
+        const elapsed = this._tick();
+        const scrollInPixels = scrollSpeedInLines * (elapsed / 1000) * lineHeight;
+        const scrollValue = (this._position.outsidePosition === 'above' ? -scrollInPixels : scrollInPixels);
+        this._context.viewModel.viewLayout.deltaScrollNow(0, scrollValue);
+        this._viewHelper.renderNow();
+        const viewportData = this._context.viewLayout.getLinesViewportData();
+        const edgeLineNumber = (this._position.outsidePosition === 'above' ? viewportData.startLineNumber : viewportData.endLineNumber);
+        // First, try to find a position that matches the horizontal position of the mouse
+        let mouseTarget;
+        {
+            const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
+            const horizontalScrollbarHeight = this._context.configuration.options.get(165 /* EditorOption.layoutInfo */).horizontalScrollbarHeight;
+            const pos = new PageCoordinates(this._mouseEvent.pos.x, editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1);
+            const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
+            mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
+        }
+        if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber) {
+            if (this._position.outsidePosition === 'above') {
+                mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, new Position(edgeLineNumber, 1), 'above', this._position.outsideDistance);
+            }
+            else {
+                mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, new Position(edgeLineNumber, this._context.viewModel.getLineMaxColumn(edgeLineNumber)), 'below', this._position.outsideDistance);
+            }
+        }
+        this._dispatchMouse(mouseTarget, true, 2 /* NavigationCommandRevealType.None */);
+        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseTarget.element), () => this._execute());
+    }
+}
+class LeftRightDragScrolling extends DragScrolling {
+    _createDragScrollingOperation(position, mouseEvent) {
+        return new LeftRightDragScrollingOperation(this._context, this._viewHelper, this._mouseTargetFactory, this._dispatchMouse, position, mouseEvent);
+    }
+}
+class LeftRightDragScrollingOperation extends DragScrollingOperation {
+    /**
+     * get the number of cols per second to auto-scroll
+     */
+    _getScrollSpeed() {
+        const charWidth = this._context.configuration.options.get(59 /* EditorOption.fontInfo */).typicalFullwidthCharacterWidth;
+        const viewportInChars = this._context.configuration.options.get(165 /* EditorOption.layoutInfo */).contentWidth / charWidth;
+        const outsideDistanceInChars = this._position.outsideDistance / charWidth;
+        if (outsideDistanceInChars <= 1.5) {
+            return Math.max(30, viewportInChars * (1 + outsideDistanceInChars));
+        }
+        if (outsideDistanceInChars <= 3) {
+            return Math.max(60, viewportInChars * (2 + outsideDistanceInChars));
+        }
+        return Math.max(200, viewportInChars * (7 + outsideDistanceInChars));
+    }
+    _execute() {
+        const charWidth = this._context.configuration.options.get(59 /* EditorOption.fontInfo */).typicalFullwidthCharacterWidth;
+        const scrollSpeedInChars = this._getScrollSpeed();
+        const elapsed = this._tick();
+        const scrollInPixels = scrollSpeedInChars * (elapsed / 1000) * charWidth * 0.5;
+        const scrollValue = (this._position.outsidePosition === 'left' ? -scrollInPixels : scrollInPixels);
+        this._context.viewModel.viewLayout.deltaScrollNow(scrollValue, 0);
+        this._viewHelper.renderNow();
+        if (!this._position.position) {
+            return;
+        }
+        const edgeLineNumber = this._position.position.lineNumber;
+        // First, try to find a position that matches the horizontal position of the mouse
+        let mouseTarget;
+        {
+            const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
+            const horizontalScrollbarHeight = this._context.configuration.options.get(165 /* EditorOption.layoutInfo */).horizontalScrollbarHeight;
+            const pos = new PageCoordinates(this._mouseEvent.pos.x, editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1);
+            const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
+            mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
+        }
+        if (this._position.outsidePosition === 'left') {
+            mouseTarget = MouseTarget.createOutsideEditor(mouseTarget.mouseColumn, new Position(edgeLineNumber, mouseTarget.mouseColumn), 'left', this._position.outsideDistance);
+        }
+        else {
+            mouseTarget = MouseTarget.createOutsideEditor(mouseTarget.mouseColumn, new Position(edgeLineNumber, mouseTarget.mouseColumn), 'right', this._position.outsideDistance);
+        }
+        this._dispatchMouse(mouseTarget, true, 2 /* NavigationCommandRevealType.None */);
+        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseTarget.element), () => this._execute());
+    }
+}
+
+export { DragScrolling, DragScrollingOperation, LeftRightDragScrolling, LeftRightDragScrollingOperation, TopBottomDragScrolling, TopBottomDragScrollingOperation };

package/dist/workers/dropIntoEditorContribution.js

@@ -0,0 +1,41 @@
+import { registerEditorContribution, registerEditorCommand, EditorCommand } from '../../../browser/editorExtensions.js';
+import { registerEditorFeature } from '../../../common/editorFeatures.js';
+import { DefaultDropProvidersFeature } from './defaultProviders.js';
+import { DropIntoEditorController, dropWidgetVisibleCtx, changeDropTypeCommandId } from './dropIntoEditorController.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerEditorContribution(DropIntoEditorController.ID, DropIntoEditorController, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorFeature(DefaultDropProvidersFeature);
+registerEditorCommand(new class extends EditorCommand {
+    constructor() {
+        super({
+            id: changeDropTypeCommandId,
+            precondition: dropWidgetVisibleCtx,
+            kbOpts: {
+                weight: 100 /* KeybindingWeight.EditorContrib */,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, _args) {
+        DropIntoEditorController.get(editor)?.changeDropType();
+    }
+});
+registerEditorCommand(new class extends EditorCommand {
+    constructor() {
+        super({
+            id: 'editor.hideDropWidget',
+            precondition: dropWidgetVisibleCtx,
+            kbOpts: {
+                weight: 100 /* KeybindingWeight.EditorContrib */,
+                primary: 9 /* KeyCode.Escape */,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, _args) {
+        DropIntoEditorController.get(editor)?.clearWidgets();
+    }
+});

package/dist/workers/dropIntoEditorController.js

@@ -0,0 +1,173 @@
+import { coalesce } from '../../../../base/common/arrays.js';
+import { createCancelablePromise, raceCancellation } from '../../../../base/common/async.js';
+import { VSDataTransfer } from '../../../../base/common/dataTransfer.js';
+import { isCancellationError } from '../../../../base/common/errors.js';
+import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { localize } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { LocalSelectionTransfer } from '../../../../platform/dnd/browser/dnd.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { toExternalVSDataTransfer } from '../../../browser/dataTransfer.js';
+import { Range } from '../../../common/core/range.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { DraggedTreeItemsIdentifier } from '../../../common/services/treeViewsDnd.js';
+import { ITreeViewsDnDService } from '../../../common/services/treeViewsDndService.js';
+import { EditorStateCancellationTokenSource } from '../../editorState/browser/editorState.js';
+import { InlineProgressManager } from '../../inlineProgress/browser/inlineProgress.js';
+import { sortEditsByYieldTo } from './edit.js';
+import { PostEditWidgetManager } from './postEditWidget.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var DropIntoEditorController_1;
+const dropAsPreferenceConfig = 'editor.dropIntoEditor.preferences';
+const changeDropTypeCommandId = 'editor.changeDropType';
+const dropWidgetVisibleCtx = new RawContextKey('dropWidgetVisible', false, localize(934, "Whether the drop widget is showing"));
+let DropIntoEditorController = class DropIntoEditorController extends Disposable {
+    static { DropIntoEditorController_1 = this; }
+    static { this.ID = 'editor.contrib.dropIntoEditorController'; }
+    static get(editor) {
+        return editor.getContribution(DropIntoEditorController_1.ID);
+    }
+    constructor(editor, instantiationService, _configService, _languageFeaturesService, _treeViewsDragAndDropService) {
+        super();
+        this._configService = _configService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._treeViewsDragAndDropService = _treeViewsDragAndDropService;
+        this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
+        this._dropProgressManager = this._register(instantiationService.createInstance(InlineProgressManager, 'dropIntoEditor', editor));
+        this._postDropWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, 'dropIntoEditor', editor, dropWidgetVisibleCtx, { id: changeDropTypeCommandId, label: localize(935, "Show drop options...") }, () => DropIntoEditorController_1._configureDefaultAction ? [DropIntoEditorController_1._configureDefaultAction] : []));
+        this._register(editor.onDropIntoEditor(e => this.onDropIntoEditor(editor, e.position, e.event)));
+    }
+    clearWidgets() {
+        this._postDropWidgetManager.clear();
+    }
+    changeDropType() {
+        this._postDropWidgetManager.tryShowSelector();
+    }
+    async onDropIntoEditor(editor, position, dragEvent) {
+        if (!dragEvent.dataTransfer || !editor.hasModel()) {
+            return;
+        }
+        DropIntoEditorController_1._currentDropOperation?.cancel();
+        editor.focus();
+        editor.setPosition(position);
+        const p = createCancelablePromise(async (token) => {
+            const disposables = new DisposableStore();
+            const tokenSource = disposables.add(new EditorStateCancellationTokenSource(editor, 1 /* CodeEditorStateFlag.Value */, undefined, token));
+            try {
+                const ourDataTransfer = await this.extractDataTransferData(dragEvent);
+                if (ourDataTransfer.size === 0 || tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                const model = editor.getModel();
+                if (!model) {
+                    return;
+                }
+                const providers = this._languageFeaturesService.documentDropEditProvider
+                    .ordered(model)
+                    .filter(provider => {
+                    if (!provider.dropMimeTypes) {
+                        // Keep all providers that don't specify mime types
+                        return true;
+                    }
+                    return provider.dropMimeTypes.some(mime => ourDataTransfer.matches(mime));
+                });
+                const editSession = disposables.add(await this.getDropEdits(providers, model, position, ourDataTransfer, tokenSource.token));
+                if (tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                if (editSession.edits.length) {
+                    const activeEditIndex = this.getInitialActiveEditIndex(model, editSession.edits);
+                    const canShowWidget = editor.getOption(43 /* EditorOption.dropIntoEditor */).showDropSelector === 'afterDrop';
+                    // Pass in the parent token here as it tracks cancelling the entire drop operation
+                    await this._postDropWidgetManager.applyEditAndShowIfNeeded([Range.fromPositions(position)], { activeEditIndex, allEdits: editSession.edits }, canShowWidget, async (edit) => edit, token);
+                }
+            }
+            finally {
+                disposables.dispose();
+                if (DropIntoEditorController_1._currentDropOperation === p) {
+                    DropIntoEditorController_1._currentDropOperation = undefined;
+                }
+            }
+        });
+        this._dropProgressManager.showWhile(position, localize(936, "Running drop handlers. Click to cancel"), p, { cancel: () => p.cancel() });
+        DropIntoEditorController_1._currentDropOperation = p;
+    }
+    async getDropEdits(providers, model, position, dataTransfer, token) {
+        const disposables = new DisposableStore();
+        const results = await raceCancellation(Promise.all(providers.map(async (provider) => {
+            try {
+                const edits = await provider.provideDocumentDropEdits(model, position, dataTransfer, token);
+                if (edits) {
+                    disposables.add(edits);
+                }
+                return edits?.edits.map(edit => ({ ...edit, providerId: provider.id }));
+            }
+            catch (err) {
+                if (!isCancellationError(err)) {
+                    console.error(err);
+                }
+                console.error(err);
+            }
+            return undefined;
+        })), token);
+        const edits = coalesce(results ?? []).flat();
+        return {
+            edits: sortEditsByYieldTo(edits),
+            dispose: () => disposables.dispose()
+        };
+    }
+    getInitialActiveEditIndex(model, edits) {
+        const preferredProviders = this._configService.getValue(dropAsPreferenceConfig, { resource: model.uri });
+        for (const config of Array.isArray(preferredProviders) ? preferredProviders : []) {
+            const desiredKind = new HierarchicalKind(config);
+            const editIndex = edits.findIndex(edit => edit.kind && desiredKind.contains(edit.kind));
+            if (editIndex >= 0) {
+                return editIndex;
+            }
+        }
+        return 0;
+    }
+    async extractDataTransferData(dragEvent) {
+        if (!dragEvent.dataTransfer) {
+            return new VSDataTransfer();
+        }
+        const dataTransfer = toExternalVSDataTransfer(dragEvent.dataTransfer);
+        if (this.treeItemsTransfer.hasData(DraggedTreeItemsIdentifier.prototype)) {
+            const data = this.treeItemsTransfer.getData(DraggedTreeItemsIdentifier.prototype);
+            if (Array.isArray(data)) {
+                for (const id of data) {
+                    const treeDataTransfer = await this._treeViewsDragAndDropService.removeDragOperationTransfer(id.identifier);
+                    if (treeDataTransfer) {
+                        for (const [type, value] of treeDataTransfer) {
+                            dataTransfer.replace(type, value);
+                        }
+                    }
+                }
+            }
+        }
+        return dataTransfer;
+    }
+};
+DropIntoEditorController = DropIntoEditorController_1 = __decorate([
+    __param(1, IInstantiationService),
+    __param(2, IConfigurationService),
+    __param(3, ILanguageFeaturesService),
+    __param(4, ITreeViewsDnDService)
+], DropIntoEditorController);
+
+export { DropIntoEditorController, changeDropTypeCommandId, dropAsPreferenceConfig, dropWidgetVisibleCtx };

package/dist/workers/dropdown.js

@@ -0,0 +1,141 @@
+import { append, $, EventType, addDisposableListener, EventHelper, isMouseEvent } from '../../dom.js';
+import { StandardKeyboardEvent } from '../../keyboardEvent.js';
+import { EventType as EventType$1, Gesture } from '../../touch.js';
+import { ActionRunner } from '../../../common/actions.js';
+import { Emitter } from '../../../common/event.js';
+import './dropdown.css';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class BaseDropdown extends ActionRunner {
+    constructor(container, options) {
+        super();
+        this._onDidChangeVisibility = this._register(new Emitter());
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._element = append(container, $('.monaco-dropdown'));
+        this._label = append(this._element, $('.dropdown-label'));
+        let labelRenderer = options.labelRenderer;
+        if (!labelRenderer) {
+            labelRenderer = (container) => {
+                container.textContent = options.label || '';
+                return null;
+            };
+        }
+        for (const event of [EventType.CLICK, EventType.MOUSE_DOWN, EventType$1.Tap]) {
+            this._register(addDisposableListener(this.element, event, e => EventHelper.stop(e, true))); // prevent default click behaviour to trigger
+        }
+        for (const event of [EventType.MOUSE_DOWN, EventType$1.Tap]) {
+            this._register(addDisposableListener(this._label, event, e => {
+                if (isMouseEvent(e) && e.button !== 0) {
+                    // prevent right click trigger to allow separate context menu (https://github.com/microsoft/vscode/issues/151064)
+                    return;
+                }
+                if (this.visible) {
+                    this.hide();
+                }
+                else {
+                    this.show();
+                }
+            }));
+        }
+        this._register(addDisposableListener(this._label, EventType.KEY_DOWN, e => {
+            const event = new StandardKeyboardEvent(e);
+            if (event.equals(3 /* KeyCode.Enter */) || event.equals(10 /* KeyCode.Space */)) {
+                EventHelper.stop(e, true); // https://github.com/microsoft/vscode/issues/57997
+                if (this.visible) {
+                    this.hide();
+                }
+                else {
+                    this.show();
+                }
+            }
+        }));
+        const cleanupFn = labelRenderer(this._label);
+        if (cleanupFn) {
+            this._register(cleanupFn);
+        }
+        this._register(Gesture.addTarget(this._label));
+    }
+    get element() {
+        return this._element;
+    }
+    show() {
+        if (!this.visible) {
+            this.visible = true;
+            this._onDidChangeVisibility.fire(true);
+        }
+    }
+    hide() {
+        if (this.visible) {
+            this.visible = false;
+            this._onDidChangeVisibility.fire(false);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.hide();
+        if (this.boxContainer) {
+            this.boxContainer.remove();
+            this.boxContainer = undefined;
+        }
+        if (this.contents) {
+            this.contents.remove();
+            this.contents = undefined;
+        }
+        if (this._label) {
+            this._label.remove();
+            this._label = undefined;
+        }
+    }
+}
+class DropdownMenu extends BaseDropdown {
+    constructor(container, _options) {
+        super(container, _options);
+        this._options = _options;
+        this._actions = [];
+        this.actions = _options.actions || [];
+    }
+    set menuOptions(options) {
+        this._menuOptions = options;
+    }
+    get menuOptions() {
+        return this._menuOptions;
+    }
+    get actions() {
+        if (this._options.actionProvider) {
+            return this._options.actionProvider.getActions();
+        }
+        return this._actions;
+    }
+    set actions(actions) {
+        this._actions = actions;
+    }
+    show() {
+        super.show();
+        this.element.classList.add('active');
+        this._options.contextMenuProvider.showContextMenu({
+            getAnchor: () => this.element,
+            getActions: () => this.actions,
+            getActionsContext: () => this.menuOptions ? this.menuOptions.context : null,
+            getActionViewItem: (action, options) => this.menuOptions && this.menuOptions.actionViewItemProvider ? this.menuOptions.actionViewItemProvider(action, options) : undefined,
+            getKeyBinding: action => this.menuOptions && this.menuOptions.getKeyBinding ? this.menuOptions.getKeyBinding(action) : undefined,
+            getMenuClassName: () => this._options.menuClassName || '',
+            onHide: () => this.onHide(),
+            actionRunner: this.menuOptions ? this.menuOptions.actionRunner : undefined,
+            anchorAlignment: this.menuOptions ? this.menuOptions.anchorAlignment : 0 /* AnchorAlignment.LEFT */,
+            domForShadowRoot: this._options.menuAsChild ? this.element : undefined,
+            skipTelemetry: this._options.skipTelemetry
+        });
+    }
+    hide() {
+        super.hide();
+    }
+    onHide() {
+        this.hide();
+        this.element.classList.remove('active');
+    }
+}
+
+export { BaseDropdown, DropdownMenu };