monaco-editor11 1.1.2 → 1.1.4

package/dist/esm/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css

@@ -0,0 +1,486 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.quick-input-widget {
+	position: absolute;
+	width: 600px;
+	z-index: 2550;
+	left: 50%;
+	-webkit-app-region: no-drag;
+	border-radius: 6px;
+}
+
+.quick-input-titlebar {
+	cursor: grab;
+	display: flex;
+	align-items: center;
+	border-top-right-radius: 5px;
+	border-top-left-radius: 5px;
+}
+
+.quick-input-left-action-bar {
+	display: flex;
+	margin-left: 4px;
+	flex: 1;
+}
+
+/* give some space between input and action bar */
+.quick-input-inline-action-bar > .actions-container > .action-item:first-child {
+	margin-left: 5px;
+}
+
+/* center horizontally */
+.quick-input-inline-action-bar > .actions-container > .action-item {
+	margin-top: 2px;
+}
+
+.quick-input-title {
+	cursor: grab;
+	padding: 3px 0px;
+	text-align: center;
+	text-overflow: ellipsis;
+	overflow: hidden;
+}
+
+.quick-input-right-action-bar {
+	display: flex;
+	margin-right: 4px;
+	flex: 1;
+}
+
+.quick-input-right-action-bar > .actions-container {
+	justify-content: flex-end;
+}
+
+.quick-input-right-action-bar > .actions-container > .action-item {
+	margin-left: 4px;
+}
+
+.quick-input-titlebar .monaco-action-bar .action-label.codicon {
+	background-position: center;
+	background-repeat: no-repeat;
+	padding: 2px;
+}
+
+.quick-input-description {
+	margin: 6px 6px 6px 11px;
+}
+
+.quick-input-header .quick-input-description {
+	margin: 4px 2px;
+	flex: 1;
+}
+
+.quick-input-header {
+	cursor: grab;
+	display: flex;
+	padding: 6px 6px 2px 6px;
+}
+
+.quick-input-widget.hidden-input .quick-input-header {
+	/* reduce margins and paddings when input box hidden */
+	padding: 0;
+	margin-bottom: 0;
+}
+
+.quick-input-and-message {
+	display: flex;
+	flex-direction: column;
+	flex-grow: 1;
+	min-width: 0;
+	position: relative;
+}
+
+.quick-input-check-all {
+	align-self: center;
+	margin: 0;
+}
+
+.quick-input-widget .quick-input-header .monaco-checkbox {
+	margin-top: 6px;
+}
+
+.quick-input-filter {
+	flex-grow: 1;
+	display: flex;
+	position: relative;
+}
+
+.quick-input-box {
+	flex-grow: 1;
+}
+
+.quick-input-widget.show-checkboxes .quick-input-box,
+.quick-input-widget.show-checkboxes .quick-input-message {
+	margin-left: 5px;
+}
+
+.quick-input-visible-count {
+	position: absolute;
+	left: -10000px;
+}
+
+.quick-input-count {
+	align-self: center;
+	position: absolute;
+	right: 4px;
+	display: flex;
+	align-items: center;
+}
+
+.quick-input-count .monaco-count-badge {
+	vertical-align: middle;
+	padding: 2px 4px;
+	border-radius: 2px;
+	min-height: auto;
+	line-height: normal;
+}
+
+.quick-input-action {
+	margin-left: 6px;
+}
+
+.quick-input-action .monaco-text-button {
+	font-size: 11px;
+	padding: 0 6px;
+	display: flex;
+	height: 25px;
+	align-items: center;
+}
+
+.quick-input-message {
+	margin-top: -1px;
+	padding: 5px;
+	overflow-wrap: break-word;
+}
+
+.quick-input-message > .codicon {
+	margin: 0 0.2em;
+	vertical-align: text-bottom;
+}
+
+/* Links in descriptions & validations */
+.quick-input-message a {
+	color: inherit;
+}
+
+.quick-input-progress.monaco-progress-container {
+	position: relative;
+}
+
+.quick-input-list {
+	line-height: 22px;
+}
+
+.quick-input-widget.hidden-input .quick-input-list {
+	margin-top: 4px;
+	/* reduce margins when input box hidden */
+	padding-bottom: 4px;
+}
+
+.quick-input-list .monaco-list {
+	overflow: hidden;
+	max-height: calc(20 * 22px);
+	padding-bottom: 5px;
+}
+
+.quick-input-list .monaco-scrollable-element {
+	padding: 0px 6px;
+}
+
+.quick-input-list .quick-input-list-entry {
+	box-sizing: border-box;
+	overflow: hidden;
+	display: flex;
+	padding: 0 6px;
+}
+
+.quick-input-list .quick-input-list-entry.quick-input-list-separator-border {
+	border-top-width: 1px;
+	border-top-style: solid;
+}
+
+.quick-input-list .monaco-list-row {
+	border-radius: 3px;
+}
+
+.quick-input-list .monaco-list-row[data-index="0"] .quick-input-list-entry.quick-input-list-separator-border {
+	border-top-style: none;
+}
+
+.quick-input-list .quick-input-list-label {
+	overflow: hidden;
+	display: flex;
+	height: 100%;
+	flex: 1;
+}
+
+.quick-input-widget .monaco-checkbox {
+	margin-right: 0;
+}
+
+.quick-input-widget .quick-input-list .monaco-checkbox,
+.quick-input-widget .quick-input-tree .monaco-checkbox {
+	margin-top: 4px;
+}
+
+.quick-input-list .quick-input-list-icon {
+	background-size: 16px;
+	background-position: left center;
+	background-repeat: no-repeat;
+	padding-right: 6px;
+	width: 16px;
+	height: 22px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+}
+
+.quick-input-list .quick-input-list-rows {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	flex: 1;
+	margin-left: 5px;
+}
+
+.quick-input-list .quick-input-list-rows > .quick-input-list-row {
+	display: flex;
+	align-items: center;
+}
+
+.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label,
+.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container {
+	flex: 1;
+	/* make sure the icon label grows within the row */
+}
+
+.quick-input-list .quick-input-list-rows > .quick-input-list-row .codicon[class*='codicon-'] {
+	vertical-align: text-bottom;
+}
+
+.quick-input-list .quick-input-list-rows .monaco-highlighted-label > span {
+	opacity: 1;
+}
+
+.quick-input-list .quick-input-list-entry .quick-input-list-entry-keybinding {
+	margin-right: 8px;
+	/* separate from the separator label or scrollbar if any */
+}
+
+.quick-input-list .quick-input-list-label-meta {
+	opacity: 0.7;
+	line-height: normal;
+	text-overflow: ellipsis;
+	overflow: hidden;
+}
+
+/* preserve list-like styling instead of tree-like styling */
+.quick-input-list .monaco-list .monaco-list-row .monaco-highlighted-label .highlight {
+	font-weight: bold;
+	background-color: unset;
+	color: var(--vscode-list-highlightForeground) !important;
+}
+
+/* preserve list-like styling instead of tree-like styling */
+.quick-input-list .monaco-list .monaco-list-row.focused .monaco-highlighted-label .highlight {
+	color: var(--vscode-list-focusHighlightForeground) !important;
+}
+
+.quick-input-list .quick-input-list-entry .quick-input-list-separator {
+	margin-right: 4px;
+	/* separate from keybindings or actions */
+}
+
+.quick-input-list .quick-input-list-entry-action-bar {
+	display: flex;
+	flex: 0;
+	overflow: visible;
+}
+
+.quick-input-list .quick-input-list-entry-action-bar .action-label {
+	/*
+	 * By default, actions in the quick input action bar are hidden
+	 * until hovered over them or selected.
+	 */
+	display: none;
+}
+
+.quick-input-list .quick-input-list-entry-action-bar .action-label.codicon {
+	margin-right: 4px;
+	padding: 2px;
+}
+
+.quick-input-list .quick-input-list-entry-action-bar {
+	margin-top: 1px;
+}
+
+.quick-input-list .quick-input-list-entry-action-bar {
+	margin-right: 4px;
+	/* separate from scrollbar */
+}
+
+.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible,
+.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label,
+.quick-input-list .quick-input-list-entry.focus-inside .quick-input-list-entry-action-bar .action-label,
+.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label,
+.quick-input-list .monaco-list-row.passive-focused .quick-input-list-entry-action-bar .action-label {
+	display: flex;
+}
+
+.quick-input-list > .monaco-list:focus .monaco-list-row.focused {
+	outline: 1px solid var(--vscode-list-focusOutline) !important;
+	outline-offset: -1px;
+}
+
+.quick-input-list > .monaco-list:focus .monaco-list-row.focused .quick-input-list-entry.quick-input-list-separator-border {
+	border-color: transparent;
+}
+
+/* focused items in quick pick */
+.quick-input-list .monaco-list-row.focused .monaco-keybinding-key,
+.quick-input-list .monaco-list-row.focused .quick-input-list-entry .quick-input-list-separator {
+	color: inherit
+}
+
+.quick-input-list .monaco-list-row.focused .monaco-keybinding-key {
+	background: none;
+}
+
+.quick-input-list .quick-input-list-separator-as-item {
+	padding: 4px 6px;
+	font-size: 12px;
+}
+
+/* Quick input separators as full-row item */
+.quick-input-list .quick-input-list-separator-as-item .label-name {
+	font-weight: 600;
+}
+
+.quick-input-list .quick-input-list-separator-as-item .label-description {
+	/* Override default description opacity so we don't have a contrast ratio issue. */
+	opacity: 1 !important;
+}
+
+/* Hide border when the item becomes the sticky one */
+.quick-input-list .monaco-tree-sticky-row .quick-input-list-entry.quick-input-list-separator-as-item.quick-input-list-separator-border {
+	border-top-style: none;
+}
+
+/* Give sticky row the same padding as the scrollable list */
+.quick-input-list .monaco-tree-sticky-row {
+	padding: 0 5px;
+}
+
+/* Hide the twistie containers so that there isn't blank indent */
+.quick-input-list .monaco-tl-twistie {
+	display: none !important;
+}
+
+/* Tree */
+
+.quick-input-tree .monaco-list {
+	overflow: hidden;
+	max-height: calc(20 * 22px);
+	padding-bottom: 5px;
+}
+
+.quick-input-tree .quick-input-tree-entry {
+	box-sizing: border-box;
+	overflow: hidden;
+	display: flex;
+	padding: 0 6px;
+}
+
+.quick-input-tree .quick-input-tree-label {
+	overflow: hidden;
+	display: flex;
+	height: 100%;
+	flex: 1;
+}
+
+.quick-input-tree .quick-input-tree-icon {
+	background-size: 16px;
+	background-position: left center;
+	background-repeat: no-repeat;
+	padding-right: 6px;
+	width: 16px;
+	height: 22px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+}
+
+.quick-input-tree .quick-input-tree-rows {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	flex: 1;
+	margin-left: 5px;
+}
+
+.quick-input-tree .quick-input-tree-rows > .quick-input-tree-row {
+	display: flex;
+	align-items: center;
+}
+
+.quick-input-tree .quick-input-tree-rows > .quick-input-tree-row .monaco-icon-label,
+.quick-input-tree .quick-input-tree-rows > .quick-input-tree-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container {
+	flex: 1;
+	/* make sure the icon label grows within the row */
+}
+
+.quick-input-tree .quick-input-tree-rows > .quick-input-tree-row .codicon[class*='codicon-'] {
+	vertical-align: text-bottom;
+}
+
+.quick-input-tree .quick-input-tree-rows .monaco-highlighted-label > span {
+	opacity: 1;
+}
+
+.quick-input-tree .quick-input-tree-entry-action-bar {
+	display: flex;
+	flex: 0;
+	overflow: visible;
+}
+
+.quick-input-tree .quick-input-tree-entry-action-bar .action-label {
+	/*
+	 * By default, actions in the quick input action bar are hidden
+	 * until hovered over them or selected.
+	 */
+	display: none;
+}
+
+.quick-input-tree .quick-input-tree-entry-action-bar .action-label.codicon {
+	margin-right: 4px;
+	padding: 2px;
+}
+
+.quick-input-tree .quick-input-tree-entry-action-bar {
+	margin-top: 1px;
+}
+
+.quick-input-tree .quick-input-tree-entry-action-bar {
+	margin-right: 4px;
+	/* separate from scrollbar */
+}
+
+.quick-input-tree .quick-input-tree-entry .quick-input-tree-entry-action-bar .action-label.always-visible,
+.quick-input-tree .quick-input-tree-entry:hover .quick-input-tree-entry-action-bar .action-label,
+.quick-input-tree .quick-input-tree-entry.focus-inside .quick-input-tree-entry-action-bar .action-label,
+.quick-input-tree .monaco-list-row.focused .quick-input-tree-entry-action-bar .action-label,
+.quick-input-tree .monaco-list-row.passive-focused .quick-input-tree-entry-action-bar .action-label {
+	display: flex;
+}
+
+.quick-input-tree > .monaco-list:focus .monaco-list-row.focused {
+	outline: 1px solid var(--vscode-list-focusOutline) !important;
+	outline-offset: -1px;
+}

