@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,281 +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 { autorun } from '../reactions/autorun';
-import { IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from '../base';
-import { transaction } from '../transaction';
-import { observableValue } from '../observables/observableValue';
-import { DebugOwner } from '../debugName';
-import { DisposableStore, Event, IDisposable, toDisposable } from '../commonFacade/deps';
-import { derived, derivedOpts } from '../observables/derived';
-import { observableFromEvent } from '../observables/observableFromEvent';
-import { observableSignal } from '../observables/observableSignal';
-import { _setKeepObserved, _setRecomputeInitiallyAndOnChange } from '../observables/baseObservable';
-
-export function observableFromPromise<T>(promise: Promise<T>): IObservable<{ value?: T }> {
-	const observable = observableValue<{ value?: T }>('promiseValue', {});
-	promise.then((value) => {
-		observable.set({ value }, undefined);
-	});
-	return observable;
-}
-
-export function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void> {
-	return derivedOpts({
-		owner,
-		equalsFn: () => false,
-	}, reader => {
-		observable.read(reader);
-	});
-}
-
-/**
- * @deprecated Use `debouncedObservable` instead.
- */
-export function debouncedObservableDeprecated<T>(observable: IObservable<T>, debounceMs: number, disposableStore: DisposableStore): IObservable<T | undefined> {
-	const debouncedObservable = observableValue<T | undefined>('debounced', undefined);
-
-	let timeout: Timeout | undefined = undefined;
-
-	disposableStore.add(autorun(reader => {
-		/** @description debounce */
-		const value = observable.read(reader);
-
-		if (timeout) {
-			clearTimeout(timeout);
-		}
-		timeout = setTimeout(() => {
-			transaction(tx => {
-				debouncedObservable.set(value, tx);
-			});
-		}, debounceMs);
-
-	}));
-
-	return debouncedObservable;
-}
-
-/**
- * Creates an observable that debounces the input observable.
- */
-export function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number): IObservable<T> {
-	let hasValue = false;
-	let lastValue: T | undefined;
-
-	let timeout: Timeout | undefined = undefined;
-
-	return observableFromEvent<T, void>(cb => {
-		const d = autorun(reader => {
-			const value = observable.read(reader);
-
-			if (!hasValue) {
-				hasValue = true;
-				lastValue = value;
-			} else {
-				if (timeout) {
-					clearTimeout(timeout);
-				}
-				timeout = setTimeout(() => {
-					lastValue = value;
-					cb();
-				}, debounceMs);
-			}
-		});
-		return {
-			dispose() {
-				d.dispose();
-				hasValue = false;
-				lastValue = undefined;
-			},
-		};
-	}, () => {
-		if (hasValue) {
-			return lastValue!;
-		} else {
-			return observable.get();
-		}
-	});
-}
-
-export function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number, disposableStore: DisposableStore): IObservable<boolean> {
-	const observable = observableValue('triggeredRecently', false);
-
-	let timeout: Timeout | undefined = undefined;
-
-	disposableStore.add(event(() => {
-		observable.set(true, undefined);
-
-		if (timeout) {
-			clearTimeout(timeout);
-		}
-		timeout = setTimeout(() => {
-			observable.set(false, undefined);
-		}, timeoutMs);
-	}));
-
-	return observable;
-}
-
-/**
- * This makes sure the observable is being observed and keeps its cache alive.
- */
-export function keepObserved<T>(observable: IObservable<T>): IDisposable {
-	const o = new KeepAliveObserver(false, undefined);
-	observable.addObserver(o);
-	return toDisposable(() => {
-		observable.removeObserver(o);
-	});
-}
-
-_setKeepObserved(keepObserved);
-
-/**
- * This converts the given observable into an autorun.
- */
-export function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable {
-	const o = new KeepAliveObserver(true, handleValue);
-	observable.addObserver(o);
-	try {
-		o.beginUpdate(observable);
-	} finally {
-		o.endUpdate(observable);
-	}
-
-	return toDisposable(() => {
-		observable.removeObserver(o);
-	});
-}
-
-_setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);
-
-export class KeepAliveObserver implements IObserver {
-	private _counter = 0;
-
-	constructor(
-		private readonly _forceRecompute: boolean,
-		private readonly _handleValue: ((value: any) => void) | undefined,
-	) { }
-
-	beginUpdate<T>(observable: IObservable<T>): void {
-		this._counter++;
-	}
-
-	endUpdate<T>(observable: IObservable<T>): void {
-		if (this._counter === 1 && this._forceRecompute) {
-			if (this._handleValue) {
-				this._handleValue(observable.get());
-			} else {
-				observable.reportChanges();
-			}
-		}
-		this._counter--;
-	}
-
-	handlePossibleChange<T>(observable: IObservable<T>): void {
-		// NO OP
-	}
-
-	handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void {
-		// NO OP
-	}
-}
-
-export function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> {
-	let lastValue: T | undefined = undefined;
-	const observable = derivedOpts({ owner, debugReferenceFn: computeFn }, reader => {
-		lastValue = computeFn(reader, lastValue);
-		return lastValue;
-	});
-	return observable;
-}
-
-export 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 } {
-	let lastValue: T | undefined = undefined;
-	const onChange = observableSignal('derivedObservableWithWritableCache');
-	const observable = derived(owner, reader => {
-		onChange.read(reader);
-		lastValue = computeFn(reader, lastValue);
-		return lastValue;
-	});
-	return Object.assign(observable, {
-		clearCache: (tx: ITransaction) => {
-			lastValue = undefined;
-			onChange.trigger(tx);
-		},
-		setCache: (newValue: T | undefined, tx: ITransaction | undefined) => {
-			lastValue = newValue;
-			onChange.trigger(tx);
-		}
-	});
-}
-
-/**
- * When the items array changes, referential equal items are not mapped again.
- */
-export 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[]> {
-	let m = new ArrayMap(map, keySelector);
-	const self = derivedOpts({
-		debugReferenceFn: map,
-		owner,
-		onLastObserverRemoved: () => {
-			m.dispose();
-			m = new ArrayMap(map);
-		}
-	}, (reader) => {
-		m.setItems(items.read(reader));
-		return m.getItems();
-	});
-	return self;
-}
-
-class ArrayMap<TIn, TOut, TKey> implements IDisposable {
-	private readonly _cache = new Map<TKey, { out: TOut; store: DisposableStore }>();
-	private _items: TOut[] = [];
-	constructor(
-		private readonly _map: (input: TIn, store: DisposableStore) => TOut,
-		private readonly _keySelector?: (input: TIn) => TKey,
-	) {
-	}
-
-	public dispose(): void {
-		this._cache.forEach(entry => entry.store.dispose());
-		this._cache.clear();
-	}
-
-	public setItems(items: readonly TIn[]): void {
-		const newItems: TOut[] = [];
-		const itemsToRemove = new Set(this._cache.keys());
-
-		for (const item of items) {
-			const key = this._keySelector ? this._keySelector(item) : item as unknown as TKey;
-
-			let entry = this._cache.get(key);
-			if (!entry) {
-				const store = new DisposableStore();
-				const out = this._map(item, store);
-				entry = { out, store };
-				this._cache.set(key, entry);
-			} else {
-				itemsToRemove.delete(key);
-			}
-			newItems.push(entry.out);
-		}
-
-		for (const item of itemsToRemove) {
-			const entry = this._cache.get(item)!;
-			entry.store.dispose();
-			this._cache.delete(item);
-		}
-
-		this._items = newItems;
-	}
-
-	public getItems(): TOut[] {
-		return this._items;
-	}
-}

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

