@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,133 +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 { AutorunObserver } from '../reactions/autorunImpl';
-import { IObservable } from '../base';
-import { TransactionImpl } from '../transaction';
-import type { Derived } from '../observables/derivedImpl';
-import { DebugLocation } from '../debugLocation';
-
-let globalObservableLogger: IObservableLogger | undefined;
-
-export function addLogger(logger: IObservableLogger): void {
-	if (!globalObservableLogger) {
-		globalObservableLogger = logger;
-	} else if (globalObservableLogger instanceof ComposedLogger) {
-		globalObservableLogger.loggers.push(logger);
-	} else {
-		globalObservableLogger = new ComposedLogger([globalObservableLogger, logger]);
-	}
-}
-
-export function getLogger(): IObservableLogger | undefined {
-	return globalObservableLogger;
-}
-
-let globalObservableLoggerFn: ((obs: IObservable<any>) => void) | undefined = undefined;
-export function setLogObservableFn(fn: (obs: IObservable<any>) => void): void {
-	globalObservableLoggerFn = fn;
-}
-
-export function logObservable(obs: IObservable<any>): void {
-	if (globalObservableLoggerFn) {
-		globalObservableLoggerFn(obs);
-	}
-}
-
-export interface IChangeInformation {
-	oldValue: unknown;
-	newValue: unknown;
-	change: unknown;
-	didChange: boolean;
-	hadValue: boolean;
-}
-
-export interface IObservableLogger {
-	handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
-	handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
-
-	handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void;
-
-	handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
-	handleAutorunDisposed(autorun: AutorunObserver): void;
-	handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
-	handleAutorunStarted(autorun: AutorunObserver): void;
-	handleAutorunFinished(autorun: AutorunObserver): void;
-
-	handleDerivedDependencyChanged(derived: Derived<any, any, any>, observable: IObservable<any>, change: unknown): void;
-	handleDerivedCleared(observable: Derived<any, any, any>): void;
-
-	handleBeginTransaction(transaction: TransactionImpl): void;
-	handleEndTransaction(transaction: TransactionImpl): void;
-}
-
-class ComposedLogger implements IObservableLogger {
-	constructor(
-		public readonly loggers: IObservableLogger[],
-	) { }
-
-	handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void {
-		for (const logger of this.loggers) {
-			logger.handleObservableCreated(observable, location);
-		}
-	}
-	handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void {
-		for (const logger of this.loggers) {
-			logger.handleOnListenerCountChanged(observable, newCount);
-		}
-	}
-	handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void {
-		for (const logger of this.loggers) {
-			logger.handleObservableUpdated(observable, info);
-		}
-	}
-	handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void {
-		for (const logger of this.loggers) {
-			logger.handleAutorunCreated(autorun, location);
-		}
-	}
-	handleAutorunDisposed(autorun: AutorunObserver): void {
-		for (const logger of this.loggers) {
-			logger.handleAutorunDisposed(autorun);
-		}
-	}
-	handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void {
-		for (const logger of this.loggers) {
-			logger.handleAutorunDependencyChanged(autorun, observable, change);
-		}
-	}
-	handleAutorunStarted(autorun: AutorunObserver): void {
-		for (const logger of this.loggers) {
-			logger.handleAutorunStarted(autorun);
-		}
-	}
-	handleAutorunFinished(autorun: AutorunObserver): void {
-		for (const logger of this.loggers) {
-			logger.handleAutorunFinished(autorun);
-		}
-	}
-	handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void {
-		for (const logger of this.loggers) {
-			logger.handleDerivedDependencyChanged(derived, observable, change);
-		}
-	}
-	handleDerivedCleared(observable: Derived<any>): void {
-		for (const logger of this.loggers) {
-			logger.handleDerivedCleared(observable);
-		}
-	}
-	handleBeginTransaction(transaction: TransactionImpl): void {
-		for (const logger of this.loggers) {
-			logger.handleBeginTransaction(transaction);
-		}
-	}
-	handleEndTransaction(transaction: TransactionImpl): void {
-		for (const logger of this.loggers) {
-			logger.handleEndTransaction(transaction);
-		}
-	}
-}

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

