@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -1,7 +1,4 @@
-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";
+import { DisposableStore } from "./commonFacade/deps.js";
 export interface IObservable<T> extends IObservableWithChange<T, unknown> {
 }
 export interface IObservableWithChange<T, TChange = unknown> {
@@ -34,77 +31,10 @@ export interface ISettable<T, TChange = void> {
 export interface ITransaction {
     updateObserver(observer: IObserver, observable: IObservableWithChange<any, any>): void;
 }
-declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
-export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
-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 IObservableWithChange<T, TChange> {
-    get TChange(): TChange;
-    abstract get(): T;
-    reportChanges(): void;
-    abstract addObserver(observer: IObserver): void;
-    abstract removeObserver(observer: IObserver): void;
-    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>;
-    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>;
-    abstract get debugName(): string;
-    protected get debugValue(): T;
-}
-export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
-    protected readonly _observers: Set<IObserver>;
-    constructor();
-    addObserver(observer: IObserver): void;
-    removeObserver(observer: IObserver): void;
-    protected onFirstObserverAdded(): void;
-    protected onLastObserverRemoved(): void;
-    log(): IObservableWithChange<T, TChange>;
-    debugGetObservers(): Set<IObserver>;
-}
-export declare function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
-export declare function globalTransaction(fn: (tx: ITransaction) => void): void;
-export declare function asyncTransaction(fn: (tx: ITransaction) => Promise<void>, getDebugName?: () => string): Promise<void>;
-export declare function subtransaction(tx: ITransaction | undefined, fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
-export declare class TransactionImpl implements ITransaction {
-    readonly _fn: Function;
-    private readonly _getDebugName?;
-    private _updatingObservers;
-    constructor(_fn: Function, _getDebugName?: (() => string) | undefined);
-    getDebugName(): string | undefined;
-    updateObserver(observer: IObserver, observable: IObservable<any>): void;
-    finish(): void;
-    debugGetUpdatingObservers(): {
-        observer: IObserver;
-        observable: IObservable<any>;
-    }[] | null;
-}
+export declare function handleBugIndicatingErrorRecovery(message: string): void;
 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>;
-export declare class ObservableValue<T, TChange = void> extends BaseObservable<T, TChange> implements ISettableObservable<T, TChange> {
-    private readonly _debugNameData;
-    private readonly _equalityComparator;
-    protected _value: T;
-    get debugName(): string;
-    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>);
-    get(): T;
-    set(value: T, tx: ITransaction | undefined, change: TChange): void;
-    toString(): string;
-    protected _setValue(newValue: T): void;
-    debugGetState(): {
-        value: T;
-    };
-    debugSetValue(value: unknown): void;
-}
-export declare function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T): ISettableObservable<T, TChange> & IDisposable;
-export declare class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {
-    protected _setValue(newValue: T): void;
-    dispose(): void;
+export interface IReaderWithStore extends IReader {
+    get store(): DisposableStore;
+    get delayedStore(): DisposableStore;
 }
-export {};

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

@@ -1,290 +1,13 @@
 
-import { getFunctionName, DebugNameData } from './debugName.js';
 import { onUnexpectedError } from '../errors.js';
-import { strictEquals } from '../equals.js';
+import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
-import { getLogger, logObservable } from './logging/logging.js';
 
-let _recomputeInitiallyAndOnChange;
-function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
-    _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
-}
-let _keepObserved;
-function _setKeepObserved(keepObserved) {
-    _keepObserved = keepObserved;
-}
-let _derived;
-function _setDerivedOpts(derived) {
-    _derived = derived;
-}
-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;
-    }
-}
-function transaction(fn, getDebugName) {
-    const tx = ( new TransactionImpl(fn, getDebugName));
-    try {
-        fn(tx);
-    }
-    finally {
-        tx.finish();
-    }
-}
-let _globalTransaction = undefined;
-function globalTransaction(fn) {
-    if (_globalTransaction) {
-        fn(_globalTransaction);
-    }
-    else {
-        const tx = ( new TransactionImpl(fn, undefined));
-        _globalTransaction = tx;
-        try {
-            fn(tx);
-        }
-        finally {
-            tx.finish();
-            _globalTransaction = undefined;
-        }
-    }
-}
-async function asyncTransaction(fn, getDebugName) {
-    const tx = ( new TransactionImpl(fn, getDebugName));
-    try {
-        await fn(tx);
-    }
-    finally {
-        tx.finish();
-    }
-}
-function subtransaction(tx, fn, getDebugName) {
-    if (!tx) {
-        transaction(fn, getDebugName);
-    }
-    else {
-        fn(tx);
-    }
-}
-class TransactionImpl {
-    constructor(_fn, _getDebugName) {
-        this._fn = _fn;
-        this._getDebugName = _getDebugName;
-        this._updatingObservers = [];
-        getLogger()?.handleBeginTransaction(this);
-    }
-    getDebugName() {
-        if (this._getDebugName) {
-            return this._getDebugName();
-        }
-        return getFunctionName(this._fn);
-    }
-    updateObserver(observer, observable) {
-        if (!this._updatingObservers) {
-            handleBugIndicatingErrorRecovery('Transaction already finished!');
-            transaction(tx => {
-                tx.updateObserver(observer, observable);
-            });
-            return;
-        }
-        this._updatingObservers.push({ observer, observable });
-        observer.beginUpdate(observable);
-    }
-    finish() {
-        const updatingObservers = this._updatingObservers;
-        if (!updatingObservers) {
-            handleBugIndicatingErrorRecovery('transaction.finish() has already been called!');
-            return;
-        }
-        for (let i = 0; i < updatingObservers.length; i++) {
-            const { observer, observable } = updatingObservers[i];
-            observer.endUpdate(observable);
-        }
-        this._updatingObservers = null;
-        getLogger()?.handleEndTransaction(this);
-    }
-    debugGetUpdatingObservers() {
-        return this._updatingObservers;
-    }
-}
 function handleBugIndicatingErrorRecovery(message) {
     const err = ( new Error('BugIndicatingErrorRecovery: ' + message));
     onUnexpectedError(err);
     console.error('recovered from an error that indicates a bug', err);
 }
