@codingame/monaco-vscode-api 6.0.3 → 7.0.1

package/vscode/src/vs/base/common/observableInternal/lazyObservableValue.js

@@ -0,0 +1,109 @@
+import { BaseObservable, TransactionImpl } from './base.js';
+class LazyObservableValue extends BaseObservable {
+    get debugName() {
+        return this._debugNameData.getDebugName(this) ?? 'LazyObservableValue';
+    }
+    constructor(_debugNameData, initialValue, _equalityComparator) {
+        super();
+        this._debugNameData = _debugNameData;
+        this._equalityComparator = _equalityComparator;
+        this._isUpToDate = true;
+        this._deltas = [];
+        this._updateCounter = 0;
+        this._value = initialValue;
+    }
+    get() {
+        this._update();
+        return this._value;
+    }
+    _update() {
+        if (this._isUpToDate) {
+            return;
+        }
+        this._isUpToDate = true;
+        if (this._deltas.length > 0) {
+            for (const observer of this.observers) {
+                for (const change of this._deltas) {
+                    observer.handleChange(this, change);
+                }
+            }
+            this._deltas.length = 0;
+        }
+        else {
+            for (const observer of this.observers) {
+                observer.handleChange(this, undefined);
+            }
+        }
+    }
+    _beginUpdate() {
+        this._updateCounter++;
+        if (this._updateCounter === 1) {
+            for (const observer of this.observers) {
+                observer.beginUpdate(this);
+            }
+        }
+    }
+    _endUpdate() {
+        this._updateCounter--;
+        if (this._updateCounter === 0) {
+            this._update();
+            const observers = [...this.observers];
+            for (const r of observers) {
+                r.endUpdate(this);
+            }
+        }
+    }
+    addObserver(observer) {
+        const shouldCallBeginUpdate = !( this.observers.has(observer)) && this._updateCounter > 0;
+        super.addObserver(observer);
+        if (shouldCallBeginUpdate) {
+            observer.beginUpdate(this);
+        }
+    }
+    removeObserver(observer) {
+        const shouldCallEndUpdate = ( this.observers.has(observer)) && this._updateCounter > 0;
+        super.removeObserver(observer);
+        if (shouldCallEndUpdate) {
+            observer.endUpdate(this);
+        }
+    }
+    set(value, tx, change) {
+        if (change === undefined && this._equalityComparator(this._value, value)) {
+            return;
+        }
+        let _tx;
+        if (!tx) {
+            tx = _tx = ( new TransactionImpl(() => { }, () => `Setting ${this.debugName}`));
+        }
+        try {
+            this._isUpToDate = false;
+            this._setValue(value);
+            if (change !== undefined) {
+                this._deltas.push(change);
+            }
+            tx.updateObserver({
+                beginUpdate: () => this._beginUpdate(),
+                endUpdate: () => this._endUpdate(),
+                handleChange: (observable, change) => { },
+                handlePossibleChange: (observable) => { },
+            }, this);
+            if (this._updateCounter > 1) {
+                for (const observer of this.observers) {
+                    observer.handlePossibleChange(this);
+                }
+            }
+        }
+        finally {
+            if (_tx) {
+                _tx.finish();
+            }
+        }
+    }
+    toString() {
+        return `${this.debugName}: ${this._value}`;
+    }
+    _setValue(newValue) {
+        this._value = newValue;
+    }
+}
+export { LazyObservableValue };

package/vscode/src/vs/base/common/observableInternal/promise.js

