@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/base/common/observableInternal/observables/observableFromEvent.ts

@@ -1,174 +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 '../base';
-import { subtransaction } from '../transaction';
-import { EqualityComparer, Event, IDisposable, strictEquals } from '../commonFacade/deps';
-import { DebugOwner, DebugNameData, IDebugNameData } from '../debugName';
-import { getLogger } from '../logging/logging';
-import { BaseObservable } from './baseObservable';
-import { DebugLocation } from '../debugLocation';
-
-
-export function observableFromEvent<T, TArgs = unknown>(
-	owner: DebugOwner,
-	event: Event<TArgs>,
-	getValue: (args: TArgs | undefined) => T,
-	debugLocation?: DebugLocation,
-): IObservable<T>;
-export function observableFromEvent<T, TArgs = unknown>(
-	event: Event<TArgs>,
-	getValue: (args: TArgs | undefined) => T,
-): IObservable<T>;
-export function observableFromEvent(...args:
-	[owner: DebugOwner, event: Event<any>, getValue: (args: any | undefined) => any, debugLocation?: DebugLocation] |
-	[event: Event<any>, getValue: (args: any | undefined) => any]
-): IObservable<any> {
-	let owner;
-	let event;
-	let getValue;
-	let debugLocation;
-	if (args.length === 2) {
-		[event, getValue] = args;
-	} else {
-		[owner, event, getValue, debugLocation] = args;
-	}
-	return new FromEventObservable(
-		new DebugNameData(owner, undefined, getValue),
-		event,
-		getValue,
-		() => FromEventObservable.globalTransaction,
-		strictEquals,
-		debugLocation ?? DebugLocation.ofCaller()
-	);
-}
-
-export function observableFromEventOpts<T, TArgs = unknown>(
-	options: IDebugNameData & {
-		equalsFn?: EqualityComparer<T>;
-	},
-	event: Event<TArgs>,
-	getValue: (args: TArgs | undefined) => T,
-	debugLocation = DebugLocation.ofCaller()
-): IObservable<T> {
-	return new FromEventObservable(
-		new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue),
-		event,
-		getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals, debugLocation
-	);
-}
-
-export class FromEventObservable<TArgs, T> extends BaseObservable<T> {
-	public static globalTransaction: ITransaction | undefined;
-
-	private _value: T | undefined;
-	private _hasValue = false;
-	private _subscription: IDisposable | undefined;
-
-	constructor(
-		private readonly _debugNameData: DebugNameData,
-		private readonly event: Event<TArgs>,
-		public readonly _getValue: (args: TArgs | undefined) => T,
-		private readonly _getTransaction: () => ITransaction | undefined,
-		private readonly _equalityComparator: EqualityComparer<T>,
-		debugLocation: DebugLocation
-	) {
-		super(debugLocation);
-	}
-
-	private getDebugName(): string | undefined {
-		return this._debugNameData.getDebugName(this);
-	}
-
-	public get debugName(): string {
-		const name = this.getDebugName();
-		return 'From Event' + (name ? `: ${name}` : '');
-	}
-
-	protected override onFirstObserverAdded(): void {
-		this._subscription = this.event(this.handleEvent);
-	}
-
-	private readonly handleEvent = (args: TArgs | undefined) => {
-		const newValue = this._getValue(args);
-		const oldValue = this._value;
-
-		const didChange = !this._hasValue || !(this._equalityComparator(oldValue!, newValue));
-		let didRunTransaction = false;
-
-		if (didChange) {
-			this._value = newValue;
-
-			if (this._hasValue) {
-				didRunTransaction = true;
-				subtransaction(
-					this._getTransaction(),
-					(tx) => {
-						getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
-
-						for (const o of this._observers) {
-							tx.updateObserver(o, this);
-							o.handleChange(this, undefined);
-						}
-					},
-					() => {
-						const name = this.getDebugName();
-						return 'Event fired' + (name ? `: ${name}` : '');
-					}
-				);
-			}
-			this._hasValue = true;
-		}
-
-		if (!didRunTransaction) {
-			getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
-		}
-	};
-
-	protected override onLastObserverRemoved(): void {
-		this._subscription!.dispose();
-		this._subscription = undefined;
-		this._hasValue = false;
-		this._value = undefined;
-	}
-
-	public get(): T {
-		if (this._subscription) {
-			if (!this._hasValue) {
-				this.handleEvent(undefined);
-			}
-			return this._value!;
-		} else {
-			// no cache, as there are no subscribers to keep it updated
-			const value = this._getValue(undefined);
-			return value;
-		}
-	}
-
-	public debugSetValue(value: unknown) {
-		this._value = value as any;
-	}
-}
-
-export namespace observableFromEvent {
-	export const Observer = FromEventObservable;
-
-	export function batchEventsGlobally(tx: ITransaction, fn: () => void): void {
-		let didSet = false;
-		if (FromEventObservable.globalTransaction === undefined) {
-			FromEventObservable.globalTransaction = tx;
-			didSet = true;
-		}
-		try {
-			fn();
-		} finally {
-			if (didSet) {
-				FromEventObservable.globalTransaction = undefined;
-			}
-		}
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/observables/observableSignal.ts

@@ -1,67 +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, ITransaction } from '../base';
-import { transaction } from '../transaction';
-import { DebugNameData } from '../debugName';
-import { BaseObservable } from './baseObservable';
-import { DebugLocation } from '../debugLocation';
-
-/**
- * Creates a signal that can be triggered to invalidate observers.
- * Signals don't have a value - when they are triggered they indicate a change.
- * However, signals can carry a delta that is passed to observers.
- */
-export function observableSignal<TDelta = void>(debugName: string): IObservableSignal<TDelta>;
-export function observableSignal<TDelta = void>(owner: object): IObservableSignal<TDelta>;
-export function observableSignal<TDelta = void>(debugNameOrOwner: string | object, debugLocation = DebugLocation.ofCaller()): IObservableSignal<TDelta> {
-	if (typeof debugNameOrOwner === 'string') {
-		return new ObservableSignal<TDelta>(debugNameOrOwner, undefined, debugLocation);
-	} else {
-		return new ObservableSignal<TDelta>(undefined, debugNameOrOwner, debugLocation);
-	}
-}
-
-export interface IObservableSignal<TChange> extends IObservableWithChange<void, TChange> {
-	trigger(tx: ITransaction | undefined, change: TChange): void;
-}
-
-class ObservableSignal<TChange> extends BaseObservable<void, TChange> implements IObservableSignal<TChange> {
-	public get debugName() {
-		return new DebugNameData(this._owner, this._debugName, undefined).getDebugName(this) ?? 'Observable Signal';
-	}
-
-	public override toString(): string {
-		return this.debugName;
-	}
-
-	constructor(
-		private readonly _debugName: string | undefined,
-		private readonly _owner: object | undefined,
-		debugLocation: DebugLocation
-	) {
-		super(debugLocation);
-	}
-
-	public trigger(tx: ITransaction | undefined, change: TChange): void {
-		if (!tx) {
-			transaction(tx => {
-				this.trigger(tx, change);
-			}, () => `Trigger signal ${this.debugName}`);
-			return;
-		}
-
-		for (const o of this._observers) {
-			tx.updateObserver(o, this);
-			o.handleChange(this, change);
-		}
-	}
-
-	public override get(): void {
-		// NO OP
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/observables/observableSignalFromEvent.ts

@@ -1,62 +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 { Event, IDisposable } from '../commonFacade/deps';
-import { DebugOwner, DebugNameData } from '../debugName';
-import { BaseObservable } from './baseObservable';
-import { DebugLocation } from '../debugLocation';
-
-export function observableSignalFromEvent(
-	owner: DebugOwner | string,
-	event: Event<any>,
-	debugLocation = DebugLocation.ofCaller()
-): IObservable<void> {
-	return new FromEventObservableSignal(typeof owner === 'string' ? owner : new DebugNameData(owner, undefined, undefined), event, debugLocation);
-}
-
-class FromEventObservableSignal extends BaseObservable<void> {
-	private subscription: IDisposable | undefined;
-
-	public readonly debugName: string;
-	constructor(
-		debugNameDataOrName: DebugNameData | string,
-		private readonly event: Event<any>,
-		debugLocation: DebugLocation
-	) {
-		super(debugLocation);
-		this.debugName = typeof debugNameDataOrName === 'string'
-			? debugNameDataOrName
-			: debugNameDataOrName.getDebugName(this) ?? 'Observable Signal From Event';
-	}
-
-	protected override onFirstObserverAdded(): void {
-		this.subscription = this.event(this.handleEvent);
-	}
-
-	private readonly handleEvent = () => {
-		transaction(
-			(tx) => {
-				for (const o of this._observers) {
-					tx.updateObserver(o, this);
-					o.handleChange(this, undefined);
-				}
-			},
-			() => this.debugName
-		);
-	};
-
-	protected override onLastObserverRemoved(): void {
-		this.subscription!.dispose();
-		this.subscription = undefined;
-	}
-
-	public override get(): void {
-		// NO OP
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/observables/observableValue.ts

@@ -1,131 +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 { ISettableObservable, ITransaction } from '../base';
-import { TransactionImpl } from '../transaction';
-import { BaseObservable } from './baseObservable';
-import { EqualityComparer, IDisposable, strictEquals } from '../commonFacade/deps';
-import { DebugNameData } from '../debugName';
-import { getLogger } from '../logging/logging';
-import { DebugLocation } from '../debugLocation';
-
-/**
- * Creates an observable value.
- * Observers get informed when the value changes.
- * @template TChange An arbitrary type to describe how or why the value changed. Defaults to `void`.
- * Observers will receive every single change value.
- */
-
-export function observableValue<T, TChange = void>(name: string, initialValue: T): ISettableObservable<T, TChange>;
-export function observableValue<T, TChange = void>(owner: object, initialValue: T): ISettableObservable<T, TChange>;
-export function observableValue<T, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T, TChange> {
-	let debugNameData: DebugNameData;
-	if (typeof nameOrOwner === 'string') {
-		debugNameData = new DebugNameData(undefined, nameOrOwner, undefined);
-	} else {
-		debugNameData = new DebugNameData(nameOrOwner, undefined, undefined);
-	}
-	return new ObservableValue(debugNameData, initialValue, strictEquals, debugLocation);
-}
-
-export class ObservableValue<T, TChange = void>
-	extends BaseObservable<T, TChange>
-	implements ISettableObservable<T, TChange> {
-	protected _value: T;
-
-	get debugName() {
-		return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
-	}
-
-	constructor(
-		private readonly _debugNameData: DebugNameData,
-		initialValue: T,
-		private readonly _equalityComparator: EqualityComparer<T>,
-		debugLocation: DebugLocation
-	) {
-		super(debugLocation);
-		this._value = initialValue;
-
-		getLogger()?.handleObservableUpdated(this, { hadValue: false, newValue: initialValue, change: undefined, didChange: true, oldValue: undefined });
-	}
-	public override get(): T {
-		return this._value;
-	}
-
-	public set(value: T, tx: ITransaction | undefined, change: TChange): void {
-		if (change === undefined && this._equalityComparator(this._value, value)) {
-			return;
-		}
-
-		let _tx: TransactionImpl | undefined;
-		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();
-			}
-		}
-	}
-
-	override toString(): string {
-		return `${this.debugName}: ${this._value}`;
-	}
-
-	protected _setValue(newValue: T): void {
-		this._value = newValue;
-	}
-
-	public debugGetState() {
-		return {
-			value: this._value,
-		};
-	}
-
-	public debugSetValue(value: unknown) {
-		this._value = value as T;
-	}
-}
-/**
- * A disposable observable. When disposed, its value is also disposed.
- * When a new value is set, the previous value is disposed.
- */
-
-export function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T, TChange> & IDisposable {
-	let debugNameData: DebugNameData;
-	if (typeof nameOrOwner === 'string') {
-		debugNameData = new DebugNameData(undefined, nameOrOwner, undefined);
-	} else {
-		debugNameData = new DebugNameData(nameOrOwner, undefined, undefined);
-	}
-	return new DisposableObservableValue(debugNameData, initialValue, strictEquals, debugLocation);
-}
-
-export class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {
-	protected override _setValue(newValue: T): void {
-		if (this._value === newValue) {
-			return;
-		}
-		if (this._value) {
-			this._value.dispose();
-		}
-		this._value = newValue;
-	}
-
-	public dispose(): void {
-		this._value?.dispose();
-	}
-}

package/src/_internal/util/vs/base/common/observableInternal/observables/observableValueOpts.ts

@@ -1,37 +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 { ISettableObservable } from '../base';
-import { DebugNameData, IDebugNameData } from '../debugName';
-import { EqualityComparer, strictEquals } from '../commonFacade/deps';
-import { ObservableValue } from './observableValue';
-import { LazyObservableValue } from './lazyObservableValue';
-import { DebugLocation } from '../debugLocation';
-
-export function observableValueOpts<T, TChange = void>(
-	options: IDebugNameData & {
-		equalsFn?: EqualityComparer<T>;
-		lazy?: boolean;
-	},
-	initialValue: T,
-	debugLocation = DebugLocation.ofCaller(),
-): ISettableObservable<T, TChange> {
-	if (options.lazy) {
-		return new LazyObservableValue(
-			new DebugNameData(options.owner, options.debugName, undefined),
-			initialValue,
-			options.equalsFn ?? strictEquals,
-			debugLocation
-		);
-	}
-	return new ObservableValue(
-		new DebugNameData(options.owner, options.debugName, undefined),
-		initialValue,
-		options.equalsFn ?? strictEquals,
-		debugLocation
-	);
-}

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

@@ -1,188 +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 { IReaderWithStore, IReader, IObservable } from '../base';
-import { IChangeTracker } from '../changeTracker';
-import { DisposableStore, IDisposable, toDisposable } from '../commonFacade/deps';
-import { DebugNameData, IDebugNameData } from '../debugName';
-import { AutorunObserver } from './autorunImpl';
-import { DebugLocation } from '../debugLocation';
-
-/**
- * Runs immediately and whenever a transaction ends and an observed observable changed.
- * {@link fn} should start with a JS Doc using `@description` to name the autorun.
- */
-export function autorun(fn: (reader: IReaderWithStore) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {
-	return new AutorunObserver(
-		new DebugNameData(undefined, undefined, fn),
-		fn,
-		undefined,
-		debugLocation
-	);
-}
-
-/**
- * Runs immediately and whenever a transaction ends and an observed observable changed.
- * {@link fn} should start with a JS Doc using `@description` to name the autorun.
- */
-export function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReaderWithStore) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {
-	return new AutorunObserver(
-		new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn),
-		fn,
-		undefined,
-		debugLocation
-	);
-}
-
-/**
- * Runs immediately and whenever a transaction ends and an observed observable changed.
- * {@link fn} should start with a JS Doc using `@description` to name the autorun.
- *
- * Use `changeTracker.createChangeSummary` to create a "change summary" that can collect the changes.
- * Use `changeTracker.handleChange` to add a reported change to the change summary.
- * The run function is given the last change summary.
- * The change summary is discarded after the run function was called.
- *
- * @see autorun
- */
-export function autorunHandleChanges<TChangeSummary>(
-	options: IDebugNameData & {
-		changeTracker: IChangeTracker<TChangeSummary>;
-	},
-	fn: (reader: IReader, changeSummary: TChangeSummary) => void,
-	debugLocation = DebugLocation.ofCaller()
-): IDisposable {
-	return new AutorunObserver(
-		new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn),
-		fn,
-		options.changeTracker,
-		debugLocation
-	);
-}
-
-/**
- * @see autorunHandleChanges (but with a disposable store that is cleared before the next run or on dispose)
- */
-export function autorunWithStoreHandleChanges<TChangeSummary>(
-	options: IDebugNameData & {
-		changeTracker: IChangeTracker<TChangeSummary>;
-	},
-	fn: (reader: IReader, changeSummary: TChangeSummary, store: DisposableStore) => void
-): IDisposable {
-	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();
-	});
-}
-
-/**
- * @see autorun (but with a disposable store that is cleared before the next run or on dispose)
- *
- * @deprecated Use `autorun(reader => { reader.store.add(...) })` instead!
- */
-export function autorunWithStore(fn: (reader: IReader, store: DisposableStore) => void): IDisposable {
-	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();
-	});
-}
-
-export function autorunDelta<T>(
-	observable: IObservable<T>,
-	handler: (args: { lastValue: T | undefined; newValue: T }) => void
-): IDisposable {
-	let _lastValue: T | undefined;
-	return autorunOpts({ debugReferenceFn: handler }, (reader) => {
-		const newValue = observable.read(reader);
-		const lastValue = _lastValue;
-		_lastValue = newValue;
-		handler({ lastValue, newValue });
-	});
-}
-
-export function autorunIterableDelta<T>(
-	getValue: (reader: IReader) => Iterable<T>,
-	handler: (args: { addedValues: T[]; removedValues: T[] }) => void,
-	getUniqueIdentifier: (value: T) => unknown = v => v
-) {
-	const lastValues = new Map<unknown, T>();
-	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()] });
-		}
-	});
-}
-
-export interface IReaderWithDispose extends IReaderWithStore, IDisposable { }
-
-/**
- * An autorun with a `dispose()` method on its `reader` which cancels the autorun.
- * It it safe to call `dispose()` synchronously.
- */
-export function autorunSelfDisposable(fn: (reader: IReaderWithDispose) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {
-	let ar: IDisposable | undefined;
-	let disposed = false;
-
-	// eslint-disable-next-line prefer-const
-	ar = autorun(reader => {
-		fn({
-			delayedStore: reader.delayedStore,
-			store: reader.store,
-			readObservable: reader.readObservable.bind(reader),
-			dispose: () => {
-				ar?.dispose();
-				disposed = true;
-			}
-		});
-	}, debugLocation);
-
-	if (disposed) {
-		ar.dispose();
-	}
-
-	return ar;
-}