-function observableValue(nameOrOwner, initialValue) {
-    let debugNameData;
-    if (typeof nameOrOwner === 'string') {
-        debugNameData = ( new DebugNameData(undefined, nameOrOwner, undefined));
-    }
-    else {
-        debugNameData = ( new DebugNameData(nameOrOwner, undefined, undefined));
-    }
-    return ( new ObservableValue(debugNameData, initialValue, strictEquals));
-}
-class ObservableValue extends BaseObservable {
-    get debugName() {
-        return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
-    }
-    constructor(_debugNameData, initialValue, _equalityComparator) {
-        super();
-        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;
-    }
-    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 {
-            const oldValue = this._value;
-            this._setValue(value);
-            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);
-            }
-        }
-        finally {
-            if (_tx) {
-                _tx.finish();
-            }
-        }
-    }
-    toString() {
-        return `${this.debugName}: ${this._value}`;
-    }
-    _setValue(newValue) {
-        this._value = newValue;
-    }
-    debugGetState() {
-        return {
-            value: this._value,
-        };
-    }
-    debugSetValue(value) {
-        this._value = value;
-    }
-}
-function disposableObservableValue(nameOrOwner, initialValue) {
-    let debugNameData;
-    if (typeof nameOrOwner === 'string') {
-        debugNameData = ( new DebugNameData(undefined, nameOrOwner, undefined));
-    }
-    else {
-        debugNameData = ( new DebugNameData(nameOrOwner, undefined, undefined));
-    }
-    return ( new DisposableObservableValue(debugNameData, initialValue, strictEquals));
-}
-class DisposableObservableValue extends ObservableValue {
-    _setValue(newValue) {
-        if (this._value === newValue) {
-            return;
-        }
-        if (this._value) {
-            this._value.dispose();
-        }
-        this._value = newValue;
-    }
-    dispose() {
-        this._value?.dispose();
-    }
-}
 
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction };
+export { handleBugIndicatingErrorRecovery };

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

@@ -1,5 +1,8 @@
 
 import { BugIndicatingError } from '../errors.js';
