@codingame/monaco-vscode-api 17.2.0 → 18.0.0

package/vscode/src/vs/base/common/observableInternal/{autorun.js → reactions/autorunImpl.js}

@@ -1,84 +1,11 @@
 
-import { DebugNameData } from './debugName.js';
-import { assertFn } from '../assert.js';
-import '../arrays.js';
-import { onBugIndicatingError, BugIndicatingError } from '../errors.js';
-import '../event.js';
-import { DisposableStore, toDisposable, trackDisposable, markAsDisposed } from '../lifecycle.js';
-import { getLogger } from './logging/logging.js';
+import { assertFn } from '../../assert.js';
+import '../../arrays.js';
+import { onBugIndicatingError, BugIndicatingError } from '../../errors.js';
+import '../../event.js';
+import { trackDisposable, markAsDisposed, DisposableStore } from '../../lifecycle.js';
+import { getLogger } from '../logging/logging.js';
 
-function autorun(fn) {
-    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined));
-}
-function autorunOpts(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined));
-}
-function autorunHandleChanges(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.changeTracker));
-}
-function autorunWithStoreHandleChanges(options, fn) {
-    const store = ( new DisposableStore());
-    const disposable = autorunHandleChanges({
-        owner: options.owner,
-        debugName: options.debugName,
-        debugReferenceFn: options.debugReferenceFn ?? fn,
-        changeTracker: options.changeTracker,
-    }, (reader, changeSummary) => {
-        store.clear();
-        fn(reader, changeSummary, store);
-    });
-    return toDisposable(() => {
-        disposable.dispose();
-        store.dispose();
-    });
-}
-function autorunWithStore(fn) {
-    const store = ( new DisposableStore());
-    const disposable = autorunOpts({
-        owner: undefined,
-        debugName: undefined,
-        debugReferenceFn: fn,
-    }, reader => {
-        store.clear();
-        fn(reader, store);
-    });
-    return toDisposable(() => {
-        disposable.dispose();
-        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) => {
-        const newValues = ( new Map());
-        const removedValues = ( new Map(lastValues));
-        for (const value of getValue(reader)) {
-            const id = getUniqueIdentifier(value);
-            if (( lastValues.has(id))) {
-                removedValues.delete(id);
-            }
-            else {
-                newValues.set(id, value);
-                lastValues.set(id, value);
-            }
-        }
-        for (const id of ( removedValues.keys())) {
-            lastValues.delete(id);
-        }
-        if (newValues.size || removedValues.size) {
-            handler({ addedValues: [...( newValues.values())], removedValues: [...( removedValues.values())] });
-        }
-    });
-}
 var AutorunState;
 (function (AutorunState) {
     AutorunState[AutorunState["dependenciesMightHaveChanged"] = 1] = "dependenciesMightHaveChanged";
@@ -99,6 +26,8 @@ class AutorunObserver {
         this._dependencies = ( new Set());
         this._dependenciesToBeRemoved = ( new Set());
         this._isRunning = false;
+        this._store = undefined;
+        this._delayedStore = undefined;
         this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
         getLogger()?.handleAutorunCreated(this);
         this._run();
@@ -113,6 +42,12 @@ class AutorunObserver {
             o.removeObserver(this);
         }
         this._dependencies.clear();
+        if (this._store !== undefined) {
+            this._store.dispose();
+        }
+        if (this._delayedStore !== undefined) {
+            this._delayedStore.dispose();
+        }
         getLogger()?.handleAutorunDisposed(this);
         markAsDisposed(this);
     }
@@ -125,12 +60,20 @@ class AutorunObserver {
             if (!this._disposed) {
                 getLogger()?.handleAutorunStarted(this);
                 const changeSummary = this._changeSummary;
+                const delayedStore = this._delayedStore;
+                if (delayedStore !== undefined) {
+                    this._delayedStore = undefined;
+                }
                 try {
                     this._isRunning = 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._runFn(this, changeSummary);
                 }
                 catch (e) {
@@ -138,6 +81,9 @@ class AutorunObserver {
                 }
                 finally {
                     this._isRunning = false;
+                    if (delayedStore !== undefined) {
+                        delayedStore.dispose();
+                    }
                 }
             }
         }
@@ -210,10 +156,13 @@ class AutorunObserver {
     _isDependency(observable) {
         return ( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable));
     }
-    readObservable(observable) {
+    _ensureNoRunning() {
         if (!this._isRunning) {
             throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
         }
+    }
+    readObservable(observable) {
+        this._ensureNoRunning();
         if (this._disposed) {
             return observable.get();
         }
@@ -223,6 +172,26 @@ class AutorunObserver {
         this._dependenciesToBeRemoved.delete(observable);
         return value;
     }
+    get store() {
+        this._ensureNoRunning();
+        if (this._disposed) {
+            throw ( new BugIndicatingError('Cannot access store after dispose'));
+        }
+        if (this._store === undefined) {
+            this._store = ( new DisposableStore());
+        }
+        return this._store;
+    }
+    get delayedStore() {
+        this._ensureNoRunning();
+        if (this._disposed) {
+            throw ( new BugIndicatingError('Cannot access store after dispose'));
+        }
+        if (this._delayedStore === undefined) {
+            this._delayedStore = ( new DisposableStore());
+        }
+        return this._delayedStore;
+    }
     debugGetState() {
         return {
             isRunning: this._isRunning,
@@ -240,8 +209,5 @@ class AutorunObserver {
         }
     }
 }
-(function (autorun) {
-    autorun.Observer = AutorunObserver;
-})(autorun || (autorun = {}));
 
-export { AutorunObserver, AutorunState, autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };
+export { AutorunObserver, AutorunState };

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

@@ -0,0 +1,20 @@
+import { IObservable, ITransaction } from "../observable.js";
+export declare class ObservableSet<T> implements Set<T> {
+    private readonly _data;
+    private _obs;
+    readonly observable: IObservable<Set<T>>;
+    get size(): number;
+    has(value: T): boolean;
+    add(value: T, tx?: ITransaction): this;
+    delete(value: T, tx?: ITransaction): boolean;
+    clear(tx?: ITransaction): void;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[
+        T,
+        T
+    ]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+    get [Symbol.toStringTag](): string;
+}

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

@@ -0,0 +1,62 @@
+
+import './index.js';
+import { observableValueOpts } from './observables/observableValueOpts.js';
+
+class ObservableSet {
+    constructor() {
+        this._data = ( new Set());
+        this._obs = observableValueOpts({ equalsFn: () => false }, this);
+        this.observable = this._obs;
+    }
+    get size() {
+        return this._data.size;
+    }
+    has(value) {
+        return ( this._data.has(value));
+    }
+    add(value, tx) {
+        const hadValue = ( this._data.has(value));
+        if (!hadValue) {
+            this._data.add(value);
+            this._obs.set(this, tx);
+        }
+        return this;
+    }
+    delete(value, tx) {
+        const result = this._data.delete(value);
+        if (result) {
+            this._obs.set(this, tx);
+        }
+        return result;
+    }
+    clear(tx) {
+        if (this._data.size > 0) {
+            this._data.clear();
+            this._obs.set(this, tx);
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        this._data.forEach((value, value2, _set) => {
+            callbackfn.call(thisArg, value, value2, this);
+        });
+    }
+    *entries() {
+        for (const value of this._data) {
+            yield [value, value];
+        }
+    }
+    *keys() {
+        yield* ( this._data.keys());
+    }
+    *values() {
+        yield* ( this._data.values());
+    }
+    [Symbol.iterator]() {
+        return ( this.values());
+    }
+    get [Symbol.toStringTag]() {
+        return 'ObservableSet';
+    }
+}
+
+export { ObservableSet };

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

@@ -0,0 +1,18 @@
+import { IObservable, IObserver, ITransaction } from "./base.js";
+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;
+}

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

@@ -0,0 +1,91 @@
+
+import { handleBugIndicatingErrorRecovery } from './base.js';
+import { getFunctionName } from './debugName.js';
+import { getLogger } from './logging/logging.js';
+
+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;
+    }
+}
+
+export { TransactionImpl, asyncTransaction, globalTransaction, subtransaction, transaction };

package/vscode/src/vs/base/common/observableInternal/{promise.d.ts → utils/promise.d.ts}

@@ -1,4 +1,4 @@
-import { IObservable } from "./base.js";
+import { IObservable } from "../base.js";
 export declare class ObservableLazy<T> {
     private readonly _computeValue;
     private readonly _value;
@@ -12,6 +12,7 @@ export declare class ObservablePromise<T> {
     readonly promise: Promise<T>;
     readonly promiseResult: IObservable<PromiseResult<T> | undefined>;
     constructor(promise: Promise<T>);
+    readonly resolvedValue: import("../base.js").IObservableWithChange<T | undefined, void>;
 }
 export declare class PromiseResult<T> {
     readonly data: T | undefined;
@@ -22,7 +23,7 @@ export declare class PromiseResult<T> {
 export declare class ObservableLazyPromise<T> {
     private readonly _computePromise;
     private readonly _lazyValue;
-    readonly cachedPromiseResult: IObservable<PromiseResult<T> | undefined>;
+    readonly cachedPromiseResult: import("../base.js").IObservableWithChange<PromiseResult<T> | undefined, void>;
     constructor(_computePromise: () => Promise<T>);
     getPromise(): Promise<T>;
 }

package/vscode/src/vs/base/common/observableInternal/{promise.js → utils/promise.js}

@@ -1,6 +1,7 @@
 
-import { observableValue, transaction } from './base.js';
-import { derived } from './derived.js';
+import { transaction } from '../transaction.js';
+import { derived } from '../observables/derived.js';
+import { observableValue } from '../observables/observableValue.js';
 
 class ObservableLazy {
     get cachedValue() { return this._value; }
@@ -24,6 +25,13 @@ class ObservablePromise {
     constructor(promise) {
         this._value = observableValue(this, undefined);
         this.promiseResult = this._value;
+        this.resolvedValue = derived(this, reader => {
+            const result = this.promiseResult.read(reader);
+            if (!result) {
+                return undefined;
+            }
+            return result.getDataOrThrow();
+        });
         this.promise = promise.then(value => {
             transaction(tx => {
                 this._value.set(( new PromiseResult(value, undefined)), tx);

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

@@ -0,0 +1,7 @@
+import { IObservableWithChange } from "../base.js";
+import { CancellationToken } from "../commonFacade/cancellation.js";
+import { DisposableStore, IDisposable } from "../commonFacade/deps.js";
+export type RemoveUndefined<T> = T extends undefined ? never : T;
+export declare function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable;
+export declare function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable;
+export declare function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable;

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

@@ -0,0 +1,58 @@
+
+import '../../errors.js';
+import { cancelOnDispose } from '../../cancellation.js';
+import '../../arrays.js';
+import '../../event.js';
+import { DisposableStore } from '../../lifecycle.js';
+import { autorunWithStoreHandleChanges } from '../reactions/autorun.js';
+
+function runOnChange(observable, cb) {
+    let _previousValue;
+    let _firstRun = true;
+    return autorunWithStoreHandleChanges({
+        changeTracker: {
+            createChangeSummary: () => ({ deltas: [], didChange: false }),
+            handleChange: (context, changeSummary) => {
+                if (context.didChange(observable)) {
+                    const e = context.change;
+                    if (e !== undefined) {
+                        changeSummary.deltas.push(e);
+                    }
+                    changeSummary.didChange = true;
+                }
+                return true;
+            },
+        }
+    }, (reader, changeSummary) => {
+        const value = observable.read(reader);
+        const previousValue = _previousValue;
+        if (changeSummary.didChange) {
+            _previousValue = value;
+            cb(value, previousValue, changeSummary.deltas);
+        }
+        if (_firstRun) {
+            _firstRun = false;
+            _previousValue = value;
+        }
+    });
+}
+function runOnChangeWithStore(observable, cb) {
+    const store = ( new DisposableStore());
+    const disposable = runOnChange(observable, (value, previousValue, deltas) => {
+        store.clear();
+        cb(value, previousValue, deltas, store);
+    });
+    return {
+        dispose() {
+            disposable.dispose();
+            store.dispose();
+        }
+    };
+}
+function runOnChangeWithCancellationToken(observable, cb) {
+    return runOnChangeWithStore(observable, (value, previousValue, deltas, store) => {
+        cb(value, previousValue, deltas, cancelOnDispose(store));
+    });
+}
+
+export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore };

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

@@ -0,0 +1,28 @@
+import { IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from "../base.js";
+import { DebugOwner } from "../debugName.js";
+import { DisposableStore, Event, IDisposable } from "../commonFacade/deps.js";
+export declare function observableFromPromise<T>(promise: Promise<T>): IObservable<{
+    value?: T;
+}>;
+export declare function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void>;
+export declare function debouncedObservableDeprecated<T>(observable: IObservable<T>, debounceMs: number, disposableStore: DisposableStore): IObservable<T | undefined>;
+export declare function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number): IObservable<T>;
+export declare function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number, disposableStore: DisposableStore): IObservable<boolean>;
+export declare function keepObserved<T>(observable: IObservable<T>): IDisposable;
+export declare function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable;
+export declare class KeepAliveObserver implements IObserver {
+    private readonly _forceRecompute;
+    private readonly _handleValue;
+    private _counter;
+    constructor(_forceRecompute: boolean, _handleValue: ((value: any) => void) | undefined);
+    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 declare function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T>;
+export declare function derivedObservableWithWritableCache<T>(owner: object, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> & {
+    clearCache(transaction: ITransaction): void;
+    setCache(newValue: T | undefined, tx: ITransaction | undefined): void;
+};
+export declare function mapObservableArrayCached<TIn, TOut, TKey = TIn>(owner: DebugOwner, items: IObservable<readonly TIn[]>, map: (input: TIn, store: DisposableStore) => TOut, keySelector?: (input: TIn) => TKey): IObservable<readonly TOut[]>;