@@ -20,6 +20,9 @@ class ObservableLazy {
     }
 }
 class ObservablePromise {
+    static fromFn(fn) {
+        return ( new ObservablePromise(fn()));
+    }
     constructor(promise) {
         this._value = observableValue(this, undefined);
         this.promiseResult = this._value;

package/vscode/src/vs/base/common/observableInternal/utils.d.ts

@@ -0,0 +1,7 @@
+import { IObservable, ITransaction } from './base.js';
+
+interface IObservableSignal<TChange> extends IObservable<void, TChange> {
+    trigger(tx: ITransaction | undefined, change: TChange): void;
+}
+
+export type { IObservableSignal };

package/vscode/src/vs/base/common/observableInternal/utils.js

@@ -1,9 +1,11 @@
 import { Event } from '../event.js';
 import { toDisposable, DisposableStore } from '../lifecycle.js';
-import './autorun.js';
+import { autorunOpts } from './autorun.js';
 import { ConvenientObservable, BaseObservable, subtransaction, transaction, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
-import { getFunctionName, DebugNameData } from './debugName.js';
+import { DebugNameData, getDebugName } from './debugName.js';
 import { derivedOpts, derived } from './derived.js';
+import { BugIndicatingError } from '../errors.js';
+import { strictEquals } from '../equals.js';
 function constObservable(value) {
     return ( new ConstObservable(value));
 }
@@ -33,23 +35,38 @@ function observableFromPromise(promise) {
     });
     return observable;
 }
-function observableFromEvent(event, getValue) {
-    return ( new FromEventObservable(event, getValue));
+function observableFromEvent(...args) {
+    let owner;
+    let event;
+    let getValue;
+    if (args.length === 3) {
+        [owner, event, getValue] = args;
+    }
+    else {
+        [event, getValue] = args;
+    }
+    return ( new FromEventObservable(( new DebugNameData(owner, undefined, getValue)), event, getValue, () => FromEventObservable.globalTransaction, strictEquals));
+}
+function observableFromEventOpts(options, event, getValue) {
+    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals));
 }
 class FromEventObservable extends BaseObservable {
-    constructor(event, _getValue) {
+    constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator) {
         super();
+        this._debugNameData = _debugNameData;
         this.event = event;
         this._getValue = _getValue;
+        this._getTransaction = _getTransaction;
+        this._equalityComparator = _equalityComparator;
         this.hasValue = false;
         this.handleEvent = (args) => {
             const newValue = this._getValue(args);
             const oldValue = this.value;
-            const didChange = !this.hasValue || oldValue !== newValue;
+            const didChange = !this.hasValue || !(this._equalityComparator(oldValue, newValue));
             if (didChange) {
                 this.value = newValue;
                 if (this.hasValue) {
-                    subtransaction(FromEventObservable.globalTransaction, (tx) => {
+                    subtransaction(this._getTransaction(), (tx) => {
                         for (const o of this.observers) {
                             tx.updateObserver(o, this);
                             o.handleChange(this, undefined);
@@ -64,7 +81,7 @@ class FromEventObservable extends BaseObservable {
         };
     }
     getDebugName() {
-        return getFunctionName(this._getValue);
+        return this._debugNameData.getDebugName(this);
     }
     get debugName() {
         const name = this.getDebugName();
@@ -150,6 +167,9 @@ class ObservableSignal extends BaseObservable {
     get debugName() {
         return ( new DebugNameData(this._owner, this._debugName, undefined)).getDebugName(this) ?? 'Observable Signal';
     }
+    toString() {
+        return this.debugName;
+    }
     constructor(_debugName, _owner) {
         super();
         this._debugName = _debugName;
@@ -233,7 +253,7 @@ class KeepAliveObserver {
 }
 function derivedObservableWithCache(owner, computeFn) {
     let lastValue = undefined;
-    const observable = derived(owner, reader => {
+    const observable = derivedOpts({ owner, debugReferenceFn: computeFn }, reader => {
         lastValue = computeFn(reader, lastValue);
         return lastValue;
     });
@@ -323,10 +343,42 @@ class ValueWithChangeEventFromObservable {
         return this.observable.get();
     }
 }
-function observableFromValueWithChangeEvent(_owner, value) {
+function observableFromValueWithChangeEvent(owner, value) {
     if (value instanceof ValueWithChangeEventFromObservable) {
         return value.observable;
     }
-    return observableFromEvent(value.onDidChange, () => value.value);
+    return observableFromEvent(owner, value.onDidChange, () => value.value);
+}
+function latestChangedValue(owner, observables) {
+    if (observables.length === 0) {
+        throw ( new BugIndicatingError());
+    }
+    let hasLastChangedValue = false;
+    let lastChangedValue = undefined;
+    const result = observableFromEvent(owner, cb => {
+        const store = ( new DisposableStore());
+        for (const o of observables) {
+            store.add(autorunOpts({ debugName: () => getDebugName(result, ( new DebugNameData(owner, undefined, undefined))) + '.updateLastChangedValue' }, reader => {
+                hasLastChangedValue = true;
+                lastChangedValue = o.read(reader);
+                cb();
+            }));
+        }
+        store.add({
+            dispose() {
+                hasLastChangedValue = false;
+                lastChangedValue = undefined;
+            },
+        });
+        return store;
+    }, () => {
+        if (hasLastChangedValue) {
+            return lastChangedValue;
+        }
+        else {
+            return observables[observables.length - 1].get();
+        }
+    });
+    return result;
 }
-export { FromEventObservable, KeepAliveObserver, ValueWithChangeEventFromObservable, constObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromEvent, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };
+export { FromEventObservable, KeepAliveObserver, ValueWithChangeEventFromObservable, constObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };

package/vscode/src/vs/base/common/prefixTree.d.ts

@@ -0,0 +1,52 @@
+declare const unset: unique symbol;
+interface IPrefixTreeNode<T> {
+    /** Possible children of the node. */
+    children?: ReadonlyMap<string, Node<T>>;
+    /** The value if data exists for this node in the tree. Mutable. */
+    value: T | undefined;
+}
+/**
+ * A simple prefix tree implementation where a value is stored based on
+ * well-defined prefix segments.
+ */
+declare class WellDefinedPrefixTree<V> {
+    private readonly root;
+    private _size;
+    get size(): number;
+    /** Gets the top-level nodes of the tree */
+    get nodes(): Iterable<IPrefixTreeNode<V>>;
+    /**
+     * Inserts a new value in the prefix tree.
+     * @param onNode - called for each node as we descend to the insertion point,
+     * including the insertion point itself.
+     */
+    insert(key: Iterable<string>, value: V, onNode?: (n: IPrefixTreeNode<V>) => void): void;
+    /** Mutates a value in the prefix tree. */
+    mutate(key: Iterable<string>, mutate: (value?: V) => V): void;
+    /** Mutates nodes along the path in the prefix tree. */
+    mutatePath(key: Iterable<string>, mutate: (node: IPrefixTreeNode<V>) => void): void;
+    /** Deletes a node from the prefix tree, returning the value it contained. */
+    delete(key: Iterable<string>): V | undefined;
+    /** Deletes a subtree from the prefix tree, returning the values they contained. */
+    deleteRecursive(key: Iterable<string>): Iterable<V>;
+    /** Gets a value from the tree. */
+    find(key: Iterable<string>): V | undefined;
+    /** Gets whether the tree has the key, or a parent of the key, already inserted. */
+    hasKeyOrParent(key: Iterable<string>): boolean;
+    /** Gets whether the tree has the given key or any children. */
+    hasKeyOrChildren(key: Iterable<string>): boolean;
+    /** Gets whether the tree has the given key. */
+    hasKey(key: Iterable<string>): boolean;
+    private getPathToKey;
+    private opNode;
+    /** Returns an iterable of the tree values in no defined order. */
+    values(): Generator<V, void, unknown>;
+}
+declare class Node<T> implements IPrefixTreeNode<T> {
+    children?: Map<string, Node<T>>;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    _value: T | typeof unset;
+}
+
+export { type IPrefixTreeNode, WellDefinedPrefixTree };

package/vscode/src/vs/base/common/product.d.ts

@@ -166,6 +166,7 @@ interface IProductConfiguration {
     readonly extensionSyncedKeys?: {
         readonly [extensionId: string]: string[];
     };
+    readonly extensionsEnabledWithApiProposalVersion?: string[];
     readonly extensionEnabledApiProposals?: {
         readonly [extensionId: string]: string[];
     };

package/vscode/src/vs/base/parts/ipc/common/ipc.js

@@ -283,7 +283,7 @@ class ChannelServer {
                     id, data: {
                         message: err.message,
                         name: err.name,
-                        stack: err.stack ? (err.stack.split ? err.stack.split('\n') : err.stack) : undefined
+                        stack: err.stack ? err.stack.split('\n') : undefined
                     }, type: ResponseType.PromiseError
                 });
             }

package/vscode/src/vs/editor/browser/config/charWidthReader.js

@@ -26,7 +26,7 @@ class DomCharWidthReader {
         this._createDomElements();
         targetWindow.document.body.appendChild(this._container);
         this._readFromDomElements();
-        targetWindow.document.body.removeChild(this._container);
+        this._container?.remove();
         this._container = null;
         this._testElements = null;
     }

package/vscode/src/vs/editor/browser/controller/textAreaHandler.js

@@ -720,7 +720,7 @@ function measureText(targetDocument, text, fontInfo, tabSize) {
     container.appendChild(regularDomNode);
     targetDocument.body.appendChild(container);
     const res = regularDomNode.offsetWidth;
-    targetDocument.body.removeChild(container);
+    container.remove();
     return res;
 }
 export { TextAreaHandler };

package/vscode/src/vs/editor/browser/coreCommands.js

@@ -20,6 +20,7 @@ import { ContextKeyExpr } from '../../platform/contextkey/common/contextkey.js';
 import { KeybindingsRegistry, KeybindingWeight } from '../../platform/keybinding/common/keybindingsRegistry.js';
 import { EditorOption } from '../common/config/editorOptions.js';
 import { getActiveElement } from '../../base/browser/dom.js';
+import { EnterOperation } from '../common/cursor/cursorTypeEditOperations.js';
 const _moduleId = "vs/editor/browser/coreCommands";
 const CORE_WEIGHT = KeybindingWeight.EditorCore;
 class CoreEditorCommand extends EditorCommand {
@@ -1561,7 +1562,7 @@ var CoreEditingCommands;
         }
         runCoreEditingCommand(editor, viewModel, args) {
             editor.pushUndoStop();
-            editor.executeCommands(this.id, TypeOperations.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection)))));
+            editor.executeCommands(this.id, EnterOperation.lineBreakInsert(viewModel.cursorConfig, viewModel.model, ( (viewModel.getCursorStates().map(s => s.modelState.selection)))));
         }
     }));
     CoreEditingCommands.Outdent = registerEditorCommand(new (class extends CoreEditingCommand {

package/vscode/src/vs/editor/browser/observableCodeEditor.js

@@ -0,0 +1,230 @@
+import { equalsIfDefined, itemsEquals } from '../../base/common/equals.js';
+import { Disposable, toDisposable, DisposableStore } from '../../base/common/lifecycle.js';
+import { TransactionImpl, observableValue } from '../../base/common/observableInternal/base.js';
+import { derivedOpts, derivedWithSetter, derived } from '../../base/common/observableInternal/derived.js';
+import { autorunOpts, autorun, autorunWithStoreHandleChanges } from '../../base/common/observableInternal/autorun.js';
+import { observableFromEvent, observableSignal } from '../../base/common/observableInternal/utils.js';
+import '../../base/common/cancellation.js';
+import { observableValueOpts } from '../../base/common/observableInternal/api.js';
+import { EditorOption } from '../common/config/editorOptions.js';
+import { Position } from '../common/core/position.js';
+import { Selection } from '../common/core/selection.js';
+function observableCodeEditor(editor) {
+    return ObservableCodeEditor.get(editor);
+}
+class ObservableCodeEditor extends Disposable {
+    static { this._map = ( new Map()); }
+    static get(editor) {
+        let result = ObservableCodeEditor._map.get(editor);
+        if (!result) {
+            result = ( new ObservableCodeEditor(editor));
+            ObservableCodeEditor._map.set(editor, result);
+            const d = editor.onDidDispose(() => {
+                const item = ObservableCodeEditor._map.get(editor);
+                if (item) {
+                    ObservableCodeEditor._map.delete(editor);
+                    item.dispose();
+                    d.dispose();
+                }
+            });
+        }
+        return result;
+    }
+    _beginUpdate() {
+        this._updateCounter++;
+        if (this._updateCounter === 1) {
+            this._currentTransaction = ( new TransactionImpl(() => {
+            }));
+        }
+    }
+    _endUpdate() {
+        this._updateCounter--;
+        if (this._updateCounter === 0) {
+            const t = this._currentTransaction;
+            this._currentTransaction = undefined;
+            t.finish();
+        }
+    }
+    constructor(editor) {
+        super();
+        this.editor = editor;
+        this._updateCounter = 0;
+        this._currentTransaction = undefined;
+        this._model = observableValue(this, this.editor.getModel());
+        this.model = this._model;
+        this.isReadonly = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.readOnly));
+        this._versionId = observableValueOpts({ owner: this, lazy: true }, this.editor.getModel()?.getVersionId() ?? null);
+        this.versionId = this._versionId;
+        this._selections = observableValueOpts({ owner: this, equalsFn: equalsIfDefined(itemsEquals(Selection.selectionsEqual)), lazy: true }, this.editor.getSelections() ?? null);
+        this.selections = this._selections;
+        this.positions = derivedOpts({ owner: this, equalsFn: equalsIfDefined(itemsEquals(Position.equals)) }, reader => this.selections.read(reader)?.map(s => s.getStartPosition()) ?? null);
+        this.isFocused = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidFocusEditorWidget(e);
+            const d2 = this.editor.onDidBlurEditorWidget(e);
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.hasWidgetFocus());
+        this.value = derivedWithSetter(this, reader => { this.versionId.read(reader); return this.model.read(reader)?.getValue() ?? ''; }, (value, tx) => {
+            const model = this.model.get();
+            if (model !== null) {
+                if (value !== model.getValue()) {
+                    model.setValue(value);
+                }
+            }
+        });
+        this.valueIsEmpty = derived(this, reader => { this.versionId.read(reader); return this.editor.getModel()?.getValueLength() === 0; });
+        this.cursorSelection = derivedOpts({ owner: this, equalsFn: equalsIfDefined(Selection.selectionsEqual) }, reader => this.selections.read(reader)?.[0] ?? null);
+        this.cursorPosition = derivedOpts({ owner: this, equalsFn: Position.equals }, reader => this.selections.read(reader)?.[0]?.getPosition() ?? null);
+        this.onDidType = observableSignal(this);
+        this.scrollTop = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollTop());
+        this.scrollLeft = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollLeft());
+        this.layoutInfo = observableFromEvent(this.editor.onDidLayoutChange, () => this.editor.getLayoutInfo());
+        this.contentWidth = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentWidth());
+        this._overlayWidgetCounter = 0;
+        this._register(this.editor.onBeginUpdate(() => this._beginUpdate()));
+        this._register(this.editor.onEndUpdate(() => this._endUpdate()));
+        this._register(this.editor.onDidChangeModel(() => {
+            this._beginUpdate();
+            try {
+                this._model.set(this.editor.getModel(), this._currentTransaction);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidType((e) => {
+            this._beginUpdate();
+            try {
+                this._forceUpdate();
+                this.onDidType.trigger(this._currentTransaction, e);
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidChangeModelContent(e => {
+            this._beginUpdate();
+            try {
+                this._versionId.set(this.editor.getModel()?.getVersionId() ?? null, this._currentTransaction, e);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidChangeCursorSelection(e => {
+            this._beginUpdate();
+            try {
+                this._selections.set(this.editor.getSelections(), this._currentTransaction, e);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+    }
+    forceUpdate(cb) {
+        this._beginUpdate();
+        try {
+            this._forceUpdate();
+            if (!cb) {
+                return undefined;
+            }
+            return cb(this._currentTransaction);
+        }
+        finally {
+            this._endUpdate();
+        }
+    }
+    _forceUpdate() {
+        this._beginUpdate();
+        try {
+            this._model.set(this.editor.getModel(), this._currentTransaction);
+            this._versionId.set(this.editor.getModel()?.getVersionId() ?? null, this._currentTransaction, undefined);
+            this._selections.set(this.editor.getSelections(), this._currentTransaction, undefined);
+        }
+        finally {
+            this._endUpdate();
+        }
+    }
+    getOption(id) {
+        return observableFromEvent(this, cb => this.editor.onDidChangeConfiguration(e => {
+            if (e.hasChanged(id)) {
+                cb(undefined);
+            }
+        }), () => this.editor.getOption(id));
+    }
+    setDecorations(decorations) {
+        const d = ( new DisposableStore());
+        const decorationsCollection = this.editor.createDecorationsCollection();
+        d.add(autorunOpts({ owner: this, debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+            const d = decorations.read(reader);
+            decorationsCollection.set(d);
+        }));
+        d.add({
+            dispose: () => {
+                decorationsCollection.clear();
+            }
+        });
+        return d;
+    }
+    createOverlayWidget(widget) {
+        const overlayWidgetId = 'observableOverlayWidget' + (this._overlayWidgetCounter++);
+        const w = {
+            getDomNode: () => widget.domNode,
+            getPosition: () => widget.position.get(),
+            getId: () => overlayWidgetId,
+            allowEditorOverflow: widget.allowEditorOverflow,
+            getMinContentWidthInPx: () => widget.minContentWidthInPx.get(),
+        };
+        this.editor.addOverlayWidget(w);
+        const d = autorun(reader => {
+            widget.position.read(reader);
+            widget.minContentWidthInPx.read(reader);
+            this.editor.layoutOverlayWidget(w);
+        });
+        return toDisposable(() => {
+            d.dispose();
+            this.editor.removeOverlayWidget(w);
+        });
+    }
+}
+function reactToChange(observable, cb) {
+    return autorunWithStoreHandleChanges({
+        createEmptyChangeSummary: () => ({ deltas: [], didChange: false }),
+        handleChange: (context, changeSummary) => {
+            if (context.didChange(observable)) {
+                const e = context.change;
+                if (e !== undefined) {
+                    changeSummary.deltas.push(e);
+                }
+                changeSummary.didChange = true;
+            }
+            return true;
+        },
+    }, (reader, changeSummary) => {
+        const value = observable.read(reader);
+        if (changeSummary.didChange) {
+            cb(value, changeSummary.deltas);
+        }
+    });
+}
+function reactToChangeWithStore(observable, cb) {
+    const store = ( new DisposableStore());
+    const disposable = reactToChange(observable, (value, deltas) => {
+        store.clear();
+        cb(value, deltas, store);
+    });
+    return {
+        dispose() {
+            disposable.dispose();
+            store.dispose();
+        }
+    };
+}
+export { ObservableCodeEditor, observableCodeEditor, reactToChange, reactToChangeWithStore };

package/vscode/src/vs/editor/browser/services/abstractCodeEditorService.js

@@ -263,7 +263,7 @@ class RefCountedStyleSheet {
     unref() {
         this._refCount--;
         if (this._refCount === 0) {
-            this._styleSheet.parentNode?.removeChild(this._styleSheet);
+            this._styleSheet.remove();
             this._parent._removeEditorStyleSheets(this._editorId);
         }
     }