@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -0,0 +1,111 @@
+
+import { getFunctionName } from '../debugName.js';
+import { getLogger, logObservable } from '../logging/logging.js';
+
+let _derived;
+function _setDerivedOpts(derived) {
+    _derived = derived;
+}
+let _recomputeInitiallyAndOnChange;
+function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
+    _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
+}
+let _keepObserved;
+function _setKeepObserved(keepObserved) {
+    _keepObserved = keepObserved;
+}
+class ConvenientObservable {
+    get TChange() { return null; }
+    reportChanges() {
+        this.get();
+    }
+    read(reader) {
+        if (reader) {
+            return reader.readObservable(this);
+        }
+        else {
+            return this.get();
+        }
+    }
+    map(fnOrOwner, fnOrUndefined) {
+        const owner = fnOrUndefined === undefined ? undefined : fnOrOwner;
+        const fn = fnOrUndefined === undefined ? fnOrOwner : fnOrUndefined;
+        return _derived({
+            owner,
+            debugName: () => {
+                const name = getFunctionName(fn);
+                if (name !== undefined) {
+                    return name;
+                }
+                const regexp = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/;
+                const match = regexp.exec(( fn.toString()));
+                if (match) {
+                    return `${this.debugName}.${match[2]}`;
+                }
+                if (!owner) {
+                    return `${this.debugName} (mapped)`;
+                }
+                return undefined;
+            },
+            debugReferenceFn: fn,
+        }, (reader) => fn(this.read(reader), reader));
+    }
+    flatten() {
+        return _derived({
+            owner: undefined,
+            debugName: () => `${this.debugName} (flattened)`,
+        }, (reader) => this.read(reader).read(reader));
+    }
+    recomputeInitiallyAndOnChange(store, handleValue) {
+        store.add(_recomputeInitiallyAndOnChange(this, handleValue));
+        return this;
+    }
+    keepObserved(store) {
+        store.add(_keepObserved(this));
+        return this;
+    }
+    get debugValue() {
+        return this.get();
+    }
+}
+class BaseObservable extends ConvenientObservable {
+    constructor() {
+        super();
+        this._observers = ( new Set());
+        getLogger()?.handleObservableCreated(this);
+    }
+    addObserver(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) {
+            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;
+    }
+    debugGetObservers() {
+        return this._observers;
+    }
+}
+
+export { BaseObservable, ConvenientObservable, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange };

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

@@ -0,0 +1,2 @@
+import { IObservable } from "../base.js";
+export declare function constObservable<T>(value: T): IObservable<T>;

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

@@ -0,0 +1,30 @@
+
+import { ConvenientObservable } from './baseObservable.js';
+
+function constObservable(value) {
+    return ( new ConstObservable(value));
+}
+class ConstObservable extends ConvenientObservable {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get debugName() {
+        return ( this.toString());
+    }
+    get() {
+        return this.value;
+    }
+    addObserver(observer) {
+    }
+    removeObserver(observer) {
+    }
+    log() {
+        return this;
+    }
+    toString() {
+        return `Const: ${this.value}`;
+    }
+}
+
+export { constObservable };

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

@@ -0,0 +1,20 @@
+import { IObservable, IReader, ITransaction, ISettableObservable, IObservableWithChange } from "../base.js";
+import { IChangeTracker } from "../changeTracker.js";
+import { DisposableStore, EqualityComparer, IDisposable } from "../commonFacade/deps.js";
+import { DebugOwner, IDebugNameData } from "../debugName.js";
+import { IDerivedReader } from "./derivedImpl.js";
+export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
+export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
+export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void): ISettableObservable<T>;
+export declare function derivedOpts<T>(options: IDebugNameData & {
+    equalsFn?: EqualityComparer<T>;
+    onLastObserverRemoved?: (() => void);
+}, computeFn: (reader: IReader) => T): IObservable<T>;
+export declare function derivedHandleChanges<T, TDelta, TChangeSummary>(options: IDebugNameData & {
+    changeTracker: IChangeTracker<TChangeSummary>;
+    equalityComparer?: EqualityComparer<T>;
+}, computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T): IObservableWithChange<T, TDelta>;
+export declare function derivedWithStore<T>(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>;

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

@@ -0,0 +1,58 @@
+
+import '../../errors.js';
+import { strictEquals } from '../../equals.js';
+import '../../event.js';
+import { DisposableStore } from '../../lifecycle.js';
+import { DebugNameData } from '../debugName.js';
+import { _setDerivedOpts } from './baseObservable.js';
+import { Derived, DerivedWithSetter } from './derivedImpl.js';
+
+function derived(computeFnOrOwner, computeFn) {
+    if (computeFn !== undefined) {
+        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals));
+    }
+    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals));
+}
+function derivedWithSetter(owner, computeFn, setter) {
+    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter));
+}
+function derivedOpts(options, computeFn) {
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals));
+}
+_setDerivedOpts(derivedOpts);
+function derivedHandleChanges(options, computeFn) {
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.changeTracker, undefined, options.equalityComparer ?? strictEquals));
+}
+function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
+    let computeFn;
+    let owner;
+    if (computeFnOrUndefined === undefined) {
+        computeFn = computeFnOrOwner;
+        owner = undefined;
+    }
+    else {
+        owner = computeFnOrOwner;
+        computeFn = computeFnOrUndefined;
+    }
+    let store = undefined;
+    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
+        if (!store) {
+            store = ( new DisposableStore());
+        }
+        else {
+            store.clear();
+        }
+        const result = computeFn(r);
+        if (result) {
+            store.add(result);
+        }
+        return result;
+    }, undefined, () => {
+        if (store) {
+            store.dispose();
+            store = undefined;
+        }
+    }, strictEquals));
+}
+
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter };

