@vscode/chat-lib 0.0.1 → 0.0.3

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

@@ -1,150 +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.
- *--------------------------------------------------------------------------------------------*/
-
-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

@@ -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, 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

@@ -1,61 +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.
- *--------------------------------------------------------------------------------------------*/
-
-// 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

@@ -1,388 +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 { 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;
-}