@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/platform/markers/common/markerService.js

@@ -2,9 +2,11 @@
 import { isFalsyOrEmpty, isNonEmptyArray } from '../../../base/common/arrays.js';
 import { DebounceEmitter } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { ResourceMap } from '../../../base/common/map.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { ResourceMap, ResourceSet } from '../../../base/common/map.js';
 import { Schemas } from '../../../base/common/network.js';
 import { URI } from '../../../base/common/uri.js';
+import { localize } from '../../../nls.js';
 import { MarkerSeverity } from './markers.js';
 
 const unsupportedSchemas = ( new Set([
@@ -130,6 +132,7 @@ class MarkerService {
         this.onMarkerChanged = this._onMarkerChanged.event;
         this._data = ( new DoubleResourceMap());
         this._stats = ( new MarkerStats(this));
+        this._filteredResources = ( new ResourceMap());
     }
     dispose() {
         this._stats.dispose();
@@ -162,6 +165,29 @@ class MarkerService {
             this._onMarkerChanged.fire([resource]);
         }
     }
+    installResourceFilter(resource, reason) {
+        let reasons = this._filteredResources.get(resource);
+        if (!reasons) {
+            reasons = [];
+            this._filteredResources.set(resource, reasons);
+        }
+        reasons.push(reason);
+        this._onMarkerChanged.fire([resource]);
+        return toDisposable(() => {
+            const reasons = this._filteredResources.get(resource);
+            if (!reasons) {
+                return;
+            }
+            const reasonIndex = reasons.indexOf(reason);
+            if (reasonIndex !== -1) {
+                reasons.splice(reasonIndex, 1);
+                if (reasons.length === 0) {
+                    this._filteredResources.delete(resource);
+                }
+                this._onMarkerChanged.fire([resource]);
+            }
+        });
+    }
     static _toMarker(owner, resource, data) {
         let { code, severity, message, source, startLineNumber, startColumn, endLineNumber, endColumn, relatedInformation, tags, } = data;
         if (!message) {
@@ -222,53 +248,77 @@ class MarkerService {
             this._onMarkerChanged.fire(changes);
         }
     }
+    _createFilteredMarker(resource, reasons) {
+        const message = reasons.length === 1
+            ? ( localize(1913, "Problems are paused because: \"{0}\"", reasons[0]))
+            : ( localize(
+            1914,
+            "Problems are paused because: \"{0}\" and {1} more",
+            reasons[0],
+            reasons.length - 1
+        ));
+        return {
+            owner: 'markersFilter',
+            resource,
+            severity: MarkerSeverity.Info,
+            message,
+            startLineNumber: 1,
+            startColumn: 1,
+            endLineNumber: 1,
+            endColumn: 1,
+        };
+    }
     read(filter = Object.create(null)) {
         let { owner, resource, severities, take } = filter;
         if (!take || take < 0) {
             take = -1;
         }
         if (owner && resource) {
+            const reasons = this._filteredResources.get(resource);
+            if (reasons?.length) {
+                const infoMarker = this._createFilteredMarker(resource, reasons);
+                return [infoMarker];
+            }
             const data = this._data.get(resource, owner);
             if (!data) {
                 return [];
             }
-            else {
-                const result = [];
-                for (const marker of data) {
-                    if (MarkerService._accept(marker, severities)) {
-                        const newLen = result.push(marker);
-                        if (take > 0 && newLen === take) {
-                            break;
-                        }
-                    }
-                }
-                return result;
-            }
-        }
-        else if (!owner && !resource) {
             const result = [];
-            for (const markers of ( this._data.values())) {
-                for (const data of markers) {
-                    if (MarkerService._accept(data, severities)) {
-                        const newLen = result.push(data);
-                        if (take > 0 && newLen === take) {
-                            return result;
-                        }
-                    }
+            for (const marker of data) {
+                if (take > 0 && result.length === take) {
+                    break;
+                }
+                const reasons = this._filteredResources.get(resource);
+                if (reasons?.length) {
+                    result.push(this._createFilteredMarker(resource, reasons));
+                }
+                else if (MarkerService._accept(marker, severities)) {
+                    result.push(marker);
                 }
             }
             return result;
         }
         else {
-            const iterable = ( this._data.values(resource ?? owner));
+            const iterable = !owner && !resource
+                ? ( this._data.values())
+                : ( this._data.values(resource ?? owner));
             const result = [];
+            const filtered = ( new ResourceSet());
             for (const markers of iterable) {
                 for (const data of markers) {
-                    if (MarkerService._accept(data, severities)) {
-                        const newLen = result.push(data);
-                        if (take > 0 && newLen === take) {
-                            return result;
-                        }
+                    if (( filtered.has(data.resource))) {
+                        continue;
+                    }
+                    if (take > 0 && result.length === take) {
+                        break;
+                    }
+                    const reasons = this._filteredResources.get(data.resource);
+                    if (reasons?.length) {
+                        result.push(this._createFilteredMarker(data.resource, reasons));
+                        filtered.add(data.resource);
+                    }
+                    else if (MarkerService._accept(data, severities)) {
+                        result.push(data);
                     }
                 }
             }

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

@@ -20,17 +20,17 @@ var MarkerSeverity;
     }
     MarkerSeverity.compare = compare;
     const _displayStrings = Object.create(null);
-    _displayStrings[MarkerSeverity.Error] = ( localize(1878, "Error"));
-    _displayStrings[MarkerSeverity.Warning] = ( localize(1879, "Warning"));
-    _displayStrings[MarkerSeverity.Info] = ( localize(1880, "Info"));
+    _displayStrings[MarkerSeverity.Error] = ( localize(1915, "Error"));
+    _displayStrings[MarkerSeverity.Warning] = ( localize(1916, "Warning"));
+    _displayStrings[MarkerSeverity.Info] = ( localize(1917, "Info"));
     function toString(a) {
         return _displayStrings[a] || '';
     }
     MarkerSeverity.toString = toString;
     const _displayStringsPlural = Object.create(null);
-    _displayStringsPlural[MarkerSeverity.Error] = ( localize(1881, "Errors"));
-    _displayStringsPlural[MarkerSeverity.Warning] = ( localize(1882, "Warnings"));
-    _displayStringsPlural[MarkerSeverity.Info] = ( localize(1883, "Infos"));
+    _displayStringsPlural[MarkerSeverity.Error] = ( localize(1918, "Errors"));
+    _displayStringsPlural[MarkerSeverity.Warning] = ( localize(1919, "Warnings"));
+    _displayStringsPlural[MarkerSeverity.Info] = ( localize(1920, "Infos"));
     function toStringPlural(a) {
         return _displayStringsPlural[a] || '';
     }

package/vscode/src/vs/platform/markers/common/markers.service.d.ts

@@ -1,4 +1,5 @@
 import { Event } from "../../../base/common/event.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
 import { IMarker, IMarkerData, IResourceMarker, MarkerStatistics } from "./markers.js";
 export declare const IMarkerService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IMarkerService>;
@@ -14,5 +15,6 @@ export interface IMarkerService {
         severities?: number;
         take?: number;
     }): IMarker[];
+    installResourceFilter(resource: URI, reason: string): IDisposable;
     readonly onMarkerChanged: Event<readonly URI[]>;
 }

package/vscode/src/vs/platform/observable/common/wrapInHotClass.js

@@ -1,7 +1,9 @@
 
-import '../../../base/common/process.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isHotReloadEnabled } from '../../../base/common/hotReload.js';
 import '../../../base/common/observableInternal/index.js';
-import '../../instantiation/common/instantiation.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { autorunWithStore } from '../../../base/common/observableInternal/autorun.js';
 
 function hotClassGetOriginalInstance(value) {
     if (value instanceof BaseClass) {
@@ -15,8 +17,31 @@ class BaseClass {
     }
     init(...params) { }
 }
+function createWrapper(clazz, B) {
+    return (class ReloadableWrapper extends B {
+        constructor() {
+            super(...arguments);
+            this._autorun = undefined;
+        }
+        init(...params) {
+            this._autorun = autorunWithStore((reader, store) => {
+                const clazz_ = clazz.read(reader);
+                this._instance = store.add(this.instantiationService.createInstance(clazz_, ...params));
+            });
+        }
+        dispose() {
+            this._autorun?.dispose();
+        }
+    });
+}
 function wrapInHotClass1(clazz) {
-    return clazz.get() ;
+    return !isHotReloadEnabled() ? clazz.get() : createWrapper(clazz, BaseClass1);
 }
+let BaseClass1 = class BaseClass1 extends BaseClass {
+    constructor(param1, i) { super(i); this.init(param1); }
+};
+BaseClass1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], BaseClass1));
 
 export { hotClassGetOriginalInstance, wrapInHotClass1 };

package/vscode/src/vs/platform/observable/common/wrapInReloadableClass.js

@@ -1,13 +1,51 @@
 
-import '../../../base/common/process.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isHotReloadEnabled } from '../../../base/common/hotReload.js';
+import { readHotReloadableExport } from '../../../base/common/hotReloadHelpers.js';
 import '../../../base/common/observableInternal/index.js';
-import '../../instantiation/common/instantiation.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { autorunWithStore } from '../../../base/common/observableInternal/autorun.js';
 
 function wrapInReloadableClass0(getClass) {
-    return getClass() ;
+    return !isHotReloadEnabled() ? getClass() : createWrapper(getClass, BaseClass0);
 }
+class BaseClass {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+    }
+    init(...params) { }
+}
+function createWrapper(getClass, B) {
+    return (class ReloadableWrapper extends B {
+        constructor() {
+            super(...arguments);
+            this._autorun = undefined;
+        }
+        init(...params) {
+            this._autorun = autorunWithStore((reader, store) => {
+                const clazz = readHotReloadableExport(getClass(), reader);
+                store.add(this.instantiationService.createInstance(clazz, ...params));
+            });
+        }
+        dispose() {
+            this._autorun?.dispose();
+        }
+    });
+}
+let BaseClass0 = class BaseClass0 extends BaseClass {
+    constructor(i) { super(i); this.init(); }
+};
+BaseClass0 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], BaseClass0));
 function wrapInReloadableClass1(getClass) {
-    return getClass() ;
+    return !isHotReloadEnabled() ? getClass() : createWrapper(getClass, BaseClass1);
 }
