@vscode/chat-lib 0.0.1

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

@@ -0,0 +1,150 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface IDebugNameData {
+	/**
+	 * The owner object of an observable.
+	 * Used for debugging only, such as computing a name for the observable by iterating over the fields of the owner.
+	 */
+	readonly owner?: DebugOwner | undefined;
+
+	/**
+	 * A string or function that returns a string that represents the name of the observable.
+	 * Used for debugging only.
+	 */
+	readonly debugName?: DebugNameSource | undefined;
+
+	/**
+	 * A function that points to the defining function of the object.
+	 * Used for debugging only.
+	 */
+	readonly debugReferenceFn?: Function | undefined;
+}
+
+export class DebugNameData {
+	constructor(
+		public readonly owner: DebugOwner | undefined,
+		public readonly debugNameSource: DebugNameSource | undefined,
+		public readonly referenceFn: Function | undefined,
+	) { }
+
+	public getDebugName(target: object): string | undefined {
+		return getDebugName(target, this);
+	}
+}
+
+/**
+ * The owning object of an observable.
+ * Is only used for debugging purposes, such as computing a name for the observable by iterating over the fields of the owner.
+ */
+export type DebugOwner = object | undefined;
+export type DebugNameSource = string | (() => string | undefined);
+
+const countPerName = new Map<string, number>();
+const cachedDebugName = new WeakMap<object, string>();
+
+export function getDebugName(target: object, data: DebugNameData): string | undefined {
+	const cached = cachedDebugName.get(target);
+	if (cached) {
+		return cached;
+	}
+
+	const dbgName = computeDebugName(target, data);
+	if (dbgName) {
+		let count = countPerName.get(dbgName) ?? 0;
+		count++;
+		countPerName.set(dbgName, count);
+		const result = count === 1 ? dbgName : `${dbgName}#${count}`;
+		cachedDebugName.set(target, result);
+		return result;
+	}
+	return undefined;
+}
+
+function computeDebugName(self: object, data: DebugNameData): string | undefined {
+	const cached = cachedDebugName.get(self);
+	if (cached) {
+		return cached;
+	}
+
+	const ownerStr = data.owner ? formatOwner(data.owner) + `.` : '';
+
+	let result: string | undefined;
+	const debugNameSource = data.debugNameSource;
+	if (debugNameSource !== undefined) {
+		if (typeof debugNameSource === 'function') {
+			result = debugNameSource();
+			if (result !== undefined) {
+				return ownerStr + result;
+			}
+		} else {
+			return ownerStr + debugNameSource;
+		}
+	}
+
+	const referenceFn = data.referenceFn;
+	if (referenceFn !== undefined) {
+		result = getFunctionName(referenceFn);
+		if (result !== undefined) {
+			return ownerStr + result;
+		}
+	}
+
+	if (data.owner !== undefined) {
+		const key = findKey(data.owner, self);
+		if (key !== undefined) {
+			return ownerStr + key;
+		}
+	}
+	return undefined;
+}
+
+function findKey(obj: object, value: object): string | undefined {
+	for (const key in obj) {
+		if ((obj as any)[key] === value) {
+			return key;
+		}
+	}
+	return undefined;
+}
+
+const countPerClassName = new Map<string, number>();
+const ownerId = new WeakMap<object, string>();
+
+function formatOwner(owner: object): string {
+	const id = ownerId.get(owner);
+	if (id) {
+		return id;
+	}
+	const className = getClassName(owner) ?? 'Object';
+	let count = countPerClassName.get(className) ?? 0;
+	count++;
+	countPerClassName.set(className, count);
+	const result = count === 1 ? className : `${className}#${count}`;
+	ownerId.set(owner, result);
+	return result;
+}
+
+export function getClassName(obj: object): string | undefined {
+	const ctor = obj.constructor;
+	if (ctor) {
+		if (ctor.name === 'Object') {
+			return undefined;
+		}
+		return ctor.name;
+	}
+	return undefined;
+}
+
+export function getFunctionName(fn: Function): string | undefined {
+	const fnSrc = fn.toString();
+	// Pattern: /** @description ... */
+	const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
+	const match = regexp.exec(fnSrc);
+	const result = match ? match[1] : undefined;
+	return result?.trim();
+}

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

