@codingame/monaco-vscode-api 6.0.2 → 7.0.0

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

@@ -6,11 +6,61 @@ function itemsEquals(itemEquals = strictEquals) {
 function itemEquals() {
     return (a, b) => a.equals(b);
 }
-function equalsIfDefined(v1, v2, equals) {
-    if (!v1 || !v2) {
-        return v1 === v2;
+function equalsIfDefined(equalsOrV1, v2, equals) {
+    if (equals !== undefined) {
+        const v1 = equalsOrV1;
+        if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+            return v2 === v1;
+        }
+        return equals(v1, v2);
+    }
+    else {
+        const equals = equalsOrV1;
+        return (v1, v2) => {
+            if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+                return v2 === v1;
+            }
+            return equals(v1, v2);
+        };
+    }
+}
+function structuralEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!structuralEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && typeof a === 'object' && b && typeof b === 'object') {
+        if (Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
+            const aObj = a;
+            const bObj = b;
+            const keysA = ( Object.keys(aObj));
+            const keysB = ( Object.keys(bObj));
+            const keysBSet = ( new Set(keysB));
+            if (keysA.length !== keysB.length) {
+                return false;
+            }
+            for (const key of keysA) {
+                if (!( keysBSet.has(key))) {
+                    return false;
+                }
+                if (!structuralEquals(aObj[key], bObj[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
-    return equals(v1, v2);
+    return false;
 }
 function getStructuralKey(t) {
     return JSON.stringify(toNormalizedJsonStructure(t));
@@ -41,4 +91,4 @@ function toNormalizedJsonStructure(t) {
     }
     return t;
 }
-export { equalsIfDefined, getStructuralKey, itemEquals, itemsEquals, strictEquals };
+export { equalsIfDefined, getStructuralKey, itemEquals, itemsEquals, strictEquals, structuralEquals };

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

@@ -71,6 +71,19 @@ function transformErrorForSerialization(error) {
     }
     return error;
 }
+function transformErrorFromSerialization(data) {
+    let error;
+    if (data.noTelemetry) {
+        error = ( new ErrorNoTelemetry());
+    }
+    else {
+        error = ( new Error());
+        error.name = data.name;
+    }
+    error.message = data.message;
+    error.stack = data.stack;
+    return error;
+}
 const canceledName = 'Canceled';
 function isCancellationError(error) {
     if (error instanceof CancellationError) {
@@ -162,4 +175,4 @@ class BugIndicatingError extends Error {
         Object.setPrototypeOf(this, BugIndicatingError.prototype);
     }
 }
-export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, ReadonlyError, canceled, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization };
+export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, ReadonlyError, canceled, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization, transformErrorFromSerialization };

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

@@ -439,7 +439,8 @@ function setGlobalLeakWarningThreshold(n) {
     };
 }
 class LeakageMonitor {
-    constructor(_errorHandler, threshold, name = ( Math.random().toString(18)).slice(2, 5)) {
+    static { this._idPool = 1; }
+    constructor(_errorHandler, threshold, name = ( (LeakageMonitor._idPool++).toString(16)).padStart(3, '0')) {
         this._errorHandler = _errorHandler;
         this.threshold = threshold;
         this.name = name;

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

@@ -1,3 +1,4 @@
+import { SetWithKey } from './collections.js';
 import { ArrayNavigator } from './navigator.js';
 class HistoryNavigator {
     constructor(history = [], limit = 10) {
@@ -79,8 +80,9 @@ class HistoryNavigator {
 }
 class HistoryNavigator2 {
     get size() { return this._size; }
-    constructor(history, capacity = 10) {
+    constructor(history, capacity = 10, identityFn = t => t) {
         this.capacity = capacity;
+        this.identityFn = identityFn;
         if (history.length < 1) {
             throw ( new Error('not supported'));
         }
@@ -90,7 +92,7 @@ class HistoryNavigator2 {
             previous: undefined,
             next: undefined
         };
-        this.valueSet = ( new Set([history[0]]));
+        this.valueSet = ( new SetWithKey([history[0]], identityFn));
         for (let i = 1; i < history.length; i++) {
             this.add(history[i]);
         }
@@ -119,7 +121,7 @@ class HistoryNavigator2 {
         }
     }
     replaceLast(value) {
-        if (this.tail.value === value) {
+        if (this.identityFn(this.tail.value) === this.identityFn(value)) {
             return value;
         }
         const oldValue = this.tail.value;
@@ -181,8 +183,9 @@ class HistoryNavigator2 {
     }
     _deleteFromList(value) {
         let temp = this.head;
+        const valueKey = this.identityFn(value);
         while (temp !== this.tail) {
-            if (temp.value === value) {
+            if (this.identityFn(temp.value) === valueKey) {
                 if (temp === this.head) {
                     this.head = this.head.next;
                     this.head.previous = undefined;

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

@@ -41,8 +41,9 @@ var Iterable;
     }
     Iterable.first = first;
     function some(iterable, predicate) {
+        let i = 0;
         for (const element of iterable) {
-            if (predicate(element)) {
+            if (predicate(element, i++)) {
                 return true;
             }
         }
@@ -73,6 +74,13 @@ var Iterable;
         }
     }
     Iterable.map = map;
+    function* flatMap(iterable, fn) {
+        let index = 0;
+        for (const element of iterable) {
+            yield* fn(element, index++);
+        }
+    }
+    Iterable.flatMap = flatMap;
     function* concat(...iterables) {
         for (const iterable of iterables) {
             yield* iterable;

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

@@ -0,0 +1,41 @@
+import { URI } from './uri.js';
+
+interface ResourceMapKeyFn {
+    (resource: URI): string;
+}
+declare class ResourceMap<T> implements Map<URI, T> {
+    private static readonly defaultToKey;
+    readonly [Symbol.toStringTag] = "ResourceMap";
+    private readonly map;
+    private readonly toKey;
+    /**
+     *
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(other?: ResourceMap<T>, toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(entries?: readonly (readonly [URI, T])[], toKey?: ResourceMapKeyFn);
+    set(resource: URI, value: T): this;
+    get(resource: URI): T | undefined;
+    has(resource: URI): boolean;
+    get size(): number;
+    clear(): void;
+    delete(resource: URI): boolean;
+    forEach(clb: (value: T, key: URI, map: Map<URI, T>) => void, thisArg?: any): void;
+    values(): IterableIterator<T>;
+    keys(): IterableIterator<URI>;
+    entries(): IterableIterator<[URI, T]>;
+    [Symbol.iterator](): IterableIterator<[URI, T]>;
+}
+
+export { ResourceMap };

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

@@ -52,4 +52,21 @@ class SlidingWindowAverage {
         return this._val;
     }
 }
-export { Counter, MovingAverage, SlidingWindowAverage, clamp, rot };
+function isPointWithinTriangle(x, y, ax, ay, bx, by, cx, cy) {
+    const v0x = cx - ax;
+    const v0y = cy - ay;
+    const v1x = bx - ax;
+    const v1y = by - ay;
+    const v2x = x - ax;
+    const v2y = y - ay;
+    const dot00 = v0x * v0x + v0y * v0y;
+    const dot01 = v0x * v1x + v0y * v1y;
+    const dot02 = v0x * v2x + v0y * v2y;
+    const dot11 = v1x * v1x + v1y * v1y;
+    const dot12 = v1x * v2x + v1y * v2y;
+    const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+    const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+    const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+    return u >= 0 && v >= 0 && u + v < 1;
+}
+export { Counter, MovingAverage, SlidingWindowAverage, clamp, isPointWithinTriangle, rot };

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

@@ -0,0 +1,11 @@
+import { strictEquals } from '../equals.js';
+import { ObservableValue } from './base.js';
+import { DebugNameData } from './debugName.js';
+import { LazyObservableValue } from './lazyObservableValue.js';
+function observableValueOpts(options, initialValue) {
+    if (options.lazy) {
+        return ( new LazyObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+    }
+    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+}
+export { observableValueOpts };

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

@@ -10,6 +10,23 @@ function autorunOpts(options, fn) {
 function autorunHandleChanges(options, fn) {
     return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.createEmptyChangeSummary, options.handleChange));
 }
+function autorunWithStoreHandleChanges(options, fn) {
+    const store = ( new DisposableStore());
+    const disposable = autorunHandleChanges({
+        owner: options.owner,
+        debugName: options.debugName,
+        debugReferenceFn: options.debugReferenceFn ?? fn,
+        createEmptyChangeSummary: options.createEmptyChangeSummary,
+        handleChange: options.handleChange,
+    }, (reader, changeSummary) => {
+        store.clear();
+        fn(reader, changeSummary, store);
+    });
+    return toDisposable(() => {
+        disposable.dispose();
+        store.dispose();
+    });
+}
 function autorunWithStore(fn) {
     const store = ( new DisposableStore());
     const disposable = autorunOpts({
@@ -138,4 +155,4 @@ class AutorunObserver {
 ( (function(autorun) {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {})));
-export { AutorunObserver, autorun, autorunHandleChanges, autorunOpts, autorunWithStore };
+export { AutorunObserver, autorun, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };

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

@@ -114,5 +114,12 @@ interface IObserver {
      */
     handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
 }
+interface ITransaction {
+    /**
+     * Calls {@link Observer.beginUpdate} immediately
+     * and {@link Observer.endUpdate} when the transaction ends.
+     */
+    updateObserver(observer: IObserver, observable: IObservable<any, any>): void;
+}
 
-export type { IObservable, IObserver, IReader };
+export type { IObservable, IObserver, IReader, ITransaction };

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

@@ -1,5 +1,5 @@
 import { strictEquals } from '../equals.js';
-import { DebugNameData, getFunctionName } from './debugName.js';
+import { getFunctionName, DebugNameData } from './debugName.js';
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
     _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
@@ -159,9 +159,6 @@ function observableValue(nameOrOwner, initialValue) {
     }
     return ( new ObservableValue(debugNameData, initialValue, strictEquals));
 }
-function observableValueOpts(options, initialValue) {
-    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
-}
 class ObservableValue extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
@@ -227,4 +224,4 @@ class DisposableObservableValue extends ObservableValue {
         this._value?.dispose();
     }
 }
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, observableValueOpts, subtransaction, transaction };
+export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction };

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

@@ -47,15 +47,25 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         owner = computeFnOrOwner;
         computeFn = computeFnOrUndefined;
     }
-    const store = ( new DisposableStore());
+    let store = undefined;
     return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
-        store.clear();
+        if (!store) {
+            store = ( new DisposableStore());
+        }
+        else {
+            store.clear();
+        }
         const result = computeFn(r);
         if (result) {
             store.add(result);
         }
         return result;
-    }, undefined, undefined, () => store.dispose(), strictEquals));
+    }, undefined, undefined, () => {
+        if (store) {
+            store.dispose();
+            store = undefined;
+        }
+    }, strictEquals));
 }
 var DerivedState;
 ( (function(DerivedState) {

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 };