+let BaseClass1 = class BaseClass1 extends BaseClass {
+    constructor(param1, i) { super(i); this.init(param1); }
+};
+BaseClass1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], BaseClass1));
 
 export { wrapInReloadableClass0, wrapInReloadableClass1 };

package/vscode/src/vs/platform/opener/browser/link.css

@@ -0,0 +1,6 @@
+.monaco-link {
+	color: var(--vscode-textLink-foreground);
+}
+.monaco-link:hover {
+	color: var(--vscode-textLink-activeForeground);
+}

package/vscode/src/vs/platform/opener/browser/link.js

@@ -8,7 +8,7 @@ import { Event } from '../../../base/common/event.js';
 import { KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { IOpenerService } from '../common/opener.service.js';
-import './link.css.js';
+import './link.css';
 import { getDefaultHoverDelegate } from '../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { IHoverService } from '../../hover/browser/hover.service.js';
 

package/vscode/src/vs/platform/policy/common/policy.d.ts

@@ -1,15 +1,17 @@
 import { IStringDictionary } from "../../../base/common/collections.js";
 import { Emitter, Event } from "../../../base/common/event.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
+import { PolicyName } from "../../../base/common/policy.js";
 import { IPolicyService } from "./policy.service.js";
-export type PolicyName = string;
-export type PolicyValue = string | number;
+export type PolicyValue = string | number | boolean;
 export type PolicyDefinition = {
-    type: "string" | "number";
+    type: "string" | "number" | "boolean";
+    previewFeature?: boolean;
+    defaultValue?: string | number | boolean;
 };
 export declare abstract class AbstractPolicyService extends Disposable implements IPolicyService {
     readonly _serviceBrand: undefined;
-    protected policyDefinitions: IStringDictionary<PolicyDefinition>;
+    policyDefinitions: IStringDictionary<PolicyDefinition>;
     protected policies: Map<string, PolicyValue>;
     protected readonly _onDidChange: Emitter<readonly string[]>;
     readonly onDidChange: Event<readonly string[]>;
@@ -27,4 +29,5 @@ export declare class NullPolicyService implements IPolicyService {
     updatePolicyDefinitions(): Promise<{}>;
     getPolicyValue(): undefined;
     serialize(): undefined;
+    policyDefinitions: IStringDictionary<PolicyDefinition>;
 }

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

@@ -6,6 +6,7 @@ import '../../../base/common/lifecycle.js';
 class NullPolicyService {
     constructor() {
         this.onDidChange = Event.None;
+        this.policyDefinitions = {};
     }
     async updatePolicyDefinitions() { return {}; }
     getPolicyValue() { return undefined; }

package/vscode/src/vs/platform/policy/common/policy.service.d.ts

@@ -1,6 +1,7 @@
 import { IStringDictionary } from "../../../base/common/collections.js";
 import { Event } from "../../../base/common/event.js";
-import { PolicyName, PolicyDefinition, PolicyValue } from "./policy.js";
+import { PolicyName } from "../../../base/common/policy.js";
+import { PolicyDefinition, PolicyValue } from "./policy.js";
 export declare const IPolicyService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IPolicyService>;
 export interface IPolicyService {
     readonly _serviceBrand: undefined;
@@ -11,4 +12,5 @@ export interface IPolicyService {
         definition: PolicyDefinition;
         value: PolicyValue;
     }> | undefined;
+    readonly policyDefinitions: IStringDictionary<PolicyDefinition>;
 }

package/vscode/src/vs/platform/quickinput/browser/media/quickInput.css

@@ -0,0 +1,311 @@
+.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;
+}
+.quick-input-inline-action-bar > .actions-container > .action-item:first-child {
+	margin-left: 5px;
+}
+.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-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: 8px 6px 2px 6px;
+}
+.quick-input-widget.hidden-input .quick-input-header {
+	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-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;
+}
+.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;
+	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 5px;
+}
+.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.indented {
+	padding-left: 1.3em;
+}
+.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-list .quick-input-list-checkbox {
+	align-self: center;
+	margin: 0;
+}
+.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-widget.show-checkboxes .quick-input-list .quick-input-list-rows {
+	margin-left: 10px;
+}
+.quick-input-widget .quick-input-list .quick-input-list-checkbox {
+	display: none;
+}
+.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-checkbox {
+	display: inline;
+}
+.quick-input-widget.show-checkboxes .quick-input-list-entry.not-pickable {
+	margin-left: -10px;
+	.quick-input-list-checkbox {
+		display: none;
+	}
+}
+.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;
+}
+.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;
+}
+.quick-input-list .quick-input-list-label-meta {
+	opacity: 0.7;
+	line-height: normal;
+	text-overflow: ellipsis;
+	overflow: hidden;
+}
+.quick-input-list .monaco-list .monaco-list-row .monaco-highlighted-label .highlight {
+	font-weight: bold;
+	background-color: unset;
+	color: var(--vscode-list-highlightForeground) !important;
+}
+.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;
+}
+.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 {
+	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;
+}
+.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-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-list .quick-input-list-separator-as-item .label-name {
+	font-weight: 600;
+}
+.quick-input-list .quick-input-list-separator-as-item .label-description {
+	opacity: 1 !important;
+}
+.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;
+}
+.quick-input-list .monaco-tree-sticky-row {
+	padding: 0 5px;
+}
+.quick-input-list .monaco-tl-twistie {
+	display: none !important;
+}
+.quick-input-widget-snapline {
+	position: absolute;
+	z-index: 2549;
+}
+.quick-input-widget-snapline.hidden {
+	display: none;
+}
+.quick-input-widget-snapline.horizontal {
+	border-top: 1px dashed var(--vscode-editorRuler-foreground);
+	height: 0;
+	width: 100%;
+	left: 0;
+}
+.quick-input-widget-snapline.vertical {
+	border-left: 1px dashed var(--vscode-editorRuler-foreground);
+	height: 100%;
+	width: 0;
+	top: 0;
+}