@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/base/common/observableInternal/reactions/autorunImpl.ts

@@ -1,256 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IObservable, IObservableWithChange, IObserver, IReaderWithStore } from '../base';
-import { DebugNameData } from '../debugName';
-import { assertFn, BugIndicatingError, DisposableStore, IDisposable, markAsDisposed, onBugIndicatingError, trackDisposable } from '../commonFacade/deps';
-import { getLogger } from '../logging/logging';
-import { IChangeTracker } from '../changeTracker';
-import { DebugLocation } from '../debugLocation';
-
-export const enum AutorunState {
-	/**
-	 * A dependency could have changed.
-	 * We need to explicitly ask them if at least one dependency changed.
-	 */
-	dependenciesMightHaveChanged = 1,
-
-	/**
-	 * A dependency changed and we need to recompute.
-	 */
-	stale = 2,
-	upToDate = 3,
-}
-
-export class AutorunObserver<TChangeSummary = any> implements IObserver, IReaderWithStore, IDisposable {
-	private _state = AutorunState.stale;
-	private _updateCount = 0;
-	private _disposed = false;
-	private _dependencies = new Set<IObservable<any>>();
-	private _dependenciesToBeRemoved = new Set<IObservable<any>>();
-	private _changeSummary: TChangeSummary | undefined;
-	private _isRunning = false;
-
-	public get debugName(): string {
-		return this._debugNameData.getDebugName(this) ?? '(anonymous)';
-	}
-
-	constructor(
-		public readonly _debugNameData: DebugNameData,
-		public readonly _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void,
-		private readonly _changeTracker: IChangeTracker<TChangeSummary> | undefined,
-		debugLocation: DebugLocation
-	) {
-		this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
-		getLogger()?.handleAutorunCreated(this, debugLocation);
-		this._run();
-
-		trackDisposable(this);
-	}
-
-	public dispose(): void {
-		if (this._disposed) {
-			return;
-		}
-		this._disposed = true;
-		for (const o of this._dependencies) {
-			o.removeObserver(this); // Warning: external call!
-		}
-		this._dependencies.clear();
-
-		if (this._store !== undefined) {
-			this._store.dispose();
-		}
-		if (this._delayedStore !== undefined) {
-			this._delayedStore.dispose();
-		}
-
-		getLogger()?.handleAutorunDisposed(this);
-		markAsDisposed(this);
-	}
-
-	private _run() {
-		const emptySet = this._dependenciesToBeRemoved;
-		this._dependenciesToBeRemoved = this._dependencies;
-		this._dependencies = emptySet;
-
-		this._state = AutorunState.upToDate;
-
-		try {
-			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); // Warning: external call!
-					}
-					if (this._store !== undefined) {
-						this._store.dispose();
-						this._store = undefined;
-					}
-
-					this._runFn(this, changeSummary); // Warning: external call!
-				} catch (e) {
-					onBugIndicatingError(e);
-				} finally {
-					this._isRunning = false;
-					if (delayedStore !== undefined) {
-						delayedStore.dispose();
-					}
-				}
-			}
-		} finally {
-			if (!this._disposed) {
-				getLogger()?.handleAutorunFinished(this);
-			}
-			// We don't want our observed observables to think that they are (not even temporarily) not being observed.
-			// Thus, we only unsubscribe from observables that are definitely not read anymore.
-			for (const o of this._dependenciesToBeRemoved) {
-				o.removeObserver(this); // Warning: external call!
-			}
-			this._dependenciesToBeRemoved.clear();
-		}
-	}
-
-	public toString(): string {
-		return `Autorun<${this.debugName}>`;
-	}
-
-	// IObserver implementation
-	public beginUpdate(_observable: IObservable<any>): void {
-		if (this._state === AutorunState.upToDate) {
-			this._state = AutorunState.dependenciesMightHaveChanged;
-		}
-		this._updateCount++;
-	}
-
-	public endUpdate(_observable: IObservable<any>): void {
-		try {
-			if (this._updateCount === 1) {
-				do {
-					if (this._state === AutorunState.dependenciesMightHaveChanged) {
-						this._state = AutorunState.upToDate;
-						for (const d of this._dependencies) {
-							d.reportChanges(); // Warning: external call!
-							if (this._state as AutorunState === AutorunState.stale) {
-								// The other dependencies will refresh on demand
-								break;
-							}
-						}
-					}
-
-					if (this._state !== AutorunState.upToDate) {
-						this._run(); // Warning: indirect external call!
-					}
-				} while (this._state !== AutorunState.upToDate);
-			}
-		} finally {
-			this._updateCount--;
-		}
-
-		assertFn(() => this._updateCount >= 0);
-	}
-
-	public handlePossibleChange(observable: IObservable<any>): void {
-		if (this._state === AutorunState.upToDate && this._isDependency(observable)) {
-			this._state = AutorunState.dependenciesMightHaveChanged;
-		}
-	}
-
-	public handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void {
-		if (this._isDependency(observable)) {
-			getLogger()?.handleAutorunDependencyChanged(this, observable, change);
-			try {
-				// Warning: external call!
-				const shouldReact = this._changeTracker ? this._changeTracker.handleChange({
-					changedObservable: observable,
-					change,
-					didChange: (o): this is any => o === observable as any,
-				}, this._changeSummary!) : true;
-				if (shouldReact) {
-					this._state = AutorunState.stale;
-				}
-			} catch (e) {
-				onBugIndicatingError(e);
-			}
-		}
-	}
-
-	private _isDependency(observable: IObservableWithChange<any, any>): boolean {
-		return this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable);
-	}
-
-	// IReader implementation
-
-	private _ensureNoRunning(): void {
-		if (!this._isRunning) { throw new BugIndicatingError('The reader object cannot be used outside its compute function!'); }
-	}
-
-	public readObservable<T>(observable: IObservable<T>): T {
-		this._ensureNoRunning();
-
-		// In case the run action disposes the autorun
-		if (this._disposed) {
-			return observable.get(); // warning: external call!
-		}
-
-		observable.addObserver(this); // warning: external call!
-		const value = observable.get(); // warning: external call!
-		this._dependencies.add(observable);
-		this._dependenciesToBeRemoved.delete(observable);
-		return value;
-	}
-
-	private _store: DisposableStore | undefined = undefined;
-	get store(): DisposableStore {
-		this._ensureNoRunning();
-		if (this._disposed) {
-			throw new BugIndicatingError('Cannot access store after dispose');
-		}
-
-		if (this._store === undefined) {
-			this._store = new DisposableStore();
-		}
-		return this._store;
-	}
-
-	private _delayedStore: DisposableStore | undefined = undefined;
-	get delayedStore(): DisposableStore {
-		this._ensureNoRunning();
-		if (this._disposed) {
-			throw new BugIndicatingError('Cannot access store after dispose');
-		}
-
-		if (this._delayedStore === undefined) {
-			this._delayedStore = new DisposableStore();
-		}
-		return this._delayedStore;
-	}
-
-	public debugGetState() {
-		return {
-			isRunning: this._isRunning,
-			updateCount: this._updateCount,
-			dependencies: this._dependencies,
-			state: this._state,
-		};
-	}
-
-	public debugRerun(): void {
-		if (!this._isRunning) {
-			this._run();
-		} else {
-			this._state = AutorunState.stale;
-		}
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/set.ts

@@ -1,78 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IObservable, ITransaction } from '../observable';
-import { observableValueOpts } from './observables/observableValueOpts';
-
-export class ObservableSet<T> implements Set<T> {
-
-	private readonly _data = new Set<T>();
-
-	private _obs = observableValueOpts({ equalsFn: () => false }, this);
-
-	readonly observable: IObservable<Set<T>> = this._obs;
-
-	get size(): number {
-		return this._data.size;
-	}
-
-	has(value: T): boolean {
-		return this._data.has(value);
-	}
-
-	add(value: T, tx?: ITransaction): this {
-		const hadValue = this._data.has(value);
-		if (!hadValue) {
-			this._data.add(value);
-			this._obs.set(this, tx);
-		}
-		return this;
-	}
-
-	delete(value: T, tx?: ITransaction): boolean {
-		const result = this._data.delete(value);
-		if (result) {
-			this._obs.set(this, tx);
-		}
-		return result;
-	}
-
-	clear(tx?: ITransaction): void {
-		if (this._data.size > 0) {
-			this._data.clear();
-			this._obs.set(this, tx);
-		}
-	}
-
-	forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void {
-		this._data.forEach((value, value2, _set) => {
-			callbackfn.call(thisArg, value, value2, this as any);
-		});
-	}
-
-	*entries(): IterableIterator<[T, T]> {
-		for (const value of this._data) {
-			yield [value, value];
-		}
-	}
-
-	*keys(): IterableIterator<T> {
-		yield* this._data.keys();
-	}
-
-	*values(): IterableIterator<T> {
-		yield* this._data.values();
-	}
-
-	[Symbol.iterator](): IterableIterator<T> {
-		return this.values();
-	}
-
-	get [Symbol.toStringTag](): string {
-		return 'ObservableSet';
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/transaction.ts

@@ -1,115 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { handleBugIndicatingErrorRecovery, IObservable, IObserver, ITransaction } from './base';
-import { getFunctionName } from './debugName';
-import { getLogger } from './logging/logging';
-
-/**
- * Starts a transaction in which many observables can be changed at once.
- * {@link fn} should start with a JS Doc using `@description` to give the transaction a debug name.
- * Reaction run on demand or when the transaction ends.
- */
-
-export function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void {
-	const tx = new TransactionImpl(fn, getDebugName);
-	try {
-		fn(tx);
-	} finally {
-		tx.finish();
-	}
-}
-let _globalTransaction: ITransaction | undefined = undefined;
-
-export function globalTransaction(fn: (tx: ITransaction) => void) {
-	if (_globalTransaction) {
-		fn(_globalTransaction);
-	} else {
-		const tx = new TransactionImpl(fn, undefined);
-		_globalTransaction = tx;
-		try {
-			fn(tx);
-		} finally {
-			tx.finish(); // During finish, more actions might be added to the transaction.
-
-			// Which is why we only clear the global transaction after finish.
-			_globalTransaction = undefined;
-		}
-	}
-}
-/** @deprecated */
-
-export async function asyncTransaction(fn: (tx: ITransaction) => Promise<void>, getDebugName?: () => string): Promise<void> {
-	const tx = new TransactionImpl(fn, getDebugName);
-	try {
-		await fn(tx);
-	} finally {
-		tx.finish();
-	}
-}
-/**
- * Allows to chain transactions.
- */
-
-export function subtransaction(tx: ITransaction | undefined, fn: (tx: ITransaction) => void, getDebugName?: () => string): void {
-	if (!tx) {
-		transaction(fn, getDebugName);
-	} else {
-		fn(tx);
-	}
-} export class TransactionImpl implements ITransaction {
-	private _updatingObservers: { observer: IObserver; observable: IObservable<any> }[] | null = [];
-
-	constructor(public readonly _fn: Function, private readonly _getDebugName?: () => string) {
-		getLogger()?.handleBeginTransaction(this);
-	}
-
-	public getDebugName(): string | undefined {
-		if (this._getDebugName) {
-			return this._getDebugName();
-		}
-		return getFunctionName(this._fn);
-	}
-
-	public updateObserver(observer: IObserver, observable: IObservable<any>): void {
-		if (!this._updatingObservers) {
-			// This happens when a transaction is used in a callback or async function.
-			// If an async transaction is used, make sure the promise awaits all users of the transaction (e.g. no race).
-			handleBugIndicatingErrorRecovery('Transaction already finished!');
-			// Error recovery
-			transaction(tx => {
-				tx.updateObserver(observer, observable);
-			});
-			return;
-		}
-
-		// When this gets called while finish is active, they will still get considered
-		this._updatingObservers.push({ observer, observable });
-		observer.beginUpdate(observable);
-	}
-
-	public finish(): void {
-		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);
-		}
-		// Prevent anyone from updating observers from now on.
-		this._updatingObservers = null;
-		getLogger()?.handleEndTransaction(this);
-	}
-
-	public debugGetUpdatingObservers() {
-		return this._updatingObservers;
-	}
-}
-