+import '../arrays.js';
+import '../event.js';
+import '../lifecycle.js';
 
 function recordChanges(obs) {
     return {

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

@@ -1,2 +1,2 @@
 export { CancellationError } from "../../errors.js";
-export { CancellationToken, CancellationTokenSource } from "../../cancellation.js";
+export { CancellationToken, CancellationTokenSource, cancelOnDispose } from "../../cancellation.js";

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

@@ -1,5 +1,5 @@
 export { assertFn } from "../../assert.js";
 export { type EqualityComparer, strictEquals } from "../../equals.js";
-export { BugIndicatingError, onBugIndicatingError } from "../../errors.js";
+export { BugIndicatingError, onBugIndicatingError, onUnexpectedError } from "../../errors.js";
 export { Event, type IValueWithChangeEvent } from "../../event.js";
 export { DisposableStore, type IDisposable, markAsDisposed, toDisposable, trackDisposable } from "../../lifecycle.js";

package/vscode/src/vs/base/common/observableInternal/{reducer.d.ts → experimental/reducer.d.ts}

@@ -1,8 +1,8 @@
-import { EqualityComparer } from "../equals.js";
-import { IObservable, IObservableWithChange, ISettableObservable } from "./base.js";
-import { IChangeTracker } from "./changeTracker.js";
-import { DebugOwner } from "./debugName.js";
-import { IDerivedReader } from "./derived.js";
+import { EqualityComparer } from "../commonFacade/deps.js";
+import { IObservable, IObservableWithChange, ISettableObservable } from "../base.js";
+import { IChangeTracker } from "../changeTracker.js";
+import { DebugOwner } from "../debugName.js";
+import { IDerivedReader } from "../observables/derivedImpl.js";
 export interface IReducerOptions<T, TChangeSummary = void, TOutChange = void> {
     initial: T | (() => T);
     disposeFinal?(value: T): void;

package/vscode/src/vs/base/common/observableInternal/{reducer.js → experimental/reducer.js}

@@ -1,9 +1,11 @@
 
-import { strictEquals } from '../equals.js';
-import { BugIndicatingError } from '../errors.js';
-import { subtransaction } from './base.js';
-import { DebugNameData } from './debugName.js';
-import { DerivedWithSetter } from './derived.js';
+import { BugIndicatingError } from '../../errors.js';
+import { strictEquals } from '../../equals.js';
+import '../../event.js';
+import '../../lifecycle.js';
+import { subtransaction } from '../transaction.js';
+import { DebugNameData } from '../debugName.js';
+import { DerivedWithSetter } from '../observables/derivedImpl.js';
 
 function observableReducerSettable(owner, options) {
     let prevValue = undefined;

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

@@ -0,0 +1,4 @@
+import { IObservable, IReader } from "../base.js";
+import { DebugOwner } from "../debugName.js";
+export declare function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]["get"]>>;
+export declare function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined>;

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

@@ -0,0 +1,47 @@
+
+import { BugIndicatingError } from '../../errors.js';
+import '../../arrays.js';
+import '../../event.js';
+import { DisposableStore } from '../../lifecycle.js';
+import { getDebugName, DebugNameData } from '../debugName.js';
+import { observableFromEvent } from '../observables/observableFromEvent.js';
+import { autorunOpts } from '../reactions/autorun.js';
+import { derivedObservableWithCache } from '../utils/utils.js';
+
+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;
+}
+function derivedConstOnceDefined(owner, fn) {
+    return derivedObservableWithCache(owner, (reader, lastValue) => lastValue ?? fn(reader));
+}
+
+export { derivedConstOnceDefined, latestChangedValue };

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

@@ -1,9 +1,23 @@
-export { observableValueOpts } from "./api.js";
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta } from "./autorun.js";
-export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
-export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore, type IDerivedReader } from "./derived.js";
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./promise.js";
-export { derivedWithCancellationToken, waitForState } from "./utilsCancellation.js";
-export { constObservable, debouncedObservableDeprecated, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, runOnChangeWithCancellationToken, signalFromObservable, ValueWithChangeEventFromObservable, wasEventTriggeredRecently, type IObservableSignal, } from "./utils.js";
+export { observableValueOpts } from "./observables/observableValueOpts.js";
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta } from "./reactions/autorun.js";
+export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction } from "./base.js";
+export { disposableObservableValue } from "./observables/observableValue.js";
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./observables/derived.js";
+export { type IDerivedReader } from "./observables/derivedImpl.js";
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./utils/promise.js";
+export { derivedWithCancellationToken, waitForState } from "./utils/utilsCancellation.js";
+export { debouncedObservableDeprecated, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, wasEventTriggeredRecently, } from "./utils/utils.js";
 export { type DebugOwner } from "./debugName.js";
 export { type IChangeContext, type IChangeTracker, recordChanges } from "./changeTracker.js";
+export { constObservable } from "./observables/constObservable.js";
+export { type IObservableSignal, observableSignal } from "./observables/observableSignal.js";
+export { observableFromEventOpts } from "./observables/observableFromEvent.js";
+export { observableSignalFromEvent } from "./observables/observableSignalFromEvent.js";
+export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from "./transaction.js";
+export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from "./utils/valueWithChangeEvent.js";
+export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore } from "./utils/runOnChange.js";
+export { derivedConstOnceDefined, latestChangedValue } from "./experimental/utils.js";
+export { observableFromEvent } from "./observables/observableFromEvent.js";
+export { observableValue } from "./observables/observableValue.js";
+export { ObservableSet } from "./set.js";
+export { ObservableMap } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableInternal/map";

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

@@ -1,12 +1,15 @@
 
+import '../errors.js';
 import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
 import { setLogObservableFn, addLogger } from './logging/logging.js';
-export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from './autorun.js';
-export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './derived.js';
+import './reactions/autorunImpl.js';
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter } from './observables/derived.js';
 import '../cancellation.js';
-export { ValueWithChangeEventFromObservable, constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, wasEventTriggeredRecently } from './utils.js';
+import './observables/derivedImpl.js';
+export { debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, wasEventTriggeredRecently } from './utils/utils.js';
+export { observableFromEvent, observableFromEventOpts } from './observables/observableFromEvent.js';
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
 import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
 import { env } from '../process.js';

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

