@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -479,7 +479,7 @@ function fuzzyScore(pattern, patternLow, patternStart, word, wordLow, wordStart,
                 score = _doScore(pattern, patternLow, patternPos, patternStart, word, wordLow, wordPos, wordLen, wordStart, _diag[row - 1][column - 1] === 0, hasStrongFirstMatch);
             }
             let diagScore = 0;
-            if (score !== Number.MAX_SAFE_INTEGER) {
+            if (score !== Number.MIN_SAFE_INTEGER) {
                 canComeDiag = true;
                 diagScore = score + _table[row - 1][column - 1];
             }

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

@@ -14,7 +14,7 @@ export declare namespace Iterable {
     function filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T>;
     function map<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => R): Iterable<R>;
     function flatMap<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => Iterable<R>): Iterable<R>;
-    function concat<T>(...iterables: Iterable<T>[]): Iterable<T>;
+    function concat<T>(...iterables: (Iterable<T> | T)[]): Iterable<T>;
     function reduce<T, R>(iterable: Iterable<T>, reducer: (previousValue: R, currentValue: T) => R, initialValue: R): R;
     function slice<T>(arr: ReadonlyArray<T>, from: number, to?: number): Iterable<T>;
     function consume<T>(iterable: Iterable<T>, atMost?: number): [

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

@@ -1,4 +1,5 @@
 
+import { isIterable } from './types.js';
 
 var Iterable;
 (function (Iterable) {
@@ -84,8 +85,13 @@ var Iterable;
     }
     Iterable.flatMap = flatMap;
     function* concat(...iterables) {
-        for (const iterable of iterables) {
-            yield* iterable;
+        for (const item of iterables) {
+            if (isIterable(item)) {
+                yield* item;
+            }
+            else {
+                yield item;
+            }
         }
     }
     Iterable.concat = concat;

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

@@ -4,6 +4,13 @@ export interface IDisposableTracker {
     markAsDisposed(disposable: IDisposable): void;
     markAsSingleton(disposable: IDisposable): void;
 }
+export declare class GCBasedDisposableTracker implements IDisposableTracker {
+    private readonly _registry;
+    trackDisposable(disposable: IDisposable): void;
+    setParent(child: IDisposable, parent: IDisposable | null): void;
+    markAsDisposed(disposable: IDisposable): void;
+    markAsSingleton(disposable: IDisposable): void;
+}
 export interface DisposableInfo {
     value: IDisposable;
     source: string | null;

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

@@ -157,24 +157,16 @@ export declare class SetMap<K, V> {
     get(key: K): ReadonlySet<V>;
 }
 export declare function mapsStrictEqualIgnoreOrder(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean;
-export declare class TwoKeyMap<TFirst extends string | number, TSecond extends string | number, TValue> {
+export declare class NKeyMap<TValue, TKeys extends (string | boolean | number)[]> {
     private _data;
-    set(first: TFirst, second: TSecond, value: TValue): void;
-    get(first: TFirst, second: TSecond): TValue | undefined;
+    set(value: TValue, ...keys: [
+        ...TKeys
+    ]): void;
+    get(...keys: [
+        ...TKeys
+    ]): TValue | undefined;
     clear(): void;
     values(): IterableIterator<TValue>;
-}
-export declare class ThreeKeyMap<TFirst extends string | number, TSecond extends string | number, TThird extends string | number, TValue> {
-    private _data;
-    set(first: TFirst, second: TSecond, third: TThird, value: TValue): void;
-    get(first: TFirst, second: TSecond, third: TThird): TValue | undefined;
-    clear(): void;
-    values(): IterableIterator<TValue>;
-}
-export declare class FourKeyMap<TFirst extends string | number, TSecond extends string | number, TThird extends string | number, TFourth extends string | number, TValue> {
-    private _data;
-    set(first: TFirst, second: TSecond, third: TThird, fourth: TFourth, value: TValue): void;
-    get(first: TFirst, second: TSecond, third: TThird, fourth: TFourth): TValue | undefined;
-    clear(): void;
+    toString(): string;
 }
 export {};

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

@@ -679,49 +679,62 @@ function mapsStrictEqualIgnoreOrder(a, b) {
     }
     return true;
 }
-class TwoKeyMap {
+class NKeyMap {
     constructor() {
-        this._data = {};
+        this._data = ( new Map());
     }
-    set(first, second, value) {
-        if (!this._data[first]) {
-            this._data[first] = {};
+    set(value, ...keys) {
+        let currentMap = this._data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!( currentMap.has(keys[i]))) {
+                currentMap.set(keys[i], ( new Map()));
+            }
+            currentMap = currentMap.get(keys[i]);
         }
-        this._data[first][second] = value;
+        currentMap.set(keys[keys.length - 1], value);
     }
-    get(first, second) {
-        return this._data[first]?.[second];
+    get(...keys) {
+        let currentMap = this._data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!( currentMap.has(keys[i]))) {
+                return undefined;
+            }
+            currentMap = currentMap.get(keys[i]);
+        }
+        return currentMap.get(keys[keys.length - 1]);
     }
     clear() {
-        this._data = {};
+        this._data.clear();
     }
     *values() {
-        for (const first in this._data) {
-            for (const second in this._data[first]) {
-                const value = this._data[first][second];
-                if (value) {
+        function* iterate(map) {
+            for (const value of ( map.values())) {
+                if (value instanceof Map) {
+                    yield* iterate(value);
+                }
+                else {
                     yield value;
                 }
             }
         }
+        yield* iterate(this._data);
     }
-}
-class FourKeyMap {
-    constructor() {
-        this._data = ( new TwoKeyMap());
-    }
-    set(first, second, third, fourth, value) {
-        if (!this._data.get(first, second)) {
-            this._data.set(first, second, ( new TwoKeyMap()));
-        }
-        this._data.get(first, second).set(third, fourth, value);
-    }
-    get(first, second, third, fourth) {
-        return this._data.get(first, second)?.get(third, fourth);
-    }
-    clear() {
-        this._data.clear();
+    toString() {
+        const printMap = (map, depth) => {
+            let result = '';
+            for (const [key, value] of map) {
+                result += `${'  '.repeat(depth)}${key}: `;
+                if (value instanceof Map) {
+                    result += '\n' + printMap(value, depth + 1);
+                }
+                else {
+                    result += `${value}\n`;
+                }
+            }
+            return result;
+        };
+        return printMap(this._data, 0);
     }
 }
 
-export { BidirectionalMap, CounterSet, FourKeyMap, LRUCache, LinkedMap, MRUCache, ResourceMap, ResourceSet, SetMap, Touch, TwoKeyMap, getOrSet, mapsStrictEqualIgnoreOrder };
+export { BidirectionalMap, CounterSet, LRUCache, LinkedMap, MRUCache, NKeyMap, ResourceMap, ResourceSet, SetMap, Touch, getOrSet, mapsStrictEqualIgnoreOrder };

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

@@ -68,10 +68,10 @@ declare class RemoteAuthoritiesImpl {
     rewrite(uri: URI): URI;
 }
 export declare const RemoteAuthorities: RemoteAuthoritiesImpl;
-export declare function getServerRootPath(product: {
+export declare function getServerProductSegment(product: {
     quality?: string;
     commit?: string;
-}, basePath: string | undefined): string;
+}): string;
 export type AppResourcePath = (`a${string}` | `b${string}` | `c${string}` | `d${string}` | `e${string}` | `f${string}` | `g${string}` | `h${string}` | `i${string}` | `j${string}` | `k${string}` | `l${string}` | `m${string}` | `n${string}` | `o${string}` | `p${string}` | `q${string}` | `r${string}` | `s${string}` | `t${string}` | `u${string}` | `v${string}` | `w${string}` | `x${string}` | `y${string}` | `z${string}`);
 export declare const builtinExtensionsPath: AppResourcePath;
 export declare const nodeModulesPath: AppResourcePath;

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

@@ -79,7 +79,7 @@ class RemoteAuthoritiesImpl {
         this._delegate = delegate;
     }
     setServerRootPath(product, serverBasePath) {
-        this._serverRootPath = getServerRootPath(product, serverBasePath);
+        this._serverRootPath = posix.join(serverBasePath ?? '/', getServerProductSegment(product));
     }
     getServerRootPath() {
         return this._serverRootPath;
@@ -127,8 +127,8 @@ class RemoteAuthoritiesImpl {
     }
 }
 const RemoteAuthorities = ( new RemoteAuthoritiesImpl());
-function getServerRootPath(product, basePath) {
-    return posix.join(basePath ?? '/', `${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`);
+function getServerProductSegment(product) {
+    return `${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
 }
 const nodeModulesPath = 'vs/../../node_modules';
 const VSCODE_AUTHORITY = 'vscode-app';
@@ -254,4 +254,4 @@ var COI;
     COI.addSearchParam = addSearchParam;
 })(COI || (COI = {}));
 
-export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, getServerRootPath, matchesScheme, matchesSomeScheme, nodeModulesPath };
+export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, getServerProductSegment, matchesScheme, matchesSomeScheme, nodeModulesPath };

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

@@ -21,3 +21,4 @@ export declare class SlidingWindowAverage {
     get value(): number;
 }
 export declare function isPointWithinTriangle(x: number, y: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean;
+export declare const randomInt: (max: number, min?: number) => number;

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

@@ -1,4 +1,4 @@
-import { IChangeContext, IObservable, IObserver, IReader } from "./base.js";
+import { IChangeContext, IObservable, IObservableWithChange, IObserver, IReader } from "./base.js";
 import { DebugNameData, IDebugNameData } from "./debugName.js";
 import { DisposableStore, IDisposable } from "./commonFacade/deps.js";
 export declare function autorun(fn: (reader: IReader) => void): IDisposable;
@@ -39,7 +39,7 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     beginUpdate(): void;
     endUpdate(): void;
     handlePossibleChange(observable: IObservable<any>): void;
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
     private _isReaderValid;
     readObservable<T>(observable: IObservable<T>): T;
 }

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

@@ -48,6 +48,15 @@ function autorunWithStore(fn) {
         store.dispose();
     });
 }
+function autorunDelta(observable, handler) {
+    let _lastValue;
+    return autorunOpts({ debugReferenceFn: handler }, (reader) => {
+        const newValue = observable.read(reader);
+        const lastValue = _lastValue;
+        _lastValue = newValue;
+        handler({ lastValue, newValue });
+    });
+}
 function autorunIterableDelta(getValue, handler, getUniqueIdentifier = v => v) {
     const lastValues = ( new Map());
     return autorunOpts({ debugReferenceFn: getValue }, (reader) => {
@@ -93,6 +102,7 @@ class AutorunObserver {
         this.dependenciesToBeRemoved = ( new Set());
         this._isReaderValid = false;
         this.changeSummary = this.createChangeSummary?.();
+        getLogger()?.handleAutorunCreated(this);
         this._runIfNeeded();
         trackDisposable(this);
     }
@@ -131,6 +141,9 @@ class AutorunObserver {
             }
         }
         finally {
+            if (!isDisposed) {
+                getLogger()?.handleAutorunFinished(this);
+            }
             for (const o of this.dependenciesToBeRemoved) {
                 o.removeObserver(this);
             }
@@ -208,4 +221,4 @@ class AutorunObserver {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {}));
 
-export { AutorunObserver, autorun, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };
+export { AutorunObserver, autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };

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

@@ -2,7 +2,9 @@ import { DebugNameData, DebugOwner } from "./debugName.js";
 import { DisposableStore, EqualityComparer, IDisposable } from "./commonFacade/deps.js";
 import type { derivedOpts } from "./derived.js";
 import { keepObserved, recomputeInitiallyAndOnChange } from "./utils.js";
-export interface IObservable<T, TChange = unknown> {
+export interface IObservable<T> extends IObservableWithChange<T, unknown> {
+}
+export interface IObservableWithChange<T, TChange = unknown> {
     get(): T;
     reportChanges(): void;
     addObserver(observer: IObserver): void;
@@ -11,25 +13,26 @@ export interface IObservable<T, TChange = unknown> {
     map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
     map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
     flatten<TNew>(this: IObservable<IObservable<TNew>>): IObservable<TNew>;
+    log(): IObservableWithChange<T, TChange>;
     recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
     keepObserved(store: DisposableStore): IObservable<T>;
     readonly debugName: string;
     readonly TChange: TChange;
 }
 export interface IReader {
-    readObservable<T>(observable: IObservable<T, any>): T;
+    readObservable<T>(observable: IObservableWithChange<T, any>): T;
 }
 export interface IObserver {
     beginUpdate<T>(observable: IObservable<T>): void;
     endUpdate<T>(observable: IObservable<T>): void;
     handlePossibleChange<T>(observable: IObservable<T>): void;
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
 }
 export interface ISettable<T, TChange = void> {
     set(value: T, transaction: ITransaction | undefined, change: TChange): void;
 }
 export interface ITransaction {
-    updateObserver(observer: IObserver, observable: IObservable<any, any>): void;
+    updateObserver(observer: IObserver, observable: IObservableWithChange<any, any>): void;
 }
 declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
 export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
@@ -37,7 +40,7 @@ declare let _keepObserved: typeof keepObserved;
 export declare function _setKeepObserved(keepObserved: typeof _keepObserved): void;
 declare let _derived: typeof derivedOpts;
 export declare function _setDerivedOpts(derived: typeof _derived): void;
-export declare abstract class ConvenientObservable<T, TChange> implements IObservable<T, TChange> {
+export declare abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
     get TChange(): TChange;
     abstract get(): T;
     reportChanges(): void;
@@ -46,7 +49,8 @@ export declare abstract class ConvenientObservable<T, TChange> implements IObser
     read(reader: IReader | undefined): T;
     map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
     map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
-    flatten<TNew>(this: IObservable<IObservable<TNew, any>>): IObservable<TNew, unknown>;
+    log(): IObservableWithChange<T, TChange>;
+    flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew>;
     recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
     keepObserved(store: DisposableStore): IObservable<T>;
     abstract get debugName(): string;
@@ -72,7 +76,7 @@ export declare class TransactionImpl implements ITransaction {
     updateObserver(observer: IObserver, observable: IObservable<any>): void;
     finish(): void;
 }
-export interface ISettableObservable<T, TChange = void> extends IObservable<T, TChange>, ISettable<T, TChange> {
+export interface ISettableObservable<T, TChange = void> extends IObservableWithChange<T, TChange>, ISettable<T, TChange> {
 }
 export declare function observableValue<T, TChange = void>(name: string, initialValue: T): ISettableObservable<T, TChange>;
 export declare function observableValue<T, TChange = void>(owner: object, initialValue: T): ISettableObservable<T, TChange>;
@@ -96,9 +100,9 @@ export interface IChangeTracker {
     handleChange(context: IChangeContext): boolean;
 }
 export interface IChangeContext {
-    readonly changedObservable: IObservable<any, any>;
+    readonly changedObservable: IObservableWithChange<any, any>;
     readonly change: unknown;
-    didChange<T, TChange>(observable: IObservable<T, TChange>): this is {
+    didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is {
         change: TChange;
     };
 }

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

@@ -3,7 +3,7 @@ import { getFunctionName, DebugNameData } from './debugName.js';
 import { strictEquals } from '../equals.js';
 import '../event.js';
 import '../lifecycle.js';
-import { getLogger } from './logging.js';
+import { logObservable, getLogger } from './logging.js';
 
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
@@ -53,6 +53,10 @@ class ConvenientObservable {
             debugReferenceFn: fn,
         }, (reader) => fn(this.read(reader), reader));
     }
+    log() {
+        logObservable(this);
+        return this;
+    }
     flatten() {
         return _derived({
             owner: undefined,
@@ -140,6 +144,7 @@ class TransactionImpl {
         this._fn = _fn;
         this._getDebugName = _getDebugName;
         this.updatingObservers = [];
+        getLogger()?.handleBeginTransaction(this);
     }
     getDebugName() {
         if (this._getDebugName) {
@@ -158,6 +163,7 @@ class TransactionImpl {
             observer.endUpdate(observable);
         }
         this.updatingObservers = null;
+        getLogger()?.handleEndTransaction();
     }
 }
 function observableValue(nameOrOwner, initialValue) {

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

@@ -1,4 +1,4 @@
-import { BaseObservable, IChangeContext, IObservable, IObserver, IReader, ISettableObservable, ITransaction } from "./base.js";
+import { BaseObservable, IChangeContext, IObservable, IObservableWithChange, IObserver, IReader, ISettableObservable, ITransaction } from "./base.js";
 import { DebugNameData, DebugOwner, IDebugNameData } from "./debugName.js";
 import { DisposableStore, EqualityComparer, IDisposable } from "./commonFacade/deps.js";
 export declare function derived<T>(computeFn: (reader: IReader) => T): IObservable<T>;
@@ -39,13 +39,15 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     private _recomputeIfNeeded;
     toString(): string;
     beginUpdate<T>(_observable: IObservable<T>): void;
+    private _removedObserverToCallEndUpdateOn;
     endUpdate<T>(_observable: IObservable<T>): void;
-    handlePossibleChange<T>(observable: IObservable<T, unknown>): void;
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    handlePossibleChange<T>(observable: IObservable<T>): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
     private _isReaderValid;
     readObservable<T>(observable: IObservable<T>): T;
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
+    log(): IObservableWithChange<T, void>;
 }
 export declare class DerivedWithSetter<T, TChangeSummary = any> extends Derived<T, TChangeSummary> implements ISettableObservable<T> {
     readonly set: (value: T, tx: ITransaction | undefined) => void;

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

@@ -99,12 +99,15 @@ class Derived extends BaseObservable {
         this.changeSummary = undefined;
         this._isUpdating = false;
         this._isComputing = false;
+        this._removedObserverToCallEndUpdateOn = null;
         this._isReaderValid = false;
         this.changeSummary = this.createChangeSummary?.();
+        getLogger()?.handleDerivedCreated(this);
     }
     onLastObserverRemoved() {
         this.state = DerivedState.initial;
         this.value = undefined;
+        getLogger()?.handleDerivedCleared(this);
         for (const d of this.dependencies) {
             d.removeObserver(this);
         }
@@ -226,6 +229,13 @@ class Derived extends BaseObservable {
             for (const r of observers) {
                 r.endUpdate(this);
             }
+            if (this._removedObserverToCallEndUpdateOn) {
+                const observers = [...this._removedObserverToCallEndUpdateOn];
+                this._removedObserverToCallEndUpdateOn = null;
+                for (const r of observers) {
+                    r.endUpdate(this);
+                }
+            }
         }
         assertFn(() => this.updateCount >= 0);
     }
@@ -275,15 +285,32 @@ class Derived extends BaseObservable {
         const shouldCallBeginUpdate = !( this.observers.has(observer)) && this.updateCount > 0;
         super.addObserver(observer);
         if (shouldCallBeginUpdate) {
-            observer.beginUpdate(this);
+            if (this._removedObserverToCallEndUpdateOn && ( this._removedObserverToCallEndUpdateOn.has(observer))) {
+                this._removedObserverToCallEndUpdateOn.delete(observer);
+            }
+            else {
+                observer.beginUpdate(this);
+            }
         }
     }
     removeObserver(observer) {
-        const shouldCallEndUpdate = ( this.observers.has(observer)) && this.updateCount > 0;
+        if (( this.observers.has(observer)) && this.updateCount > 0) {
+            if (!this._removedObserverToCallEndUpdateOn) {
+                this._removedObserverToCallEndUpdateOn = ( new Set());
+            }
+            this._removedObserverToCallEndUpdateOn.add(observer);
+        }
         super.removeObserver(observer);
-        if (shouldCallEndUpdate) {
-            observer.endUpdate(this);
+    }
+    log() {
+        if (!getLogger()) {
+            super.log();
+            getLogger()?.handleDerivedCreated(this);
+        }
+        else {
+            super.log();
         }
+        return this;
     }
 }
 class DerivedWithSetter extends Derived {

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

@@ -1,8 +1,8 @@
 export { observableValueOpts } from "./api.js";
 export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from "./autorun.js";
-export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IChangeContext, type IChangeTracker, type IObservable, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
+export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IChangeContext, type IChangeTracker, type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./derived.js";
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./promise.js";
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/base/common/observableInternal/promise";
 export { derivedWithCancellationToken, waitForState } from "./utilsCancellation.js";
 export { constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, signalFromObservable, ValueWithChangeEventFromObservable, wasEventTriggeredRecently, type IObservableSignal, } from "./utils.js";
 export { type DebugOwner } from "./debugName.js";

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

@@ -1,5 +1,6 @@
 
 import { BaseObservable, TransactionImpl } from './base.js';
+import { getLogger } from './logging.js';
 
 class LazyObservableValue extends BaseObservable {
     get debugName() {
@@ -24,14 +25,16 @@ class LazyObservableValue extends BaseObservable {
         }
         this._isUpToDate = true;
         if (this._deltas.length > 0) {
-            for (const observer of this.observers) {
-                for (const change of this._deltas) {
+            for (const change of this._deltas) {
+                getLogger()?.handleObservableChanged(this, { change, didChange: true, oldValue: '(unknown)', newValue: this._value, hadValue: true });
+                for (const observer of this.observers) {
                     observer.handleChange(this, change);
                 }
             }
             this._deltas.length = 0;
         }
         else {
+            getLogger()?.handleObservableChanged(this, { change: undefined, didChange: true, oldValue: '(unknown)', newValue: this._value, hadValue: true });
             for (const observer of this.observers) {
                 observer.handleChange(this, undefined);
             }

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

@@ -1,9 +1,10 @@
 import { AutorunObserver } from "./autorun.js";
-import { IObservable, ObservableValue, TransactionImpl } from "./base.js";
+import { IObservable, TransactionImpl } from "./base.js";
 import { Derived } from "./derived.js";
 import { FromEventObservable } from "./utils.js";
 export declare function setLogger(logger: IObservableLogger): void;
 export declare function getLogger(): IObservableLogger | undefined;
+export declare function logObservable(obs: IObservable<any>): void;
 interface IChangeInformation {
     oldValue: unknown;
     newValue: unknown;
@@ -12,25 +13,30 @@ interface IChangeInformation {
     hadValue: boolean;
 }
 export interface IObservableLogger {
-    handleObservableChanged(observable: ObservableValue<any, any>, info: IChangeInformation): void;
+    handleObservableChanged(observable: IObservable<any>, info: IChangeInformation): void;
     handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void;
     handleAutorunCreated(autorun: AutorunObserver): void;
     handleAutorunTriggered(autorun: AutorunObserver): void;
     handleAutorunFinished(autorun: AutorunObserver): void;
     handleDerivedCreated(observable: Derived<any>): void;
     handleDerivedRecomputed(observable: Derived<any>, info: IChangeInformation): void;
+    handleDerivedCleared(observable: Derived<any>): void;
     handleBeginTransaction(transaction: TransactionImpl): void;
     handleEndTransaction(): void;
 }
 export declare class ConsoleObservableLogger implements IObservableLogger {
     private indentation;
+    private _filteredObjects;
+    addFilteredObj(obj: unknown): void;
+    private _isIncluded;
     private textToConsoleArgs;
     private formatInfo;
-    handleObservableChanged(observable: IObservable<unknown, unknown>, info: IChangeInformation): void;
+    handleObservableChanged(observable: IObservable<unknown>, info: IChangeInformation): void;
     private readonly changedObservablesSets;
-    formatChanges(changes: Set<IObservable<any, any>>): ConsoleText | undefined;
+    formatChanges(changes: Set<IObservable<any>>): ConsoleText | undefined;
     handleDerivedCreated(derived: Derived<unknown>): void;
     handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void;
+    handleDerivedCleared(derived: Derived<unknown>): void;
     handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void;
     handleAutorunCreated(autorun: AutorunObserver): void;
     handleAutorunTriggered(autorun: AutorunObserver): void;