package/src/_internal/util/vs/base/common/observableInternal/utils/promise.ts

@@ -1,129 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { IObservable } from '../base';
-import { transaction } from '../transaction';
-import { derived } from '../observables/derived';
-import { observableValue } from '../observables/observableValue';
-
-export class ObservableLazy<T> {
-	private readonly _value = observableValue<T | undefined>(this, undefined);
-
-	/**
-	 * The cached value.
-	 * Does not force a computation of the value.
-	 */
-	public get cachedValue(): IObservable<T | undefined> { return this._value; }
-
-	constructor(private readonly _computeValue: () => T) {
-	}
-
-	/**
-	 * Returns the cached value.
-	 * Computes the value if the value has not been cached yet.
-	 */
-	public getValue(): T {
-		let v = this._value.get();
-		if (!v) {
-			v = this._computeValue();
-			this._value.set(v, undefined);
-		}
-		return v;
-	}
-}
-
-/**
- * A promise whose state is observable.
- */
-export class ObservablePromise<T> {
-	public static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T> {
-		return new ObservablePromise(fn());
-	}
-
-	private readonly _value = observableValue<PromiseResult<T> | undefined>(this, undefined);
-
-	/**
-	 * The promise that this object wraps.
-	 */
-	public readonly promise: Promise<T>;
-
-	/**
-	 * The current state of the promise.
-	 * Is `undefined` if the promise didn't resolve yet.
-	 */
-	public readonly promiseResult: IObservable<PromiseResult<T> | undefined> = this._value;
-
-	constructor(promise: Promise<T>) {
-		this.promise = promise.then(value => {
-			transaction(tx => {
-				/** @description onPromiseResolved */
-				this._value.set(new PromiseResult(value, undefined), tx);
-			});
-			return value;
-		}, error => {
-			transaction(tx => {
-				/** @description onPromiseRejected */
-				this._value.set(new PromiseResult<T>(undefined, error), tx);
-			});
-			throw error;
-		});
-	}
-
-	public readonly resolvedValue = derived(this, reader => {
-		const result = this.promiseResult.read(reader);
-		if (!result) {
-			return undefined;
-		}
-		return result.getDataOrThrow();
-	});
-}
-
-export class PromiseResult<T> {
-	constructor(
-		/**
-		 * The value of the resolved promise.
-		 * Undefined if the promise rejected.
-		 */
-		public readonly data: T | undefined,
-
-		/**
-		 * The error in case of a rejected promise.
-		 * Undefined if the promise resolved.
-		 */
-		public readonly error: unknown | undefined,
-	) {
-	}
-
-	/**
-	 * Returns the value if the promise resolved, otherwise throws the error.
-	 */
-	public getDataOrThrow(): T {
-		if (this.error) {
-			throw this.error;
-		}
-		return this.data!;
-	}
-}
-
-/**
- * A lazy promise whose state is observable.
- */
-export class ObservableLazyPromise<T> {
-	private readonly _lazyValue = new ObservableLazy(() => new ObservablePromise(this._computePromise()));
-
-	/**
-	 * Does not enforce evaluation of the promise compute function.
-	 * Is undefined if the promise has not been computed yet.
-	 */
-	public readonly cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
-
-	constructor(private readonly _computePromise: () => Promise<T>) {
-	}
-
-	public getPromise(): Promise<T> {
-		return this._lazyValue.getValue().promise;
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/utils/runOnChange.ts

@@ -1,65 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IObservableWithChange } from '../base';
-import { CancellationToken, cancelOnDispose } from '../commonFacade/cancellation';
-import { DisposableStore, IDisposable } from '../commonFacade/deps';
-import { autorunWithStoreHandleChanges } from '../reactions/autorun';
-
-export type RemoveUndefined<T> = T extends undefined ? never : T;
-
-export function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable {
-	let _previousValue: T | undefined;
-	let _firstRun = true;
-	return autorunWithStoreHandleChanges({
-		changeTracker: {
-			createChangeSummary: () => ({ deltas: [] as RemoveUndefined<TChange>[], didChange: false }),
-			handleChange: (context, changeSummary) => {
-				if (context.didChange(observable)) {
-					const e = context.change;
-					if (e !== undefined) {
-						changeSummary.deltas.push(e as RemoveUndefined<TChange>);
-					}
-					changeSummary.didChange = true;
-				}
-				return true;
-			},
-		}
-	}, (reader, changeSummary) => {
-		const value = observable.read(reader);
-		const previousValue = _previousValue;
-		if (changeSummary.didChange) {
-			_previousValue = value;
-			// didChange can never be true on the first autorun, so we know previousValue is defined
-			cb(value, previousValue!, changeSummary.deltas);
-		}
-		if (_firstRun) {
-			_firstRun = false;
-			_previousValue = value;
-		}
-	});
-}
-
-export function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable {
-	const store = new DisposableStore();
-	const disposable = runOnChange(observable, (value, previousValue: T, deltas) => {
-		store.clear();
-		cb(value, previousValue, deltas, store);
-	});
-	return {
-		dispose() {
-			disposable.dispose();
-			store.dispose();
-		}
-	};
-}
-
-export function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable {
-	return runOnChangeWithStore(observable, (value, previousValue, deltas, store) => {
-		cb(value, previousValue, deltas, cancelOnDispose(store));
-	});
-}