@@ -1,8 +1,9 @@
-import { AutorunObserver } from "../autorun.js";
-import { IObservable, TransactionImpl } from "../base.js";
-import { Derived } from "../derived.js";
+import { IObservable } from "../base.js";
+import { TransactionImpl } from "../transaction.js";
 import { IObservableLogger, IChangeInformation } from "./logging.js";
-import { FromEventObservable } from "../utils.js";
+import { FromEventObservable } from "../observables/observableFromEvent.js";
+import { Derived } from "../observables/derivedImpl.js";
+import { AutorunObserver } from "../reactions/autorunImpl.js";
 export declare function logObservableToConsole(obs: IObservable<any>): void;
 export declare class ConsoleObservableLogger implements IObservableLogger {
     private indentation;

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

@@ -1,7 +1,7 @@
 
-import { Derived } from '../derived.js';
 import { addLogger } from './logging.js';
 import { getClassName } from '../debugName.js';
+import { Derived } from '../observables/derivedImpl.js';
 
 let consoleObservableLogger;
 function logObservableToConsole(obs) {

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

@@ -1,7 +1,8 @@
-import { AutorunObserver } from "../../autorun.js";
-import { IObservable, TransactionImpl } from "../../base.js";
-import { Derived } from "../../derived.js";
+import { AutorunObserver } from "../../reactions/autorunImpl.js";
+import { TransactionImpl } from "../../transaction.js";
 import { IChangeInformation, IObservableLogger } from "../logging.js";
+import { IObservable } from "../../base.js";
+import { Derived } from "../../observables/derivedImpl.js";
 export declare class DevToolsLogger implements IObservableLogger {
     private static _instance;
     static getInstance(): DevToolsLogger;

package/vscode/src/vs/base/common/observableInternal/logging/debugger/devToolsLogger.js

@@ -1,13 +1,13 @@
 
-import { AutorunObserver, AutorunState } from '../../autorun.js';
-import { ObservableValue } from '../../base.js';
-import { Derived, DerivedState } from '../../derived.js';
+import { AutorunObserver, AutorunState } from '../../reactions/autorunImpl.js';
 import { formatValue } from '../consoleObservableLogger.js';
 import { registerDebugChannel } from './debuggerRpc.js';
 import { Throttler, deepAssignDeleteNulls, deepAssign, getFirstStackFrameOutsideOf } from './utils.js';
 import { isDefined } from '../../../types.js';
-import { FromEventObservable } from '../../utils.js';
+import { FromEventObservable } from '../../observables/observableFromEvent.js';
 import { onUnexpectedError, BugIndicatingError } from '../../../errors.js';
+import { Derived, DerivedState } from '../../observables/derivedImpl.js';
+import { ObservableValue } from '../../observables/observableValue.js';
 
 class DevToolsLogger {
     static { this._instance = undefined; }

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

@@ -1,6 +1,7 @@
-import { AutorunObserver } from "../autorun.js";
-import { IObservable, TransactionImpl } from "../base.js";
-import type { Derived } from "../derived.js";
+import { AutorunObserver } from "../reactions/autorunImpl.js";
+import { IObservable } from "../base.js";
+import { TransactionImpl } from "../transaction.js";
+import type { Derived } from "../observables/derivedImpl.js";
 export declare function addLogger(logger: IObservableLogger): void;
 export declare function getLogger(): IObservableLogger | undefined;
 export declare function setLogObservableFn(fn: (obs: IObservable<any>) => void): void;

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

@@ -0,0 +1,38 @@
+import { IObservableWithChange, IObserver, IReader, IObservable } from "../base.js";
+import { DisposableStore } from "../commonFacade/deps.js";
+import { DebugOwner } from "../debugName.js";
+import type { keepObserved, recomputeInitiallyAndOnChange } from "../utils/utils.js";
+import { derivedOpts } from "./derived.js";
+declare let _derived: typeof derivedOpts;
+export declare function _setDerivedOpts(derived: typeof _derived): void;
+declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
+export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
+declare let _keepObserved: typeof keepObserved;
+export declare function _setKeepObserved(keepObserved: typeof _keepObserved): void;
+export declare abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
+    get TChange(): TChange;
+    abstract get(): T;
+    reportChanges(): void;
+    abstract addObserver(observer: IObserver): void;
+    abstract removeObserver(observer: IObserver): void;
+    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>;
+    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>;
+    abstract get debugName(): string;
+    protected get debugValue(): T;
+}
+export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
+    protected readonly _observers: Set<IObserver>;
+    constructor();
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    protected onFirstObserverAdded(): void;
+    protected onLastObserverRemoved(): void;
+    log(): IObservableWithChange<T, TChange>;
+    debugGetObservers(): Set<IObserver>;
+}
+export {};