@codingame/monaco-vscode-api 1.83.15 → 1.83.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.15",
+  "version": "1.83.16",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -100,10 +100,10 @@
   "dependencies": {
     "monaco-editor": "0.44.0",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-files-service-override": "1.83.15",
-    "@codingame/monaco-vscode-layout-service-override": "1.83.15",
-    "@codingame/monaco-vscode-environment-service-override": "1.83.15",
-    "@codingame/monaco-vscode-extensions-service-override": "1.83.15",
-    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.15"
+    "@codingame/monaco-vscode-files-service-override": "1.83.16",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.16",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.16",
+    "@codingame/monaco-vscode-extensions-service-override": "1.83.16",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.16"
   }
 }

package/vscode/src/vs/base/common/prefixTree.js

@@ -0,0 +1,130 @@
+const unset = Symbol('unset');
+class WellDefinedPrefixTree {
+    constructor() {
+        this.root = ( new Node());
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+    insert(key, value) {
+        this.opNode(key, n => n.value = value);
+    }
+    mutate(key, mutate) {
+        this.opNode(key, n => n.value = mutate(n.value === unset ? undefined : n.value));
+    }
+    delete(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
+        for (const part of key) {
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return undefined;
+            }
+            path.push({ part, node });
+            i++;
+        }
+        const value = path[i].node.value;
+        if (value === unset) {
+            return;
+        }
+        this._size--;
+        for (; i > 0; i--) {
+            const parent = path[i - 1];
+            parent.node.children.delete(path[i].part);
+            if (parent.node.children.size > 0 || parent.node.value !== unset) {
+                break;
+            }
+        }
+        return value;
+    }
+    find(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return undefined;
+            }
+            node = next;
+        }
+        return node.value === unset ? undefined : node.value;
+    }
+    hasKeyOrParent(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            if (next.value !== unset) {
+                return true;
+            }
+            node = next;
+        }
+        return false;
+    }
+    hasKeyOrChildren(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return true;
+    }
+    hasKey(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return node.value !== unset;
+    }
+    opNode(key, fn) {
+        let node = this.root;
+        for (const part of key) {
+            if (!node.children) {
+                const next = ( new Node());
+                node.children = ( new Map([[part, next]]));
+                node = next;
+            }
+            else if (!( node.children.has(part))) {
+                const next = ( new Node());
+                node.children.set(part, next);
+                node = next;
+            }
+            else {
+                node = node.children.get(part);
+            }
+        }
+        if (node.value === unset) {
+            this._size++;
+        }
+        fn(node);
+    }
+    *values() {
+        const stack = [this.root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.value !== unset) {
+                yield node.value;
+            }
+            if (node.children) {
+                for (const child of ( node.children.values())) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+}
+class Node {
+    constructor() {
+        this.value = unset;
+    }
+}
+export { WellDefinedPrefixTree };

package/vscode/src/vs/platform/actions/browser/floatingMenu.js

@@ -2,10 +2,11 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { $, clearNode, append } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
 import { IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { asCssVariableWithDefault, buttonBackground, asCssVariable, editorBackground, buttonForeground, editorForeground, contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 class FloatingClickWidget extends Widget {
     constructor(label) {
@@ -70,4 +71,27 @@ AbstractFloatingClickMenu = ( __decorate([
     ( __param(1, IMenuService)),
     ( __param(2, IContextKeyService))
 ], AbstractFloatingClickMenu));
-export { AbstractFloatingClickMenu, FloatingClickWidget };
+let FloatingClickMenu = class FloatingClickMenu extends AbstractFloatingClickMenu {
+    constructor(options, instantiationService, menuService, contextKeyService) {
+        super(options.menuId, menuService, contextKeyService);
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.render();
+    }
+    createWidget(action, disposable) {
+        const w = this.instantiationService.createInstance(FloatingClickWidget, action.label);
+        const node = w.getDomNode();
+        this.options.container.appendChild(node);
+        disposable.add(toDisposable(() => this.options.container.removeChild(node)));
+        return w;
+    }
+    getActionArg() {
+        return this.options.getActionArg();
+    }
+};
+FloatingClickMenu = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IMenuService)),
+    ( __param(3, IContextKeyService))
+], FloatingClickMenu));
+export { AbstractFloatingClickMenu, FloatingClickMenu, FloatingClickWidget };

package/vscode/src/vs/platform/terminal/common/capabilities/bufferMarkCapability.js

@@ -0,0 +1,41 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class BufferMarkCapability extends Disposable {
+    constructor(_terminal) {
+        super();
+        this._terminal = _terminal;
+        this.type = 4 ;
+        this._idToMarkerMap = ( new Map());
+        this._anonymousMarkers = ( new Map());
+        this._onMarkAdded = this._register(( new Emitter()));
+        this.onMarkAdded = this._onMarkAdded.event;
+    }
+    *markers() {
+        for (const m of ( this._idToMarkerMap.values())) {
+            yield m;
+        }
+        for (const m of ( this._anonymousMarkers.values())) {
+            yield m;
+        }
+    }
+    addMark(properties) {
+        const marker = properties?.marker || this._terminal.registerMarker();
+        const id = properties?.id;
+        if (!marker) {
+            return;
+        }
+        if (id) {
+            this._idToMarkerMap.set(id, marker);
+            marker.onDispose(() => this._idToMarkerMap.delete(id));
+        }
+        else {
+            this._anonymousMarkers.set(marker.id, marker);
+            marker.onDispose(() => this._anonymousMarkers.delete(marker.id));
+        }
+        this._onMarkAdded.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
+    }
+    getMark(id) {
+        return this._idToMarkerMap.get(id);
+    }
+}
+export { BufferMarkCapability };