@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/base/common/objects.ts

@@ -0,0 +1,242 @@
+//!!! 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 { isTypedArray, isObject, isUndefinedOrNull } from './types';
+
+export function deepClone<T>(obj: T): T {
+	if (!obj || typeof obj !== 'object') {
+		return obj;
+	}
+	if (obj instanceof RegExp) {
+		return obj;
+	}
+	const result: any = Array.isArray(obj) ? [] : {};
+	Object.entries(obj).forEach(([key, value]) => {
+		result[key] = value && typeof value === 'object' ? deepClone(value) : value;
+	});
+	return result;
+}
+
+export function deepFreeze<T>(obj: T): T {
+	if (!obj || typeof obj !== 'object') {
+		return obj;
+	}
+	const stack: any[] = [obj];
+	while (stack.length > 0) {
+		const obj = stack.shift();
+		Object.freeze(obj);
+		for (const key in obj) {
+			if (_hasOwnProperty.call(obj, key)) {
+				const prop = obj[key];
+				if (typeof prop === 'object' && !Object.isFrozen(prop) && !isTypedArray(prop)) {
+					stack.push(prop);
+				}
+			}
+		}
+	}
+	return obj;
+}
+
+const _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+export function cloneAndChange(obj: any, changer: (orig: any) => any): any {
+	return _cloneAndChange(obj, changer, new Set());
+}
+
+function _cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<any>): any {
+	if (isUndefinedOrNull(obj)) {
+		return obj;
+	}
+
+	const changed = changer(obj);
+	if (typeof changed !== 'undefined') {
+		return changed;
+	}
+
+	if (Array.isArray(obj)) {
+		const r1: any[] = [];
+		for (const e of obj) {
+			r1.push(_cloneAndChange(e, changer, seen));
+		}
+		return r1;
+	}
+
+	if (isObject(obj)) {
+		if (seen.has(obj)) {
+			throw new Error('Cannot clone recursive data-structure');
+		}
+		seen.add(obj);
+		const r2 = {};
+		for (const i2 in obj) {
+			if (_hasOwnProperty.call(obj, i2)) {
+				(r2 as any)[i2] = _cloneAndChange(obj[i2], changer, seen);
+			}
+		}
+		seen.delete(obj);
+		return r2;
+	}
+
+	return obj;
+}
+
+/**
+ * Copies all properties of source into destination. The optional parameter "overwrite" allows to control
+ * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).
+ */
+export function mixin(destination: any, source: any, overwrite: boolean = true): any {
+	if (!isObject(destination)) {
+		return source;
+	}
+
+	if (isObject(source)) {
+		Object.keys(source).forEach(key => {
+			if (key in destination) {
+				if (overwrite) {
+					if (isObject(destination[key]) && isObject(source[key])) {
+						mixin(destination[key], source[key], overwrite);
+					} else {
+						destination[key] = source[key];
+					}
+				}
+			} else {
+				destination[key] = source[key];
+			}
+		});
+	}
+	return destination;
+}
+
+export function equals(one: any, other: any): boolean {
+	if (one === other) {
+		return true;
+	}
+	if (one === null || one === undefined || other === null || other === undefined) {
+		return false;
+	}
+	if (typeof one !== typeof other) {
+		return false;
+	}
+	if (typeof one !== 'object') {
+		return false;
+	}
+	if ((Array.isArray(one)) !== (Array.isArray(other))) {
+		return false;
+	}
+
+	let i: number;
+	let key: string;
+
+	if (Array.isArray(one)) {
+		if (one.length !== other.length) {
+			return false;
+		}
+		for (i = 0; i < one.length; i++) {
+			if (!equals(one[i], other[i])) {
+				return false;
+			}
+		}
+	} else {
+		const oneKeys: string[] = [];
+
+		for (key in one) {
+			oneKeys.push(key);
+		}
+		oneKeys.sort();
+		const otherKeys: string[] = [];
+		for (key in other) {
+			otherKeys.push(key);
+		}
+		otherKeys.sort();
+		if (!equals(oneKeys, otherKeys)) {
+			return false;
+		}
+		for (i = 0; i < oneKeys.length; i++) {
+			if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+/**
+ * Calls `JSON.Stringify` with a replacer to break apart any circular references.
+ * This prevents `JSON`.stringify` from throwing the exception
+ *  "Uncaught TypeError: Converting circular structure to JSON"
+ */
+export function safeStringify(obj: any): string {
+	const seen = new Set<any>();
+	return JSON.stringify(obj, (key, value) => {
+		if (isObject(value) || Array.isArray(value)) {
+			if (seen.has(value)) {
+				return '[Circular]';
+			} else {
+				seen.add(value);
+			}
+		}
+		if (typeof value === 'bigint') {
+			return `[BigInt ${value.toString()}]`;
+		}
+		return value;
+	});
+}
+
+type obj = { [key: string]: any };
+/**
+ * Returns an object that has keys for each value that is different in the base object. Keys
+ * that do not exist in the target but in the base object are not considered.
+ *
+ * Note: This is not a deep-diffing method, so the values are strictly taken into the resulting
+ * object if they differ.
+ *
+ * @param base the object to diff against
+ * @param obj the object to use for diffing
+ */
+export function distinct(base: obj, target: obj): obj {
+	const result = Object.create(null);
+
+	if (!base || !target) {
+		return result;
+	}
+
+	const targetKeys = Object.keys(target);
+	targetKeys.forEach(k => {
+		const baseValue = base[k];
+		const targetValue = target[k];
+
+		if (!equals(baseValue, targetValue)) {
+			result[k] = targetValue;
+		}
+	});
+
+	return result;
+}
+
+export function getCaseInsensitive(target: obj, key: string): unknown {
+	const lowercaseKey = key.toLowerCase();
+	const equivalentKey = Object.keys(target).find(k => k.toLowerCase() === lowercaseKey);
+	return equivalentKey ? target[equivalentKey] : target[key];
+}
+
+export function filter(obj: obj, predicate: (key: string, value: any) => boolean): obj {
+	const result = Object.create(null);
+	for (const [key, value] of Object.entries(obj)) {
+		if (predicate(key, value)) {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
+export function mapValues<T extends {}, R>(obj: T, fn: (value: T[keyof T], key: string) => R): { [K in keyof T]: R } {
+	const result: { [key: string]: R } = {};
+	for (const [key, value] of Object.entries(obj)) {
+		result[key] = fn(<T[keyof T]>value, key);
+	}
+	return result as { [K in keyof T]: R };
+}

package/src/_internal/util/vs/base/common/observable.ts

@@ -0,0 +1,10 @@
+//!!! 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 * from './observableInternal/index';

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

@@ -0,0 +1,208 @@
+//!!! 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 { DisposableStore, onUnexpectedError } from './commonFacade/deps';
+
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ */
+// This interface exists so that, for example for string observables,
+// typescript renders the type as `IObservable<string>` instead of `IObservable<string, unknown>`.
+export interface IObservable<T> extends IObservableWithChange<T, unknown> { }
+
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ * @template TChange The type used to describe value changes
+ * (usually `void` and only used in advanced scenarios).
+ * While observers can miss temporary values of an observable,
+ * they will receive all change values (as long as they are subscribed)!
+ */
+export interface IObservableWithChange<T, TChange = unknown> {
+	/**
+	 * Returns the current value.
+	 *
+	 * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+	 * Must not be called from {@link IObserver.handleChange}!
+	 */
+	get(): T;
+
+	/**
+	 * Forces the observable to check for changes and report them.
+	 *
+	 * Has the same effect as calling {@link IObservable.get}, but does not force the observable
+	 * to actually construct the value, e.g. if change deltas are used.
+	 * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+	 * Must not be called from {@link IObserver.handleChange}!
+	 */
+	reportChanges(): void;
+
+	/**
+	 * Adds the observer to the set of subscribed observers.
+	 * This method is idempotent.
+	 */
+	addObserver(observer: IObserver): void;
+
+	/**
+	 * Removes the observer from the set of subscribed observers.
+	 * This method is idempotent.
+	 */
+	removeObserver(observer: IObserver): void;
+
+	// #region These members have a standard implementation and are only part of the interface for convenience.
+
+	/**
+	 * Reads the current value and subscribes the reader to this observable.
+	 *
+	 * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
+	 * (see {@link ConvenientObservable.read} for the implementation).
+	 */
+	read(reader: IReader | undefined): T;
+
+	/**
+	 * Makes sure this value is computed eagerly.
+	 */
+	recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+
+	/**
+	 * Makes sure this value is cached.
+	 */
+	keepObserved(store: DisposableStore): IObservable<T>;
+
+	/**
+	 * Creates a derived observable that depends on this observable.
+	 * Use the reader to read other observables
+	 * (see {@link ConvenientObservable.map} for the implementation).
+	 */
+	map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+	map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+
+	flatten<TNew>(this: IObservable<IObservable<TNew>>): IObservable<TNew>;
+
+	/**
+	 * ONLY FOR DEBUGGING!
+	 * Logs computations of this derived.
+	*/
+	log(): IObservableWithChange<T, TChange>;
+
+	/**
+	 * A human-readable name for debugging purposes.
+	 */
+	readonly debugName: string;
+
+	/**
+	 * This property captures the type of the change object. Do not use it at runtime!
+	 */
+	readonly TChange: TChange;
+
+	// #endregion
+}
+
+/**
+ * Represents an observer that can be subscribed to an observable.
+ *
+ * If an observer is subscribed to an observable and that observable didn't signal
+ * a change through one of the observer methods, the observer can assume that the
+ * observable didn't change.
+ * If an observable reported a possible change, {@link IObservable.reportChanges} forces
+ * the observable to report an actual change if there was one.
+ */
+export interface IObserver {
+	/**
+	 * Signals that the given observable might have changed and a transaction potentially modifying that observable started.
+	 * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.
+	 *
+	 * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+	 * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+	 */
+	beginUpdate<T>(observable: IObservable<T>): void;
+
+	/**
+	 * Signals that the transaction that potentially modified the given observable ended.
+	 * This is a good place to react to (potential) changes.
+	 */
+	endUpdate<T>(observable: IObservable<T>): void;
+
+	/**
+	 * Signals that the given observable might have changed.
+	 * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+	 *
+	 * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+	 * The change should be processed lazily or in {@link IObserver.endUpdate}.
+	 */
+	handlePossibleChange<T>(observable: IObservable<T>): void;
+
+	/**
+	 * Signals that the given {@link observable} changed.
+	 *
+	 * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+	 * The change should be processed lazily or in {@link IObserver.endUpdate}.
+	 *
+	 * @param change Indicates how or why the value changed.
+	 */
+	handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
+}
+
+export interface IReader {
+	/**
+	 * Reads the value of an observable and subscribes to it.
+	 */
+	readObservable<T>(observable: IObservableWithChange<T, any>): T;
+}
+
+export interface ISettable<T, TChange = void> {
+	/**
+	 * Sets the value of the observable.
+	 * Use a transaction to batch multiple changes (with a transaction, observers only react at the end of the transaction).
+	 *
+	 * @param transaction When given, value changes are handled on demand or when the transaction ends.
+	 * @param change Describes how or why the value changed.
+	 */
+	set(value: T, transaction: ITransaction | undefined, change: TChange): void;
+}
+
+export interface ITransaction {
+	/**
+	 * Calls {@link Observer.beginUpdate} immediately
+	 * and {@link Observer.endUpdate} when the transaction ends.
+	 */
+	updateObserver(observer: IObserver, observable: IObservableWithChange<any, any>): void;
+}
+
+/**
+ * This function is used to indicate that the caller recovered from an error that indicates a bug.
+*/
+export function handleBugIndicatingErrorRecovery(message: string) {
+	const err = new Error('BugIndicatingErrorRecovery: ' + message);
+	onUnexpectedError(err);
+	console.error('recovered from an error that indicates a bug', err);
+}
+
+/**
+ * A settable observable.
+ */
+export interface ISettableObservable<T, TChange = void> extends IObservableWithChange<T, TChange>, ISettable<T, TChange> {
+}
+
+export interface IReaderWithStore extends IReader {
+	/**
+	 * Items in this store get disposed just before the observable recomputes/reruns or when it becomes unobserved.
+	*/
+	get store(): DisposableStore;
+
+	/**
+	 * Items in this store get disposed just after the observable recomputes/reruns or when it becomes unobserved.
+	 * This is important if the current run needs the undisposed result from the last run.
+	 *
+	 * Warning: Items in this store might still get disposed before dependents (that read the now disposed value in the past) are recomputed with the new (undisposed) value!
+	 * A clean solution for this is ref counting.
+	*/
+	get delayedStore(): DisposableStore;
+}

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

@@ -0,0 +1,96 @@
+//!!! 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 { BugIndicatingError } from './commonFacade/deps';
+import { IObservableWithChange, IReader } from './base';
+
+export interface IChangeTracker<TChangeSummary> {
+	createChangeSummary(previousChangeSummary: TChangeSummary | undefined): TChangeSummary;
+	handleChange(ctx: IChangeContext, change: TChangeSummary): boolean;
+	beforeUpdate?(reader: IReader, change: TChangeSummary): void;
+}
+
+export interface IChangeContext {
+	readonly changedObservable: IObservableWithChange<any, any>;
+	readonly change: unknown;
+
+	/**
+	 * Returns if the given observable caused the change.
+	 */
+	didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is { change: TChange };
+}
+
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+export function recordChanges<TObs extends Record<any, IObservableWithChange<any, any>>>(obs: TObs):
+	IChangeTracker<{ [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']> }
+		& { changes: readonly ({ [TKey in keyof TObs]: { key: TKey; change: TObs[TKey]['TChange'] } }[keyof TObs])[] }> {
+	return {
+		createChangeSummary: (_previousChangeSummary) => {
+			return {
+				changes: [],
+			} as any;
+		},
+		handleChange(ctx, changeSummary) {
+			for (const key in obs) {
+				if (ctx.didChange(obs[key])) {
+					(changeSummary.changes as any).push({ key, change: ctx.change });
+				}
+			}
+			return true;
+		},
+		beforeUpdate(reader, changeSummary) {
+			for (const key in obs) {
+				if (key === 'changes') {
+					throw new BugIndicatingError('property name "changes" is reserved for change tracking');
+				}
+				changeSummary[key] = obs[key].read(reader);
+			}
+		}
+	};
+}
+
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+export function recordChangesLazy<TObs extends Record<any, IObservableWithChange<any, any>>>(getObs: () => TObs):
+	IChangeTracker<{ [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']> }
+		& { changes: readonly ({ [TKey in keyof TObs]: { key: TKey; change: TObs[TKey]['TChange'] } }[keyof TObs])[] }> {
+	let obs: TObs | undefined = undefined;
+	return {
+		createChangeSummary: (_previousChangeSummary) => {
+			return {
+				changes: [],
+			} as any;
+		},
+		handleChange(ctx, changeSummary) {
+			if (!obs) {
+				obs = getObs();
+			}
+			for (const key in obs) {
+				if (ctx.didChange(obs[key])) {
+					(changeSummary.changes as any).push({ key, change: ctx.change });
+				}
+			}
+			return true;
+		},
+		beforeUpdate(reader, changeSummary) {
+			if (!obs) {
+				obs = getObs();
+			}
+			for (const key in obs) {
+				if (key === 'changes') {
+					throw new BugIndicatingError('property name "changes" is reserved for change tracking');
+				}
+				changeSummary[key] = obs[key].read(reader);
+			}
+		}
+	};
+}

package/src/_internal/util/vs/base/common/observableInternal/commonFacade/cancellation.ts

@@ -0,0 +1,9 @@
+//!!! 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 { CancellationError } from '../../errors';
+export { CancellationToken, CancellationTokenSource, cancelOnDispose } from '../../cancellation';

package/src/_internal/util/vs/base/common/observableInternal/commonFacade/deps.ts

@@ -0,0 +1,12 @@
+//!!! 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 { assertFn } from '../../assert';
+export { type EqualityComparer, strictEquals } from '../../equals';
+export { BugIndicatingError, onBugIndicatingError, onUnexpectedError } from '../../errors';
+export { Event, type IValueWithChangeEvent } from '../../event';
+export { DisposableStore, type IDisposable, markAsDisposed, toDisposable, trackDisposable } from '../../lifecycle';

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

@@ -0,0 +1,88 @@
+//!!! 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 type DebugLocation = DebugLocationImpl | undefined;
+
+export namespace DebugLocation {
+	let enabled = false;
+
+	export function enable(): void {
+		enabled = true;
+	}
+
+	export function ofCaller(): DebugLocation {
+		if (!enabled) {
+			return undefined;
+		}
+		const Err = Error as any as { stackTraceLimit: number }; // For the monaco editor checks, which don't have the nodejs types.
+
+		const l = Err.stackTraceLimit;
+		Err.stackTraceLimit = 3;
+		const stack = new Error().stack!;
+		Err.stackTraceLimit = l;
+
+		return DebugLocationImpl.fromStack(stack, 2);
+	}
+}
+
+class DebugLocationImpl implements ILocation {
+	public static fromStack(stack: string, parentIdx: number): DebugLocationImpl | undefined {
+		const lines = stack.split('\n');
+		const location = parseLine(lines[parentIdx + 1]);
+		if (location) {
+			return new DebugLocationImpl(
+				location.fileName,
+				location.line,
+				location.column,
+				location.id
+			);
+		} else {
+			return undefined;
+		}
+	}
+
+	constructor(
+		public readonly fileName: string,
+		public readonly line: number,
+		public readonly column: number,
+		public readonly id: string,
+	) {
+	}
+}
+
+
+export interface ILocation {
+	fileName: string;
+	line: number;
+	column: number;
+	id: string;
+}
+
+function parseLine(stackLine: string): ILocation | undefined {
+	const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+	if (match) {
+		return {
+			fileName: match[1],
+			line: parseInt(match[2]),
+			column: parseInt(match[3]),
+			id: stackLine,
+		};
+	}
+
+	const match2 = stackLine.match(/at ([^\(\)]*):(\d+):(\d+)/);
+
+	if (match2) {
+		return {
+			fileName: match2[1],
+			line: parseInt(match2[2]),
+			column: parseInt(match2[3]),
+			id: stackLine,
+		};
+	}
+
+	return undefined;
+}