@@ -1,81 +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 ObservableMap<K, V> implements Map<K, V> {
-	private readonly _data = new Map<K, V>();
-
-	private readonly _obs = observableValueOpts({ equalsFn: () => false }, this);
-
-	readonly observable: IObservable<Map<K, V>> = this._obs;
-
-	get size(): number {
-		return this._data.size;
-	}
-
-	has(key: K): boolean {
-		return this._data.has(key);
-	}
-
-	get(key: K): V | undefined {
-		return this._data.get(key);
-	}
-
-	set(key: K, value: V, tx?: ITransaction): this {
-		const hadKey = this._data.has(key);
-		const oldValue = this._data.get(key);
-		if (!hadKey || oldValue !== value) {
-			this._data.set(key, value);
-			this._obs.set(this, tx);
-		}
-		return this;
-	}
-
-	delete(key: K, tx?: ITransaction): boolean {
-		const result = this._data.delete(key);
-		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: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
-		this._data.forEach((value, key, _map) => {
-			callbackfn.call(thisArg, value, key, this);
-		});
-	}
-
-	*entries(): IterableIterator<[K, V]> {
-		yield* this._data.entries();
-	}
-
-	*keys(): IterableIterator<K> {
-		yield* this._data.keys();
-	}
-
-	*values(): IterableIterator<V> {
-		yield* this._data.values();
-	}
-
-	[Symbol.iterator](): IterableIterator<[K, V]> {
-		return this.entries();
-	}
-
-	get [Symbol.toStringTag](): string {
-		return 'ObservableMap';
-	}
-}

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

@@ -1,172 +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, IObserver, IReader, IObservable } from '../base';
-import { DisposableStore } from '../commonFacade/deps';
-import { DebugLocation } from '../debugLocation';
-import { DebugOwner, getFunctionName } from '../debugName';
-import { getLogger, logObservable } from '../logging/logging';
-import type { keepObserved, recomputeInitiallyAndOnChange } from '../utils/utils';
-import { derivedOpts } from './derived';
-
-let _derived: typeof derivedOpts;
-/**
- * @internal
- * This is to allow splitting files.
-*/
-export function _setDerivedOpts(derived: typeof _derived) {
-	_derived = derived;
-}
-
-let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
-export function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange) {
-	_recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
-}
-
-let _keepObserved: typeof keepObserved;
-export function _setKeepObserved(keepObserved: typeof _keepObserved) {
-	_keepObserved = keepObserved;
-}
-
-export abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
-	get TChange(): TChange { return null!; }
-
-	public abstract get(): T;
-
-	public reportChanges(): void {
-		this.get();
-	}
-
-	public abstract addObserver(observer: IObserver): void;
-	public abstract removeObserver(observer: IObserver): void;
-
-	/** @sealed */
-	public read(reader: IReader | undefined): T {
-		if (reader) {
-			return reader.readObservable(this);
-		} else {
-			return this.get();
-		}
-	}
-
-	/** @sealed */
-	public map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
-	public map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
-	public map<TNew>(fnOrOwner: DebugOwner | ((value: T, reader: IReader) => TNew), fnOrUndefined?: (value: T, reader: IReader) => TNew, debugLocation: DebugLocation = DebugLocation.ofCaller()): IObservable<TNew> {
-		const owner = fnOrUndefined === undefined ? undefined : fnOrOwner as DebugOwner;
-		const fn = fnOrUndefined === undefined ? fnOrOwner as (value: T, reader: IReader) => TNew : fnOrUndefined;
-
-		return _derived(
-			{
-				owner,
-				debugName: () => {
-					const name = getFunctionName(fn);
-					if (name !== undefined) {
-						return name;
-					}
-
-					// regexp to match `x => x.y` or `x => x?.y` where x and y can be arbitrary identifiers (uses backref):
-					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),
-			debugLocation,
-		);
-	}
-
-	public abstract log(): IObservableWithChange<T, TChange>;
-
-	/**
-	 * @sealed
-	 * Converts an observable of an observable value into a direct observable of the value.
-	*/
-	public flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew> {
-		return _derived(
-			{
-				owner: undefined,
-				debugName: () => `${this.debugName} (flattened)`,
-			},
-			(reader) => this.read(reader).read(reader)
-		);
-	}
-
-	public recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T> {
-		store.add(_recomputeInitiallyAndOnChange!(this, handleValue));
-		return this;
-	}
-
-	/**
-	 * Ensures that this observable is observed. This keeps the cache alive.
-	 * However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
-	 * Use `recomputeInitiallyAndOnChange` for eager evaluation.
-	 */
-	public keepObserved(store: DisposableStore): IObservable<T> {
-		store.add(_keepObserved!(this));
-		return this;
-	}
-
-	public abstract get debugName(): string;
-
-	protected get debugValue() {
-		return this.get();
-	}
-}
-
-export abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
-	protected readonly _observers = new Set<IObserver>();
-
-	constructor(debugLocation: DebugLocation) {
-		super();
-		getLogger()?.handleObservableCreated(this, debugLocation);
-	}
-
-	public addObserver(observer: IObserver): void {
-		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);
-		}
-	}
-
-	public removeObserver(observer: IObserver): void {
-		const deleted = this._observers.delete(observer);
-		if (deleted && this._observers.size === 0) {
-			this.onLastObserverRemoved();
-		}
-		if (deleted) {
-			getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
-		}
-	}
-
-	protected onFirstObserverAdded(): void { }
-	protected onLastObserverRemoved(): void { }
-
-	public override log(): IObservableWithChange<T, TChange> {
-		const hadLogger = !!getLogger();
-		logObservable(this);
-		if (!hadLogger) {
-			getLogger()?.handleObservableCreated(this, DebugLocation.ofCaller());
-		}
-		return this;
-	}
-
-	public debugGetObservers() {
-		return this._observers;
-	}
-}

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

