@codingame/monaco-vscode-api 14.0.6 → 15.0.0

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

@@ -5,7 +5,7 @@ import '../arrays.js';
 import { onBugIndicatingError, BugIndicatingError } from '../errors.js';
 import '../event.js';
 import { DisposableStore, toDisposable, trackDisposable, markAsDisposed } from '../lifecycle.js';
-import { getLogger } from './logging.js';
+import { getLogger } from './logging/logging.js';
 
 function autorun(fn) {
     return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, undefined));
@@ -95,53 +95,50 @@ class AutorunObserver {
         this._runFn = _runFn;
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
-        this.state = AutorunState.stale;
+        this._state = AutorunState.stale;
         this.updateCount = 0;
         this.disposed = false;
-        this.dependencies = ( new Set());
+        this._dependencies = ( new Set());
         this.dependenciesToBeRemoved = ( new Set());
-        this._isReaderValid = false;
+        this._isRunning = false;
         this.changeSummary = this.createChangeSummary?.();
         getLogger()?.handleAutorunCreated(this);
-        this._runIfNeeded();
+        this._run();
         trackDisposable(this);
     }
     dispose() {
         this.disposed = true;
-        for (const o of this.dependencies) {
+        for (const o of this._dependencies) {
             o.removeObserver(this);
         }
-        this.dependencies.clear();
+        this._dependencies.clear();
+        getLogger()?.handleAutorunDisposed(this);
         markAsDisposed(this);
     }
-    _runIfNeeded() {
-        if (this.state === AutorunState.upToDate) {
-            return;
-        }
+    _run() {
         const emptySet = this.dependenciesToBeRemoved;
-        this.dependenciesToBeRemoved = this.dependencies;
-        this.dependencies = emptySet;
-        this.state = AutorunState.upToDate;
-        const isDisposed = this.disposed;
+        this.dependenciesToBeRemoved = this._dependencies;
+        this._dependencies = emptySet;
+        this._state = AutorunState.upToDate;
         try {
-            if (!isDisposed) {
-                getLogger()?.handleAutorunTriggered(this);
+            if (!this.disposed) {
+                getLogger()?.handleAutorunStarted(this);
                 const changeSummary = this.changeSummary;
                 try {
                     this.changeSummary = this.createChangeSummary?.();
-                    this._isReaderValid = true;
+                    this._isRunning = true;
                     this._runFn(this, changeSummary);
                 }
                 catch (e) {
                     onBugIndicatingError(e);
                 }
                 finally {
-                    this._isReaderValid = false;
+                    this._isRunning = false;
                 }
             }
         }
         finally {
-            if (!isDisposed) {
+            if (!this.disposed) {
                 getLogger()?.handleAutorunFinished(this);
             }
             for (const o of this.dependenciesToBeRemoved) {
@@ -153,27 +150,29 @@ class AutorunObserver {
     toString() {
         return `Autorun<${this.debugName}>`;
     }
-    beginUpdate() {
-        if (this.state === AutorunState.upToDate) {
-            this.state = AutorunState.dependenciesMightHaveChanged;
+    beginUpdate(_observable) {
+        if (this._state === AutorunState.upToDate) {
+            this._state = AutorunState.dependenciesMightHaveChanged;
         }
         this.updateCount++;
     }
-    endUpdate() {
+    endUpdate(_observable) {
         try {
             if (this.updateCount === 1) {
                 do {
-                    if (this.state === AutorunState.dependenciesMightHaveChanged) {
-                        this.state = AutorunState.upToDate;
-                        for (const d of this.dependencies) {
+                    if (this._state === AutorunState.dependenciesMightHaveChanged) {
+                        this._state = AutorunState.upToDate;
+                        for (const d of this._dependencies) {
                             d.reportChanges();
-                            if (this.state === AutorunState.stale) {
+                            if (this._state === AutorunState.stale) {
                                 break;
                             }
                         }
                     }
-                    this._runIfNeeded();
-                } while (this.state !== AutorunState.upToDate);
+                    if (this._state !== AutorunState.upToDate) {
+                        this._run();
+                    }
+                } while (this._state !== AutorunState.upToDate);
             }
         }
         finally {
@@ -182,12 +181,13 @@ class AutorunObserver {
         assertFn(() => this.updateCount >= 0);
     }
     handlePossibleChange(observable) {
-        if (this.state === AutorunState.upToDate && ( this.dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable))) {
-            this.state = AutorunState.dependenciesMightHaveChanged;
+        if (this._state === AutorunState.upToDate && this._isDependency(observable)) {
+            this._state = AutorunState.dependenciesMightHaveChanged;
         }
     }
     handleChange(observable, change) {
-        if (( this.dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable))) {
+        if (this._isDependency(observable)) {
+            getLogger()?.handleAutorunDependencyChanged(this, observable, change);
             try {
                 const shouldReact = this._handleChange ? this._handleChange({
                     changedObservable: observable,
@@ -195,7 +195,7 @@ class AutorunObserver {
                     didChange: (o) => o === observable,
                 }, this.changeSummary) : true;
                 if (shouldReact) {
-                    this.state = AutorunState.stale;
+                    this._state = AutorunState.stale;
                 }
             }
             catch (e) {
@@ -203,8 +203,11 @@ class AutorunObserver {
             }
         }
     }
+    _isDependency(observable) {
+        return ( this._dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable));
+    }
     readObservable(observable) {
-        if (!this._isReaderValid) {
+        if (!this._isRunning) {
             throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
         }
         if (this.disposed) {
@@ -212,7 +215,7 @@ class AutorunObserver {
         }
         observable.addObserver(this);
         const value = observable.get();
-        this.dependencies.add(observable);
+        this._dependencies.add(observable);
         this.dependenciesToBeRemoved.delete(observable);
         return value;
     }
@@ -221,4 +224,4 @@ class AutorunObserver {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {}));
 
-export { AutorunObserver, autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };
+export { AutorunObserver, AutorunState, autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };

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

@@ -10,24 +10,24 @@ export interface IObservableWithChange<T, TChange = unknown> {
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     read(reader: IReader | undefined): T;
+    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+    keepObserved(store: DisposableStore): IObservable<T>;
     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: 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: IObservableWithChange<T, TChange>, change: TChange): void;
 }
+export interface IReader {
+    readObservable<T>(observable: IObservableWithChange<T, any>): T;
+}
 export interface ISettable<T, TChange = void> {
     set(value: T, transaction: ITransaction | undefined, change: TChange): void;
 }
@@ -49,7 +49,7 @@ 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>;
-    log(): IObservableWithChange<T, TChange>;
+    abstract 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>;
@@ -57,11 +57,13 @@ export declare abstract class ConvenientObservable<T, TChange> implements IObser
     protected get debugValue(): T;
 }
 export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
-    protected readonly observers: Set<IObserver>;
+    readonly _observers: Set<IObserver>;
+    constructor();
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     protected onFirstObserverAdded(): void;
     protected onLastObserverRemoved(): void;
+    log(): IObservableWithChange<T, TChange>;
 }
 export declare function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
 export declare function globalTransaction(fn: (tx: ITransaction) => void): void;
@@ -70,7 +72,10 @@ export declare function subtransaction(tx: ITransaction | undefined, fn: (tx: IT
 export declare class TransactionImpl implements ITransaction {
     readonly _fn: Function;
     private readonly _getDebugName?;
-    private updatingObservers;
+    _updatingObservers: {
+        observer: IObserver;
+        observable: IObservable<any>;
+    }[] | null;
     constructor(_fn: Function, _getDebugName?: (() => string) | undefined);
     getDebugName(): string | undefined;
     updateObserver(observer: IObserver, observable: IObservable<any>): void;

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 { logObservable, getLogger } from './logging.js';
+import { getLogger, logObservable } from './logging/logging.js';
 
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
@@ -53,10 +53,6 @@ class ConvenientObservable {
             debugReferenceFn: fn,
         }, (reader) => fn(this.read(reader), reader));
     }
-    log() {
-        logObservable(this);
-        return this;
-    }
     flatten() {
         return _derived({
             owner: undefined,
@@ -77,24 +73,39 @@ class ConvenientObservable {
 }
 class BaseObservable extends ConvenientObservable {
     constructor() {
-        super(...arguments);
-        this.observers = ( new Set());
+        super();
+        this._observers = ( new Set());
+        getLogger()?.handleObservableCreated(this);
     }
     addObserver(observer) {
-        const len = this.observers.size;
-        this.observers.add(observer);
+        const len = this._observers.size;
+        this._observers.add(observer);
         if (len === 0) {
             this.onFirstObserverAdded();
         }
+        if (len !== this._observers.size) {
+            getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+        }
     }
     removeObserver(observer) {
-        const deleted = this.observers.delete(observer);
-        if (deleted && this.observers.size === 0) {
+        const deleted = this._observers.delete(observer);
+        if (deleted && this._observers.size === 0) {
             this.onLastObserverRemoved();
         }
+        if (deleted) {
+            getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+        }
     }
     onFirstObserverAdded() { }
     onLastObserverRemoved() { }
+    log() {
+        const hadLogger = !!getLogger();
+        logObservable(this);
+        if (!hadLogger) {
+            getLogger()?.handleObservableCreated(this);
+        }
+        return this;
+    }
 }
 function transaction(fn, getDebugName) {
     const tx = ( new TransactionImpl(fn, getDebugName));
@@ -143,7 +154,7 @@ class TransactionImpl {
     constructor(_fn, _getDebugName) {
         this._fn = _fn;
         this._getDebugName = _getDebugName;
-        this.updatingObservers = [];
+        this._updatingObservers = [];
         getLogger()?.handleBeginTransaction(this);
     }
     getDebugName() {
@@ -153,17 +164,17 @@ class TransactionImpl {
         return getFunctionName(this._fn);
     }
     updateObserver(observer, observable) {
-        this.updatingObservers.push({ observer, observable });
+        this._updatingObservers.push({ observer, observable });
         observer.beginUpdate(observable);
     }
     finish() {
-        const updatingObservers = this.updatingObservers;
+        const updatingObservers = this._updatingObservers;
         for (let i = 0; i < updatingObservers.length; i++) {
             const { observer, observable } = updatingObservers[i];
             observer.endUpdate(observable);
         }
-        this.updatingObservers = null;
-        getLogger()?.handleEndTransaction();
+        this._updatingObservers = null;
+        getLogger()?.handleEndTransaction(this);
     }
 }
 function observableValue(nameOrOwner, initialValue) {
@@ -185,6 +196,7 @@ class ObservableValue extends BaseObservable {
         this._debugNameData = _debugNameData;
         this._equalityComparator = _equalityComparator;
         this._value = initialValue;
+        getLogger()?.handleObservableUpdated(this, { hadValue: false, newValue: initialValue, change: undefined, didChange: true, oldValue: undefined });
     }
     get() {
         return this._value;
@@ -200,8 +212,8 @@ class ObservableValue extends BaseObservable {
         try {
             const oldValue = this._value;
             this._setValue(value);
-            getLogger()?.handleObservableChanged(this, { oldValue, newValue: value, change, didChange: true, hadValue: true });
-            for (const observer of this.observers) {
+            getLogger()?.handleObservableUpdated(this, { oldValue, newValue: value, change, didChange: true, hadValue: true });
+            for (const observer of this._observers) {
                 tx.updateObserver(observer, this);
                 observer.handleChange(this, change);
             }

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

@@ -13,4 +13,5 @@ export declare class DebugNameData {
 export type DebugOwner = object | undefined;
 export type DebugNameSource = string | (() => string | undefined);
 export declare function getDebugName(target: object, data: DebugNameData): string | undefined;
+export declare function getClassName(obj: object): string | undefined;
 export declare function getFunctionName(fn: Function): string | undefined;

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

@@ -77,7 +77,7 @@ function formatOwner(owner) {
     if (id) {
         return id;
     }
-    const className = getClassName(owner);
+    const className = getClassName(owner) ?? 'Object';
     let count = countPerClassName.get(className) ?? 0;
     count++;
     countPerClassName.set(className, count);
@@ -88,9 +88,12 @@ function formatOwner(owner) {
 function getClassName(obj) {
     const ctor = obj.constructor;
     if (ctor) {
+        if (ctor.name === 'Object') {
+            return undefined;
+        }
         return ctor.name;
     }
-    return 'Object';
+    return undefined;
 }
 function getFunctionName(fn) {
     const fnSrc = ( fn.toString());
@@ -100,4 +103,4 @@ function getFunctionName(fn) {
     return result?.trim();
 }
 
-export { DebugNameData, getDebugName, getFunctionName };
+export { DebugNameData, getClassName, getDebugName, getFunctionName };

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

@@ -14,9 +14,15 @@ export declare function derivedHandleChanges<T, TChangeSummary>(options: IDebugN
     equalityComparer?: EqualityComparer<T>;
 }, computeFn: (reader: IReader, changeSummary: TChangeSummary) => T): IObservable<T>;
 export declare function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
-export declare function derivedWithStore<T>(owner: object, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
+export declare function derivedWithStore<T>(owner: DebugOwner, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
 export declare function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;
 export declare function derivedDisposable<T extends IDisposable | undefined>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;
+export declare enum DerivedState {
+    initial = 0,
+    dependenciesMightHaveChanged = 1,
+    stale = 2,
+    upToDate = 3
+}
 export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T, void> implements IReader, IObserver {
     readonly _debugNameData: DebugNameData;
     readonly _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T;
@@ -24,19 +30,19 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     private readonly _handleChange;
     private readonly _handleLastObserverRemoved;
     private readonly _equalityComparator;
-    private state;
+    _state: DerivedState;
     private value;
-    private updateCount;
-    private dependencies;
+    _updateCount: number;
+    _dependencies: Set<IObservable<any>>;
     private dependenciesToBeRemoved;
     private changeSummary;
     private _isUpdating;
-    private _isComputing;
+    _isComputing: boolean;
     get debugName(): string;
     constructor(_debugNameData: DebugNameData, _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T, createChangeSummary: (() => TChangeSummary) | undefined, _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
     protected onLastObserverRemoved(): void;
     get(): T;
-    private _recomputeIfNeeded;
+    private _recompute;
     toString(): string;
     beginUpdate<T>(_observable: IObservable<T>): void;
     private _removedObserverToCallEndUpdateOn;
@@ -47,7 +53,6 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     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;