@@ -0,0 +1,62 @@
+//!!! 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 } from '../base';
+import { BugIndicatingError, DisposableStore } from '../commonFacade/deps';
+import { DebugOwner, getDebugName, DebugNameData } from '../debugName';
+import { observableFromEvent } from '../observables/observableFromEvent';
+import { autorunOpts } from '../reactions/autorun';
+import { derivedObservableWithCache } from '../utils/utils';
+
+/**
+ * Creates an observable that has the latest changed value of the given observables.
+ * Initially (and when not observed), it has the value of the last observable.
+ * When observed and any of the observables change, it has the value of the last changed observable.
+ * If multiple observables change in the same transaction, the last observable wins.
+*/
+export function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]['get']>> {
+	if (observables.length === 0) {
+		throw new BugIndicatingError();
+	}
+
+	let hasLastChangedValue = false;
+	let lastChangedValue: unknown = undefined;
+
+	const result = observableFromEvent<any, void>(owner, cb => {
+		const store = new DisposableStore();
+		for (const o of observables) {
+			store.add(autorunOpts({ debugName: () => getDebugName(result, new DebugNameData(owner, undefined, undefined)) + '.updateLastChangedValue' }, reader => {
+				hasLastChangedValue = true;
+				lastChangedValue = o.read(reader);
+				cb();
+			}));
+		}
+		store.add({
+			dispose() {
+				hasLastChangedValue = false;
+				lastChangedValue = undefined;
+			},
+		});
+		return store;
+	}, () => {
+		if (hasLastChangedValue) {
+			return lastChangedValue;
+		} else {
+			return observables[observables.length - 1].get();
+		}
+	});
+	return result;
+}
+
+/**
+ * Works like a derived.
+ * However, if the value is not undefined, it is cached and will not be recomputed anymore.
+ * In that case, the derived will unsubscribe from its dependencies.
+*/
+export function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined> {
+	return derivedObservableWithCache<T | undefined>(owner, (reader, lastValue) => lastValue ?? fn(reader));
+}

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

@@ -0,0 +1,61 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+// This is a facade for the observable implementation. Only import from here!
+
+export { observableValueOpts } from './observables/observableValueOpts';
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunSelfDisposable } from './reactions/autorun';
+export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction } from './base';
+export { disposableObservableValue } from './observables/observableValue';
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './observables/derived';
+export { type IDerivedReader } from './observables/derivedImpl';
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from './utils/promise';
+export { derivedWithCancellationToken, waitForState } from './utils/utilsCancellation';
+export {
+	debouncedObservableDeprecated, debouncedObservable, derivedObservableWithCache,
+	derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise,
+	recomputeInitiallyAndOnChange,
+	signalFromObservable, wasEventTriggeredRecently,
+} from './utils/utils';
+export { type DebugOwner } from './debugName';
+export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from './changeTracker';
+export { constObservable } from './observables/constObservable';
+export { type IObservableSignal, observableSignal } from './observables/observableSignal';
+export { observableFromEventOpts } from './observables/observableFromEvent';
+export { observableSignalFromEvent } from './observables/observableSignalFromEvent';
+export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from './transaction';
+export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from './utils/valueWithChangeEvent';
+export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, type RemoveUndefined } from './utils/runOnChange';
+export { derivedConstOnceDefined, latestChangedValue } from './experimental/utils';
+export { observableFromEvent } from './observables/observableFromEvent';
+export { observableValue } from './observables/observableValue';
+
+export { ObservableSet } from './set';
+export { ObservableMap } from './map';
+export { DebugLocation } from './debugLocation';
+
+import { addLogger, setLogObservableFn } from './logging/logging';
+import { ConsoleObservableLogger, logObservableToConsole } from './logging/consoleObservableLogger';
+import { DevToolsLogger } from './logging/debugger/devToolsLogger';
+import { env } from '../process';
+
+
+setLogObservableFn(logObservableToConsole);
+
+// Remove "//" in the next line to enable logging
+const enableLogging = false
+	// || Boolean("true") // done "weirdly" so that a lint warning prevents you from pushing this
+	;
+
+if (enableLogging) {
+	addLogger(new ConsoleObservableLogger());
+}
+
+if (env && env['VSCODE_DEV_DEBUG_OBSERVABLES']) {
+	// To debug observables you also need the extension "ms-vscode.debug-value-editor"
+	addLogger(DevToolsLogger.getInstance());
+}

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