package/dist/esm/monaco-editor/esm/vs/platform/quickinput/browser/quickAccess.js

@@ -0,0 +1,209 @@
+import { DeferredPromise } from '../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable, toDisposable, isDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { Extensions, DefaultQuickAccessFilterValue } from '../common/quickAccess.js';
+import { IQuickInputService, ItemActivation } from '../common/quickInput.js';
+import { Registry } from '../../registry/common/platform.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); }
+};
+let QuickAccessController = class QuickAccessController extends Disposable {
+    constructor(quickInputService, instantiationService) {
+        super();
+        this.quickInputService = quickInputService;
+        this.instantiationService = instantiationService;
+        this.registry = Registry.as(Extensions.Quickaccess);
+        this.mapProviderToDescriptor = new Map();
+        this.lastAcceptedPickerValues = new Map();
+        this.visibleQuickAccess = undefined;
+        this._register(toDisposable(() => {
+            for (const provider of this.mapProviderToDescriptor.values()) {
+                if (isDisposable(provider)) {
+                    provider.dispose();
+                }
+            }
+            this.visibleQuickAccess?.picker.dispose();
+        }));
+    }
+    show(value = '', options) {
+        this.doShowOrPick(value, false, options);
+    }
+    doShowOrPick(value, pick, options) {
+        // Find provider for the value to show
+        const [provider, descriptor] = this.getOrInstantiateProvider(value, options?.enabledProviderPrefixes);
+        // Return early if quick access is already showing on that same prefix
+        const visibleQuickAccess = this.visibleQuickAccess;
+        const visibleDescriptor = visibleQuickAccess?.descriptor;
+        if (visibleQuickAccess && descriptor && visibleDescriptor === descriptor) {
+            // Apply value only if it is more specific than the prefix
+            // from the provider and we are not instructed to preserve
+            if (value !== descriptor.prefix && !options?.preserveValue) {
+                visibleQuickAccess.picker.value = value;
+            }
+            // Always adjust selection
+            this.adjustValueSelection(visibleQuickAccess.picker, descriptor, options);
+            return;
+        }
+        // Rewrite the filter value based on certain rules unless disabled
+        if (descriptor && !options?.preserveValue) {
+            let newValue = undefined;
+            // If we have a visible provider with a value, take it's filter value but
+            // rewrite to new provider prefix in case they differ
+            if (visibleQuickAccess && visibleDescriptor && visibleDescriptor !== descriptor) {
+                const newValueCandidateWithoutPrefix = visibleQuickAccess.value.substr(visibleDescriptor.prefix.length);
+                if (newValueCandidateWithoutPrefix) {
+                    newValue = `${descriptor.prefix}${newValueCandidateWithoutPrefix}`;
+                }
+            }
+            // Otherwise, take a default value as instructed
+            if (!newValue) {
+                const defaultFilterValue = provider?.defaultFilterValue;
+                if (defaultFilterValue === DefaultQuickAccessFilterValue.LAST) {
+                    newValue = this.lastAcceptedPickerValues.get(descriptor);
+                }
+                else if (typeof defaultFilterValue === 'string') {
+                    newValue = `${descriptor.prefix}${defaultFilterValue}`;
+                }
+            }
+            if (typeof newValue === 'string') {
+                value = newValue;
+            }
+        }
+        // Store the existing selection if there was one.
+        const visibleSelection = visibleQuickAccess?.picker?.valueSelection;
+        const visibleValue = visibleQuickAccess?.picker?.value;
+        // Create a picker for the provider to use with the initial value
+        // and adjust the filtering to exclude the prefix from filtering
+        const disposables = new DisposableStore();
+        const picker = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
+        picker.value = value;
+        this.adjustValueSelection(picker, descriptor, options);
+        picker.placeholder = options?.placeholder ?? descriptor?.placeholder;
+        picker.quickNavigate = options?.quickNavigateConfiguration;
+        picker.hideInput = !!picker.quickNavigate && !visibleQuickAccess; // only hide input if there was no picker opened already
+        if (typeof options?.itemActivation === 'number' || options?.quickNavigateConfiguration) {
+            picker.itemActivation = options?.itemActivation ?? ItemActivation.SECOND /* quick nav is always second */;
+        }
+        picker.contextKey = descriptor?.contextKey;
+        picker.filterValue = (value) => value.substring(descriptor ? descriptor.prefix.length : 0);
+        // Pick mode: setup a promise that can be resolved
+        // with the selected items and prevent execution
+        let pickPromise = undefined;
+        if (pick) {
+            pickPromise = new DeferredPromise();
+            disposables.add(Event.once(picker.onWillAccept)(e => {
+                e.veto();
+                picker.hide();
+            }));
+        }
+        // Register listeners
+        disposables.add(this.registerPickerListeners(picker, provider, descriptor, value, options));
+        // Ask provider to fill the picker as needed if we have one
+        // and pass over a cancellation token that will indicate when
+        // the picker is hiding without a pick being made.
+        const cts = disposables.add(new CancellationTokenSource());
+        if (provider) {
+            disposables.add(provider.provide(picker, cts.token, options?.providerOptions));
+        }
+        // Finally, trigger disposal and cancellation when the picker
+        // hides depending on items selected or not.
+        Event.once(picker.onDidHide)(() => {
+            if (picker.selectedItems.length === 0) {
+                cts.cancel();
+            }
+            // Start to dispose once picker hides
+            disposables.dispose();
+            // Resolve pick promise with selected items
+            pickPromise?.complete(picker.selectedItems.slice(0));
+        });
+        // Finally, show the picker. This is important because a provider
+        // may not call this and then our disposables would leak that rely
+        // on the onDidHide event.
+        picker.show();
+        // If the previous picker had a selection and the value is unchanged, we should set that in the new picker.
+        if (visibleSelection && visibleValue === value) {
+            picker.valueSelection = visibleSelection;
+        }
+        // Pick mode: return with promise
+        if (pick) {
+            return pickPromise?.p;
+        }
+    }
+    adjustValueSelection(picker, descriptor, options) {
+        let valueSelection;
+        // Preserve: just always put the cursor at the end
+        if (options?.preserveValue) {
+            valueSelection = [picker.value.length, picker.value.length];
+        }
+        // Otherwise: select the value up until the prefix
+        else {
+            valueSelection = [descriptor?.prefix.length ?? 0, picker.value.length];
+        }
+        picker.valueSelection = valueSelection;
+    }
+    registerPickerListeners(picker, provider, descriptor, value, options) {
+        const disposables = new DisposableStore();
+        // Remember as last visible picker and clean up once picker get's disposed
+        const visibleQuickAccess = this.visibleQuickAccess = { picker, descriptor, value };
+        disposables.add(toDisposable(() => {
+            if (visibleQuickAccess === this.visibleQuickAccess) {
+                this.visibleQuickAccess = undefined;
+            }
+        }));
+        // Whenever the value changes, check if the provider has
+        // changed and if so - re-create the picker from the beginning
+        disposables.add(picker.onDidChangeValue(value => {
+            const [providerForValue] = this.getOrInstantiateProvider(value, options?.enabledProviderPrefixes);
+            if (providerForValue !== provider) {
+                this.show(value, {
+                    enabledProviderPrefixes: options?.enabledProviderPrefixes,
+                    // do not rewrite value from user typing!
+                    preserveValue: true,
+                    // persist the value of the providerOptions from the original showing
+                    providerOptions: options?.providerOptions
+                });
+            }
+            else {
+                visibleQuickAccess.value = value; // remember the value in our visible one
+            }
+        }));
+        // Remember picker input for future use when accepting
+        if (descriptor) {
+            disposables.add(picker.onDidAccept(() => {
+                this.lastAcceptedPickerValues.set(descriptor, picker.value);
+            }));
+        }
+        return disposables;
+    }
+    getOrInstantiateProvider(value, enabledProviderPrefixes) {
+        const providerDescriptor = this.registry.getQuickAccessProvider(value);
+        if (!providerDescriptor || enabledProviderPrefixes && !enabledProviderPrefixes?.includes(providerDescriptor.prefix)) {
+            return [undefined, undefined];
+        }
+        let provider = this.mapProviderToDescriptor.get(providerDescriptor);
+        if (!provider) {
+            provider = this.instantiationService.createInstance(providerDescriptor.ctor);
+            this.mapProviderToDescriptor.set(providerDescriptor, provider);
+        }
+        return [provider, providerDescriptor];
+    }
+};
+QuickAccessController = __decorate([
+    __param(0, IQuickInputService),
+    __param(1, IInstantiationService)
+], QuickAccessController);
+
+export { QuickAccessController };