@@ -1,101 +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 { IReader, IObservable } from '../base';
-import { DebugOwner, DebugNameData } from '../debugName';
-import { CancellationError, CancellationToken, CancellationTokenSource } from '../commonFacade/cancellation';
-import { strictEquals } from '../commonFacade/deps';
-import { autorun } from '../reactions/autorun';
-import { Derived } from '../observables/derivedImpl';
-import { DebugLocation } from '../debugLocation';
-
-/**
- * Resolves the promise when the observables state matches the predicate.
- */
-export function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;
-export function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;
-export function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;
-export function waitForState<T>(observable: IObservable<T>, predicate?: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T> {
-	if (!predicate) {
-		predicate = state => state !== null && state !== undefined;
-	}
-	return new Promise((resolve, reject) => {
-		let isImmediateRun = true;
-		let shouldDispose = false;
-		const stateObs = observable.map(state => {
-			/** @description waitForState.state */
-			return {
-				isFinished: predicate(state),
-				error: isError ? isError(state) : false,
-				state
-			};
-		});
-		const d = autorun(reader => {
-			/** @description waitForState */
-			const { isFinished, error, state } = stateObs.read(reader);
-			if (isFinished || error) {
-				if (isImmediateRun) {
-					// The variable `d` is not initialized yet
-					shouldDispose = true;
-				} else {
-					d.dispose();
-				}
-				if (error) {
-					reject(error === true ? state : error);
-				} else {
-					resolve(state);
-				}
-			}
-		});
-		if (cancellationToken) {
-			const dc = cancellationToken.onCancellationRequested(() => {
-				d.dispose();
-				dc.dispose();
-				reject(new CancellationError());
-			});
-			if (cancellationToken.isCancellationRequested) {
-				d.dispose();
-				dc.dispose();
-				reject(new CancellationError());
-				return;
-			}
-		}
-		isImmediateRun = false;
-		if (shouldDispose) {
-			d.dispose();
-		}
-	});
-}
-
-export function derivedWithCancellationToken<T>(computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
-export function derivedWithCancellationToken<T>(owner: object, computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
-export function derivedWithCancellationToken<T>(computeFnOrOwner: ((reader: IReader, cancellationToken: CancellationToken) => T) | object, computeFnOrUndefined?: ((reader: IReader, cancellationToken: CancellationToken) => T)): IObservable<T> {
-	let computeFn: (reader: IReader, store: CancellationToken) => T;
-	let owner: DebugOwner;
-	if (computeFnOrUndefined === undefined) {
-		computeFn = computeFnOrOwner as any;
-		owner = undefined;
-	} else {
-		owner = computeFnOrOwner;
-		computeFn = computeFnOrUndefined as any;
-	}
-
-	let cancellationTokenSource: CancellationTokenSource | undefined = undefined;
-	return new Derived(
-		new DebugNameData(owner, undefined, computeFn),
-		r => {
-			if (cancellationTokenSource) {
-				cancellationTokenSource.dispose(true);
-			}
-			cancellationTokenSource = new CancellationTokenSource();
-			return computeFn(r, cancellationTokenSource.token);
-		}, undefined,
-		() => cancellationTokenSource?.dispose(),
-		strictEquals,
-		DebugLocation.ofCaller()
-	);
-}

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

@@ -1,31 +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 { Event, IValueWithChangeEvent } from '../commonFacade/deps';
-import { DebugOwner } from '../debugName';
-import { observableFromEvent } from '../observables/observableFromEvent';
-
-export class ValueWithChangeEventFromObservable<T> implements IValueWithChangeEvent<T> {
-	constructor(public readonly observable: IObservable<T>) {
-	}
-
-	get onDidChange(): Event<void> {
-		return Event.fromObservableLight(this.observable);
-	}
-
-	get value(): T {
-		return this.observable.get();
-	}
-}
-
-export function observableFromValueWithChangeEvent<T>(owner: DebugOwner, value: IValueWithChangeEvent<T>): IObservable<T> {
-	if (value instanceof ValueWithChangeEventFromObservable) {
-		return value.observable;
-	}
-	return observableFromEvent(owner, value.onDidChange, () => value.value);
-}