@@ -0,0 +1,388 @@
+//!!! 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 { TransactionImpl } from '../transaction';
+import { IObservableLogger, IChangeInformation, addLogger } from './logging';
+import { FromEventObservable } from '../observables/observableFromEvent';
+import { getClassName } from '../debugName';
+import { Derived } from '../observables/derivedImpl';
+import { AutorunObserver } from '../reactions/autorunImpl';
+
+let consoleObservableLogger: ConsoleObservableLogger | undefined;
+
+export function logObservableToConsole(obs: IObservable<any>): void {
+	if (!consoleObservableLogger) {
+		consoleObservableLogger = new ConsoleObservableLogger();
+		addLogger(consoleObservableLogger);
+	}
+	consoleObservableLogger.addFilteredObj(obs);
+}
+
+export class ConsoleObservableLogger implements IObservableLogger {
+	private indentation = 0;
+
+	private _filteredObjects: Set<unknown> | undefined;
+
+	public addFilteredObj(obj: unknown): void {
+		if (!this._filteredObjects) {
+			this._filteredObjects = new Set();
+		}
+		this._filteredObjects.add(obj);
+	}
+
+	private _isIncluded(obj: unknown): boolean {
+		return this._filteredObjects?.has(obj) ?? true;
+	}
+
+	private textToConsoleArgs(text: ConsoleText): unknown[] {
+		return consoleTextToArgs([
+			normalText(repeat('|  ', this.indentation)),
+			text,
+		]);
+	}
+
+	private formatInfo(info: IChangeInformation): ConsoleText[] {
+		if (!info.hadValue) {
+			return [
+				normalText(` `),
+				styled(formatValue(info.newValue, 60), {
+					color: 'green',
+				}),
+				normalText(` (initial)`),
+			];
+		}
+		return info.didChange
+			? [
+				normalText(` `),
+				styled(formatValue(info.oldValue, 70), {
+					color: 'red',
+					strikeThrough: true,
+				}),
+				normalText(` `),
+				styled(formatValue(info.newValue, 60), {
+					color: 'green',
+				}),
+			]
+			: [normalText(` (unchanged)`)];
+	}
+
+	handleObservableCreated(observable: IObservable<any>): void {
+		if (observable instanceof Derived) {
+			const derived = observable;
+			this.changedObservablesSets.set(derived, new Set());
+
+			const debugTrackUpdating = false;
+			if (debugTrackUpdating) {
+				const updating: IObservable<any>[] = [];
+				(derived as any).__debugUpdating = updating;
+
+				const existingBeginUpdate = derived.beginUpdate;
+				derived.beginUpdate = (obs) => {
+					updating.push(obs);
+					return existingBeginUpdate.apply(derived, [obs]);
+				};
+
+				const existingEndUpdate = derived.endUpdate;
+				derived.endUpdate = (obs) => {
+					const idx = updating.indexOf(obs);
+					if (idx === -1) {
+						console.error('endUpdate called without beginUpdate', derived.debugName, obs.debugName);
+					}
+					updating.splice(idx, 1);
+					return existingEndUpdate.apply(derived, [obs]);
+				};
+			}
+		}
+	}
+
+	handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void {
+	}
+
+	handleObservableUpdated(observable: IObservable<unknown>, info: IChangeInformation): void {
+		if (!this._isIncluded(observable)) { return; }
+		if (observable instanceof Derived) {
+			this._handleDerivedRecomputed(observable, info);
+			return;
+		}
+
+		console.log(...this.textToConsoleArgs([
+			formatKind('observable value changed'),
+			styled(observable.debugName, { color: 'BlueViolet' }),
+			...this.formatInfo(info),
+		]));
+	}
+
+	private readonly changedObservablesSets = new WeakMap<object, Set<IObservable<any>>>();
+
+	formatChanges(changes: Set<IObservable<any>>): ConsoleText | undefined {
+		if (changes.size === 0) {
+			return undefined;
+		}
+		return styled(
+			' (changed deps: ' +
+			[...changes].map((o) => o.debugName).join(', ') +
+			')',
+			{ color: 'gray' }
+		);
+	}
+
+	handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void {
+		if (!this._isIncluded(derived)) { return; }
+
+		this.changedObservablesSets.get(derived)?.add(observable);
+	}
+
+	_handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void {
+		if (!this._isIncluded(derived)) { return; }
+
+		const changedObservables = this.changedObservablesSets.get(derived);
+		if (!changedObservables) { return; }
+		console.log(...this.textToConsoleArgs([
+			formatKind('derived recomputed'),
+			styled(derived.debugName, { color: 'BlueViolet' }),
+			...this.formatInfo(info),
+			this.formatChanges(changedObservables),
+			{ data: [{ fn: derived._debugNameData.referenceFn ?? derived._computeFn }] }
+		]));
+		changedObservables.clear();
+	}
+
+	handleDerivedCleared(derived: Derived<unknown>): void {
+		if (!this._isIncluded(derived)) { return; }
+
+		console.log(...this.textToConsoleArgs([
+			formatKind('derived cleared'),
+			styled(derived.debugName, { color: 'BlueViolet' }),
+		]));
+	}
+
+	handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void {
+		if (!this._isIncluded(observable)) { return; }
+
+		console.log(...this.textToConsoleArgs([
+			formatKind('observable from event triggered'),
+			styled(observable.debugName, { color: 'BlueViolet' }),
+			...this.formatInfo(info),
+			{ data: [{ fn: observable._getValue }] }
+		]));
+	}
+
+	handleAutorunCreated(autorun: AutorunObserver): void {
+		if (!this._isIncluded(autorun)) { return; }
+
+		this.changedObservablesSets.set(autorun, new Set());
+	}
+
+	handleAutorunDisposed(autorun: AutorunObserver): void {
+	}
+
+	handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void {
+		if (!this._isIncluded(autorun)) { return; }
+
+		this.changedObservablesSets.get(autorun)!.add(observable);
+	}
+
+	handleAutorunStarted(autorun: AutorunObserver): void {
+		const changedObservables = this.changedObservablesSets.get(autorun);
+		if (!changedObservables) { return; }
+
+		if (this._isIncluded(autorun)) {
+			console.log(...this.textToConsoleArgs([
+				formatKind('autorun'),
+				styled(autorun.debugName, { color: 'BlueViolet' }),
+				this.formatChanges(changedObservables),
+				{ data: [{ fn: autorun._debugNameData.referenceFn ?? autorun._runFn }] }
+			]));
+		}
+		changedObservables.clear();
+		this.indentation++;
+	}
+
+	handleAutorunFinished(autorun: AutorunObserver): void {
+		this.indentation--;
+	}
+
+	handleBeginTransaction(transaction: TransactionImpl): void {
+		let transactionName = transaction.getDebugName();
+		if (transactionName === undefined) {
+			transactionName = '';
+		}
+		if (this._isIncluded(transaction)) {
+			console.log(...this.textToConsoleArgs([
+				formatKind('transaction'),
+				styled(transactionName, { color: 'BlueViolet' }),
+				{ data: [{ fn: transaction._fn }] }
+			]));
+		}
+		this.indentation++;
+	}
+
+	handleEndTransaction(): void {
+		this.indentation--;
+	}
+}
+type ConsoleText = (ConsoleText | undefined)[] |
+{ text: string; style: string; data?: unknown[] } |
+{ data: unknown[] };
+function consoleTextToArgs(text: ConsoleText): unknown[] {
+	const styles = new Array<any>();
+	const data: unknown[] = [];
+	let firstArg = '';
+
+	function process(t: ConsoleText): void {
+		if ('length' in t) {
+			for (const item of t) {
+				if (item) {
+					process(item);
+				}
+			}
+		} else if ('text' in t) {
+			firstArg += `%c${t.text}`;
+			styles.push(t.style);
+			if (t.data) {
+				data.push(...t.data);
+			}
+		} else if ('data' in t) {
+			data.push(...t.data);
+		}
+	}
+
+	process(text);
+
+	const result = [firstArg, ...styles];
+	result.push(...data);
+	return result;
+}
+function normalText(text: string): ConsoleText {
+	return styled(text, { color: 'black' });
+}
+function formatKind(kind: string): ConsoleText {
+	return styled(padStr(`${kind}: `, 10), { color: 'black', bold: true });
+}
+function styled(
+	text: string,
+	options: { color: string; strikeThrough?: boolean; bold?: boolean } = {
+		color: 'black',
+	}
+): ConsoleText {
+	function objToCss(styleObj: Record<string, string>): string {
+		return Object.entries(styleObj).reduce(
+			(styleString, [propName, propValue]) => {
+				return `${styleString}${propName}:${propValue};`;
+			},
+			''
+		);
+	}
+
+	const style: Record<string, string> = {
+		color: options.color,
+	};
+	if (options.strikeThrough) {
+		style['text-decoration'] = 'line-through';
+	}
+	if (options.bold) {
+		style['font-weight'] = 'bold';
+	}
+
+	return {
+		text,
+		style: objToCss(style),
+	};
+}
+
+export function formatValue(value: unknown, availableLen: number): string {
+	switch (typeof value) {
+		case 'number':
+			return '' + value;
+		case 'string':
+			if (value.length + 2 <= availableLen) {
+				return `"${value}"`;
+			}
+			return `"${value.substr(0, availableLen - 7)}"+...`;
+
+		case 'boolean':
+			return value ? 'true' : 'false';
+		case 'undefined':
+			return 'undefined';
+		case 'object':
+			if (value === null) {
+				return 'null';
+			}
+			if (Array.isArray(value)) {
+				return formatArray(value, availableLen);
+			}
+			return formatObject(value, availableLen);
+		case 'symbol':
+			return value.toString();
+		case 'function':
+			return `[[Function${value.name ? ' ' + value.name : ''}]]`;
+		default:
+			return '' + value;
+	}
+}
+
+function formatArray(value: unknown[], availableLen: number): string {
+	let result = '[ ';
+	let first = true;
+	for (const val of value) {
+		if (!first) {
+			result += ', ';
+		}
+		if (result.length - 5 > availableLen) {
+			result += '...';
+			break;
+		}
+		first = false;
+		result += `${formatValue(val, availableLen - result.length)}`;
+	}
+	result += ' ]';
+	return result;
+}
+
+function formatObject(value: object, availableLen: number): string {
+	if (typeof value.toString === 'function' && value.toString !== Object.prototype.toString) {
+		const val = value.toString();
+		if (val.length <= availableLen) {
+			return val;
+		}
+		return val.substring(0, availableLen - 3) + '...';
+	}
+
+	const className = getClassName(value);
+
+	let result = className ? className + '(' : '{ ';
+	let first = true;
+	for (const [key, val] of Object.entries(value)) {
+		if (!first) {
+			result += ', ';
+		}
+		if (result.length - 5 > availableLen) {
+			result += '...';
+			break;
+		}
+		first = false;
+		result += `${key}: ${formatValue(val, availableLen - result.length)}`;
+	}
+	result += className ? ')' : ' }';
+	return result;
+}
+
+function repeat(str: string, count: number): string {
+	let result = '';
+	for (let i = 1; i <= count; i++) {
+		result += str;
+	}
+	return result;
+}
+
+function padStr(str: string, length: number): string {
+	while (str.length < length) {
+		str += ' ';
+	}
+	return str;
+}