@@ -1,44 +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, IObserver, IObservableWithChange } from '../base';
-import { ConvenientObservable } from './baseObservable';
-
-/**
- * Represents an efficient observable whose value never changes.
- */
-
-export function constObservable<T>(value: T): IObservable<T> {
-	return new ConstObservable(value);
-}
-class ConstObservable<T> extends ConvenientObservable<T, void> {
-	constructor(private readonly value: T) {
-		super();
-	}
-
-	public override get debugName(): string {
-		return this.toString();
-	}
-
-	public get(): T {
-		return this.value;
-	}
-	public addObserver(observer: IObserver): void {
-		// NO OP
-	}
-	public removeObserver(observer: IObserver): void {
-		// NO OP
-	}
-
-	override log(): IObservableWithChange<T, void> {
-		return this;
-	}
-
-	override toString(): string {
-		return `Const: ${this.value}`;
-	}
-}

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

@@ -1,190 +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, IReader, ITransaction, ISettableObservable, IObservableWithChange } from '../base';
-import { IChangeTracker } from '../changeTracker';
-import { DisposableStore, EqualityComparer, IDisposable, strictEquals } from '../commonFacade/deps';
-import { DebugLocation } from '../debugLocation';
-import { DebugOwner, DebugNameData, IDebugNameData } from '../debugName';
-import { _setDerivedOpts } from './baseObservable';
-import { IDerivedReader, Derived, DerivedWithSetter } from './derivedImpl';
-
-/**
- * Creates an observable that is derived from other observables.
- * The value is only recomputed when absolutely needed.
- *
- * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
- */
-export function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export function derived<T, TChange = void>(
-	computeFnOrOwner: ((reader: IDerivedReader<TChange>) => T) | DebugOwner,
-	computeFn?: ((reader: IDerivedReader<TChange>) => T) | undefined,
-	debugLocation = DebugLocation.ofCaller()
-): IObservable<T> {
-	if (computeFn !== undefined) {
-		return new Derived(
-			new DebugNameData(computeFnOrOwner, undefined, computeFn),
-			computeFn,
-			undefined,
-			undefined,
-			strictEquals,
-			debugLocation,
-		);
-	}
-	return new Derived(
-		new DebugNameData(undefined, undefined, computeFnOrOwner as any),
-		computeFnOrOwner as any,
-		undefined,
-		undefined,
-		strictEquals,
-		debugLocation,
-	);
-}
-
-export function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T> {
-	return new DerivedWithSetter(
-		new DebugNameData(owner, undefined, computeFn),
-		computeFn,
-		undefined,
-		undefined,
-		strictEquals,
-		setter,
-		debugLocation
-	);
-}
-
-export function derivedOpts<T>(
-	options: IDebugNameData & {
-		equalsFn?: EqualityComparer<T>;
-		onLastObserverRemoved?: (() => void);
-	},
-	computeFn: (reader: IReader) => T,
-	debugLocation = DebugLocation.ofCaller()
-): IObservable<T> {
-	return new Derived(
-		new DebugNameData(options.owner, options.debugName, options.debugReferenceFn),
-		computeFn,
-		undefined,
-		options.onLastObserverRemoved,
-		options.equalsFn ?? strictEquals,
-		debugLocation
-	);
-}
-_setDerivedOpts(derivedOpts);
-
-/**
- * Represents an observable that is derived from other observables.
- * The value is only recomputed when absolutely needed.
- *
- * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
- *
- * Use `createEmptyChangeSummary` to create a "change summary" that can collect the changes.
- * Use `handleChange` to add a reported change to the change summary.
- * The compute function is given the last change summary.
- * The change summary is discarded after the compute function was called.
- *
- * @see derived
- */
-export function derivedHandleChanges<T, TDelta, TChangeSummary>(
-	options: IDebugNameData & {
-		changeTracker: IChangeTracker<TChangeSummary>;
-		equalityComparer?: EqualityComparer<T>;
-	},
-	computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T,
-	debugLocation = DebugLocation.ofCaller()
-): IObservableWithChange<T, TDelta> {
-	return new Derived(
-		new DebugNameData(options.owner, options.debugName, undefined),
-		computeFn,
-		options.changeTracker,
-		undefined,
-		options.equalityComparer ?? strictEquals,
-		debugLocation
-	);
-}
-
-/**
- * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
-*/
-export function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
-
-/**
- * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
-*/
-export function derivedWithStore<T>(owner: DebugOwner, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
-export function derivedWithStore<T>(computeFnOrOwner: ((reader: IReader, store: DisposableStore) => T) | DebugOwner, computeFnOrUndefined?: ((reader: IReader, store: DisposableStore) => T), debugLocation = DebugLocation.ofCaller()): IObservable<T> {
-	let computeFn: (reader: IReader, store: DisposableStore) => T;
-	let owner: DebugOwner;
-	if (computeFnOrUndefined === undefined) {
-		computeFn = computeFnOrOwner as any;
-		owner = undefined;
-	} else {
-		owner = computeFnOrOwner;
-		computeFn = computeFnOrUndefined as any;
-	}
-
-	// Intentionally re-assigned in case an inactive observable is re-used later
-	// eslint-disable-next-line local/code-no-potentially-unsafe-disposables
-	let store = new DisposableStore();
-
-	return new Derived(
-		new DebugNameData(owner, undefined, computeFn),
-		r => {
-			if (store.isDisposed) {
-				store = new DisposableStore();
-			} else {
-				store.clear();
-			}
-			return computeFn(r, store);
-		},
-		undefined,
-		() => store.dispose(),
-		strictEquals,
-		debugLocation
-	);
-}
-
-export function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;
-export function derivedDisposable<T extends IDisposable | undefined>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;
-export function derivedDisposable<T extends IDisposable | undefined>(computeFnOrOwner: ((reader: IReader) => T) | DebugOwner, computeFnOrUndefined?: ((reader: IReader) => T), debugLocation = DebugLocation.ofCaller()): IObservable<T> {
-	let computeFn: (reader: IReader) => T;
-	let owner: DebugOwner;
-	if (computeFnOrUndefined === undefined) {
-		computeFn = computeFnOrOwner as any;
-		owner = undefined;
-	} else {
-		owner = computeFnOrOwner;
-		computeFn = computeFnOrUndefined as any;
-	}
-
-	let store: DisposableStore | undefined = undefined;
-	return new Derived(
-		new DebugNameData(owner, undefined, computeFn),
-		r => {
-			if (!store) {
-				store = new DisposableStore();
-			} else {
-				store.clear();
-			}
-			const result = computeFn(r);
-			if (result) {
-				store.add(result);
-			}
-			return result;
-		},
-		undefined,
-		() => {
-			if (store) {
-				store.dispose();
-				store = undefined;
-			}
-		},
-		strictEquals,
-		debugLocation
-	);
-}