package/vscode/src/vs/base/common/observableInternal/{derived.d.ts → observables/derivedImpl.d.ts}

@@ -1,25 +1,11 @@
-import { BaseObservable, IObservable, IObservableWithChange, IObserver, IReader, ISettableObservable, ITransaction } from "./base.js";
-import { DebugNameData, DebugOwner, IDebugNameData } from "./debugName.js";
-import { DisposableStore, EqualityComparer, IDisposable } from "./commonFacade/deps.js";
-import { IChangeTracker } from "./changeTracker.js";
-export interface IDerivedReader<TChange = void> extends IReader {
+import { IObservable, IObservableWithChange, IObserver, IReaderWithStore, ISettableObservable, ITransaction } from "../base.js";
+import { BaseObservable } from "./baseObservable.js";
+import { DebugNameData } from "../debugName.js";
+import { DisposableStore, EqualityComparer } from "../commonFacade/deps.js";
+import { IChangeTracker } from "../changeTracker.js";
+export interface IDerivedReader<TChange = void> extends IReaderWithStore {
     reportChange(change: TChange): void;
 }
-export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservable<T>;
-export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservable<T>;
-export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void): ISettableObservable<T>;
-export declare function derivedOpts<T>(options: IDebugNameData & {
-    equalsFn?: EqualityComparer<T>;
-    onLastObserverRemoved?: (() => void);
-}, computeFn: (reader: IReader) => T): IObservable<T>;
-export declare function derivedHandleChanges<T, TChangeSummary>(options: IDebugNameData & {
-    changeTracker: IChangeTracker<TChangeSummary>;
-    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: 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,
@@ -41,6 +27,11 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
     private _isUpdating;
     private _isComputing;
     private _didReportChange;
+    private _isInBeforeUpdate;
+    private _isReaderValid;
+    private _store;
+    private _delayedStore;
+    private _removedObserverToCallEndUpdateOn;
     get debugName(): string;
     constructor(_debugNameData: DebugNameData, _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T, _changeTracker: IChangeTracker<TChangeSummary> | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
     protected onLastObserverRemoved(): void;
@@ -48,13 +39,14 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
     private _recompute;
     toString(): string;
     beginUpdate<T>(_observable: IObservable<T>): void;
-    private _removedObserverToCallEndUpdateOn;
     endUpdate<T>(_observable: IObservable<T>): void;
     handlePossibleChange<T>(observable: IObservable<T>): void;
     handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
-    private _isReaderValid;
+    private _ensureReaderValid;
     readObservable<T>(observable: IObservable<T>): T;
     reportChange(change: TChange): void;
+    get store(): DisposableStore;
+    get delayedStore(): DisposableStore;
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     debugGetState(): {

package/vscode/src/vs/base/common/observableInternal/{derived.js → observables/derivedImpl.js}

@@ -1,82 +1,12 @@
 
-import { _setDerivedOpts, BaseObservable } from './base.js';
-import { DebugNameData } from './debugName.js';
-import { assertFn } from '../assert.js';
-import { strictEquals } from '../equals.js';
-import { onBugIndicatingError, BugIndicatingError } from '../errors.js';
-import '../event.js';
-import { DisposableStore } from '../lifecycle.js';
-import { getLogger } from './logging/logging.js';
+import { BaseObservable } from './baseObservable.js';
+import { assertFn } from '../../assert.js';
+import '../../arrays.js';
+import { onBugIndicatingError, BugIndicatingError } from '../../errors.js';
+import '../../event.js';
+import { DisposableStore } from '../../lifecycle.js';
+import { getLogger } from '../logging/logging.js';
 
-function derived(computeFnOrOwner, computeFn) {
-    if (computeFn !== undefined) {
-        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals));
-    }
-    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals));
-}
-function derivedWithSetter(owner, computeFn, setter) {
-    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter));
-}
-function derivedOpts(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals));
-}
-_setDerivedOpts(derivedOpts);
-function derivedHandleChanges(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.changeTracker, undefined, options.equalityComparer ?? strictEquals));
-}
-function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
-    let computeFn;
-    let owner;
-    if (computeFnOrUndefined === undefined) {
-        computeFn = computeFnOrOwner;
-        owner = undefined;
-    }
-    else {
-        owner = computeFnOrOwner;
-        computeFn = computeFnOrUndefined;
-    }
-    let store = ( new DisposableStore());
-    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
-        if (store.isDisposed) {
-            store = ( new DisposableStore());
-        }
-        else {
-            store.clear();
-        }
-        return computeFn(r, store);
-    }, undefined, () => store.dispose(), strictEquals));
-}
-function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
-    let computeFn;
-    let owner;
-    if (computeFnOrUndefined === undefined) {
-        computeFn = computeFnOrOwner;
-        owner = undefined;
-    }
-    else {
-        owner = computeFnOrOwner;
-        computeFn = computeFnOrUndefined;
-    }
-    let store = undefined;
-    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
-        if (!store) {
-            store = ( new DisposableStore());
-        }
-        else {
-            store.clear();
-        }
-        const result = computeFn(r);
-        if (result) {
-            store.add(result);
-        }
-        return result;
-    }, undefined, () => {
-        if (store) {
-            store.dispose();
-            store = undefined;
-        }
-    }, strictEquals));
-}
 var DerivedState;
 (function (DerivedState) {
     DerivedState[DerivedState["initial"] = 0] = "initial";
@@ -104,8 +34,11 @@ class Derived extends BaseObservable {
         this._isUpdating = false;
         this._isComputing = false;
         this._didReportChange = false;
-        this._removedObserverToCallEndUpdateOn = null;
+        this._isInBeforeUpdate = false;
         this._isReaderValid = false;
+        this._store = undefined;
+        this._delayedStore = undefined;
+        this._removedObserverToCallEndUpdateOn = null;
         this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
     }
     onLastObserverRemoved() {
@@ -116,6 +49,14 @@ class Derived extends BaseObservable {
             d.removeObserver(this);
         }
         this._dependencies.clear();
+        if (this._store !== undefined) {
+            this._store.dispose();
+            this._store = undefined;
+        }
+        if (this._delayedStore !== undefined) {
+            this._delayedStore.dispose();
+            this._delayedStore = undefined;
+        }
         this._handleLastObserverRemoved?.();
     }
     get() {
@@ -157,22 +98,32 @@ class Derived extends BaseObservable {
         }
     }
     _recompute() {
-        const emptySet = this._dependenciesToBeRemoved;
-        this._dependenciesToBeRemoved = this._dependencies;
-        this._dependencies = emptySet;
-        const hadValue = this._state !== DerivedState.initial;
-        const oldValue = this._value;
-        this._state = DerivedState.upToDate;
         let didChange = false;
         this._isComputing = true;
         this._didReportChange = false;
+        const emptySet = this._dependenciesToBeRemoved;
+        this._dependenciesToBeRemoved = this._dependencies;
+        this._dependencies = emptySet;
         try {
             const changeSummary = this._changeSummary;
+            this._isReaderValid = true;
+            if (this._changeTracker) {
+                this._isInBeforeUpdate = true;
+                this._changeTracker.beforeUpdate?.(this, changeSummary);
+                this._isInBeforeUpdate = false;
+                this._changeSummary = this._changeTracker?.createChangeSummary(changeSummary);
+            }
+            const hadValue = this._state !== DerivedState.initial;
+            const oldValue = this._value;
+            this._state = DerivedState.upToDate;
+            const delayedStore = this._delayedStore;
+            if (delayedStore !== undefined) {
+                this._delayedStore = undefined;
+            }
             try {
-                this._isReaderValid = true;
-                if (this._changeTracker) {
-                    this._changeTracker.beforeUpdate?.(this, changeSummary);
-                    this._changeSummary = this._changeTracker?.createChangeSummary(changeSummary);
+                if (this._store !== undefined) {
+                    this._store.dispose();
+                    this._store = undefined;
                 }
                 this._value = this._computeFn(this, changeSummary);
             }
@@ -182,6 +133,9 @@ class Derived extends BaseObservable {
                     o.removeObserver(this);
                 }
                 this._dependenciesToBeRemoved.clear();
+                if (delayedStore !== undefined) {
+                    delayedStore.dispose();
+                }
             }
             didChange = this._didReportChange || (hadValue && !(this._equalityComparator(oldValue, this._value)));
             getLogger()?.handleObservableUpdated(this, {
@@ -260,7 +214,7 @@ class Derived extends BaseObservable {
         }
     }
     handleChange(observable, change) {
-        if (( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable))) {
+        if (( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable)) || this._isInBeforeUpdate) {
             getLogger()?.handleDerivedDependencyChanged(this, observable, change);
             let shouldReact = false;
             try {
@@ -284,10 +238,13 @@ class Derived extends BaseObservable {
             }
         }
     }
-    readObservable(observable) {
+    _ensureReaderValid() {
         if (!this._isReaderValid) {
             throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
         }
+    }
+    readObservable(observable) {
+        this._ensureReaderValid();
         observable.addObserver(this);
         const value = observable.get();
         this._dependencies.add(observable);
@@ -295,14 +252,26 @@ class Derived extends BaseObservable {
         return value;
     }
     reportChange(change) {
-        if (!this._isReaderValid) {
-            throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
-        }
+        this._ensureReaderValid();
         this._didReportChange = true;
         for (const r of this._observers) {
             r.handleChange(this, change);
         }
     }
+    get store() {
+        this._ensureReaderValid();
+        if (this._store === undefined) {
+            this._store = ( new DisposableStore());
+        }
+        return this._store;
+    }
+    get delayedStore() {
+        this._ensureReaderValid();
+        if (this._delayedStore === undefined) {
+            this._delayedStore = ( new DisposableStore());
+        }
+        return this._delayedStore;
+    }
     addObserver(observer) {
         const shouldCallBeginUpdate = !( this._observers.has(observer)) && this._updateCount > 0;
         super.addObserver(observer);
@@ -352,4 +321,4 @@ class DerivedWithSetter extends Derived {
     }
 }
 
-export { Derived, DerivedState, DerivedWithSetter, derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore };
+export { Derived, DerivedState, DerivedWithSetter };

package/vscode/src/vs/base/common/observableInternal/{lazyObservableValue.d.ts → observables/lazyObservableValue.d.ts}

@@ -1,6 +1,7 @@
-import { EqualityComparer } from "./commonFacade/deps.js";
-import { BaseObservable, IObserver, ISettableObservable, ITransaction } from "./base.js";
-import { DebugNameData } from "./debugName.js";
+import { EqualityComparer } from "../commonFacade/deps.js";
+import { IObserver, ISettableObservable, ITransaction } from "../base.js";
+import { DebugNameData } from "../debugName.js";
+import { BaseObservable } from "./baseObservable.js";
 export declare class LazyObservableValue<T, TChange = void> extends BaseObservable<T, TChange> implements ISettableObservable<T, TChange> {
     private readonly _debugNameData;
     private readonly _equalityComparator;

package/vscode/src/vs/base/common/observableInternal/{lazyObservableValue.js → observables/lazyObservableValue.js}

@@ -1,6 +1,7 @@
 
-import { BaseObservable, TransactionImpl } from './base.js';
-import { getLogger } from './logging/logging.js';
+import { TransactionImpl } from '../transaction.js';
+import { getLogger } from '../logging/logging.js';
+import { BaseObservable } from './baseObservable.js';
 
 class LazyObservableValue extends BaseObservable {
     get debugName() {

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

@@ -0,0 +1,32 @@
+import { IObservable, ITransaction } from "../base.js";
+import { EqualityComparer, Event } from "../commonFacade/deps.js";
+import { DebugOwner, DebugNameData, IDebugNameData } from "../debugName.js";
+import { BaseObservable } from "./baseObservable.js";
+export declare function observableFromEvent<T, TArgs = unknown>(owner: DebugOwner, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+export declare function observableFromEvent<T, TArgs = unknown>(event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+export declare function observableFromEventOpts<T, TArgs = unknown>(options: IDebugNameData & {
+    equalsFn?: EqualityComparer<T>;
+}, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
+    private readonly _debugNameData;
+    private readonly event;
+    readonly _getValue: (args: TArgs | undefined) => T;
+    private readonly _getTransaction;
+    private readonly _equalityComparator;
+    static globalTransaction: ITransaction | undefined;
+    private _value;
+    private _hasValue;
+    private _subscription;
+    constructor(_debugNameData: DebugNameData, event: Event<TArgs>, _getValue: (args: TArgs | undefined) => T, _getTransaction: () => ITransaction | undefined, _equalityComparator: EqualityComparer<T>);
+    private getDebugName;
+    get debugName(): string;
+    protected onFirstObserverAdded(): void;
+    private readonly handleEvent;
+    protected onLastObserverRemoved(): void;
+    get(): T;
+    debugSetValue(value: unknown): void;
+}
+export declare namespace observableFromEvent {
+    const Observer: typeof FromEventObservable;
+    function batchEventsGlobally(tx: ITransaction, fn: () => void): void;
+}