@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,242 +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 { 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

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

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

@@ -1,208 +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 { 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

@@ -1,96 +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 { 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

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

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

@@ -1,12 +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 { 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

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