@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/base/common/diff/diffChange.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.
- *--------------------------------------------------------------------------------------------*/
-
-/**
- * Represents information about a specific difference between two sequences.
- */
-export class DiffChange {
-
-	/**
-	 * The position of the first element in the original sequence which
-	 * this change affects.
-	 */
-	public originalStart: number;
-
-	/**
-	 * The number of elements from the original sequence which were
-	 * affected.
-	 */
-	public originalLength: number;
-
-	/**
-	 * The position of the first element in the modified sequence which
-	 * this change affects.
-	 */
-	public modifiedStart: number;
-
-	/**
-	 * The number of elements from the modified sequence which were
-	 * affected (added).
-	 */
-	public modifiedLength: number;
-
-	/**
-	 * Constructs a new DiffChange with the given sequence information
-	 * and content.
-	 */
-	constructor(originalStart: number, originalLength: number, modifiedStart: number, modifiedLength: number) {
-		//Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");
-		this.originalStart = originalStart;
-		this.originalLength = originalLength;
-		this.modifiedStart = modifiedStart;
-		this.modifiedLength = modifiedLength;
-	}
-
-	/**
-	 * The end point (exclusive) of the change in the original sequence.
-	 */
-	public getOriginalEnd() {
-		return this.originalStart + this.originalLength;
-	}
-
-	/**
-	 * The end point (exclusive) of the change in the modified sequence.
-	 */
-	public getModifiedEnd() {
-		return this.modifiedStart + this.modifiedLength;
-	}
-}

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

@@ -1,148 +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 * as arrays from './arrays';
-
-export type EqualityComparer<T> = (a: T, b: T) => boolean;
-
-/**
- * Compares two items for equality using strict equality.
-*/
-export const strictEquals: EqualityComparer<any> = (a, b) => a === b;
-
-/**
- * Checks if the items of two arrays are equal.
- * By default, strict equality is used to compare elements, but a custom equality comparer can be provided.
- */
-export function itemsEquals<T>(itemEquals: EqualityComparer<T> = strictEquals): EqualityComparer<readonly T[]> {
-	return (a, b) => arrays.equals(a, b, itemEquals);
-}
-
-/**
- * Two items are considered equal, if their stringified representations are equal.
-*/
-export function jsonStringifyEquals<T>(): EqualityComparer<T> {
-	return (a, b) => JSON.stringify(a) === JSON.stringify(b);
-}
-
-/**
- * Uses `item.equals(other)` to determine equality.
- */
-export function itemEquals<T extends { equals(other: T): boolean }>(): EqualityComparer<T> {
-	return (a, b) => a.equals(b);
-}
-
-/**
- * Checks if two items are both null or undefined, or are equal according to the provided equality comparer.
-*/
-export function equalsIfDefined<T>(v1: T | undefined | null, v2: T | undefined | null, equals: EqualityComparer<T>): boolean;
-/**
- * Returns an equality comparer that checks if two items are both null or undefined, or are equal according to the provided equality comparer.
-*/
-export function equalsIfDefined<T>(equals: EqualityComparer<T>): EqualityComparer<T | undefined | null>;
-export function equalsIfDefined<T>(equalsOrV1: EqualityComparer<T> | T, v2?: T | undefined | null, equals?: EqualityComparer<T>): EqualityComparer<T | undefined | null> | boolean {
-	if (equals !== undefined) {
-		const v1 = equalsOrV1 as T | undefined;
-		if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
-			return v2 === v1;
-		}
-		return equals(v1, v2);
-	} else {
-		const equals = equalsOrV1 as EqualityComparer<T>;
-		return (v1, v2) => {
-			if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
-				return v2 === v1;
-			}
-			return equals(v1, v2);
-		};
-	}
-}
-
-/**
- * Drills into arrays (items ordered) and objects (keys unordered) and uses strict equality on everything else.
-*/
-export function structuralEquals<T>(a: T, b: T): boolean {
-	if (a === b) {
-		return true;
-	}
-
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) {
-			return false;
-		}
-		for (let i = 0; i < a.length; i++) {
-			if (!structuralEquals(a[i], b[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	if (a && typeof a === 'object' && b && typeof b === 'object') {
-		if (Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
-			const aObj = a as Record<string, unknown>;
-			const bObj = b as Record<string, unknown>;
-			const keysA = Object.keys(aObj);
-			const keysB = Object.keys(bObj);
-			const keysBSet = new Set(keysB);
-
-			if (keysA.length !== keysB.length) {
-				return false;
-			}
-
-			for (const key of keysA) {
-				if (!keysBSet.has(key)) {
-					return false;
-				}
-				if (!structuralEquals(aObj[key], bObj[key])) {
-					return false;
-				}
-			}
-
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * `getStructuralKey(a) === getStructuralKey(b) <=> structuralEquals(a, b)`
- * (assuming that a and b are not cyclic structures and nothing extends globalThis Array).
-*/
-export function getStructuralKey(t: unknown): string {
-	return JSON.stringify(toNormalizedJsonStructure(t));
-}
-
-let objectId = 0;
-const objIds = new WeakMap<object, number>();
-
-function toNormalizedJsonStructure(t: unknown): unknown {
-	if (Array.isArray(t)) {
-		return t.map(toNormalizedJsonStructure);
-	}
-
-	if (t && typeof t === 'object') {
-		if (Object.getPrototypeOf(t) === Object.prototype) {
-			const tObj = t as Record<string, unknown>;
-			const res: Record<string, unknown> = Object.create(null);
-			for (const key of Object.keys(tObj).sort()) {
-				res[key] = toNormalizedJsonStructure(tObj[key]);
-			}
-			return res;
-		} else {
-			let objId = objIds.get(t);
-			if (objId === undefined) {
-				objId = objectId++;
-				objIds.set(t, objId);
-			}
-			// Random string to prevent collisions
-			return objId + '----2b76a038c20c4bcc';
-		}
-	}
-	return t;
-}

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

@@ -1,342 +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 ErrorListenerCallback {
-	(error: any): void;
-}
-
-export interface ErrorListenerUnbind {
-	(): void;
-}
-
-// Avoid circular dependency on EventEmitter by implementing a subset of the interface.
-export class ErrorHandler {
-	private unexpectedErrorHandler: (e: any) => void;
-	private listeners: ErrorListenerCallback[];
-
-	constructor() {
-
-		this.listeners = [];
-
-		this.unexpectedErrorHandler = function (e: any) {
-			setTimeout(() => {
-				if (e.stack) {
-					if (ErrorNoTelemetry.isErrorNoTelemetry(e)) {
-						throw new ErrorNoTelemetry(e.message + '\n\n' + e.stack);
-					}
-
-					throw new Error(e.message + '\n\n' + e.stack);
-				}
-
-				throw e;
-			}, 0);
-		};
-	}
-
-	addListener(listener: ErrorListenerCallback): ErrorListenerUnbind {
-		this.listeners.push(listener);
-
-		return () => {
-			this._removeListener(listener);
-		};
-	}
-
-	private emit(e: any): void {
-		this.listeners.forEach((listener) => {
-			listener(e);
-		});
-	}
-
-	private _removeListener(listener: ErrorListenerCallback): void {
-		this.listeners.splice(this.listeners.indexOf(listener), 1);
-	}
-
-	setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {
-		this.unexpectedErrorHandler = newUnexpectedErrorHandler;
-	}
-
-	getUnexpectedErrorHandler(): (e: any) => void {
-		return this.unexpectedErrorHandler;
-	}
-
-	onUnexpectedError(e: any): void {
-		this.unexpectedErrorHandler(e);
-		this.emit(e);
-	}
-
-	// For external errors, we don't want the listeners to be called
-	onUnexpectedExternalError(e: any): void {
-		this.unexpectedErrorHandler(e);
-	}
-}
-
-export const errorHandler = new ErrorHandler();
-
-/** @skipMangle */
-export function setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {
-	errorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler);
-}
-
-/**
- * Returns if the error is a SIGPIPE error. SIGPIPE errors should generally be
- * logged at most once, to avoid a loop.
- *
- * @see https://github.com/microsoft/vscode-remote-release/issues/6481
- */
-export function isSigPipeError(e: unknown): e is Error {
-	if (!e || typeof e !== 'object') {
-		return false;
-	}
-
-	const cast = e as Record<string, string | undefined>;
-	return cast.code === 'EPIPE' && cast.syscall?.toUpperCase() === 'WRITE';
-}
-
-/**
- * This function should only be called with errors that indicate a bug in the product.
- * E.g. buggy extensions/invalid user-input/network issues should not be able to trigger this code path.
- * If they are, this indicates there is also a bug in the product.
-*/
-export function onBugIndicatingError(e: any): undefined {
-	errorHandler.onUnexpectedError(e);
-	return undefined;
-}
-
-export function onUnexpectedError(e: any): undefined {
-	// ignore errors from cancelled promises
-	if (!isCancellationError(e)) {
-		errorHandler.onUnexpectedError(e);
-	}
-	return undefined;
-}
-
-export function onUnexpectedExternalError(e: any): undefined {
-	// ignore errors from cancelled promises
-	if (!isCancellationError(e)) {
-		errorHandler.onUnexpectedExternalError(e);
-	}
-	return undefined;
-}
-
-export interface SerializedError {
-	readonly $isError: true;
-	readonly name: string;
-	readonly message: string;
-	readonly stack: string;
-	readonly noTelemetry: boolean;
-	readonly code?: string;
-	readonly cause?: SerializedError;
-}
-
-type ErrorWithCode = Error & {
-	code: string | undefined;
-};
-
-export function transformErrorForSerialization(error: Error): SerializedError;
-export function transformErrorForSerialization(error: any): any;
-export function transformErrorForSerialization(error: any): any {
-	if (error instanceof Error) {
-		const { name, message, cause } = error;
-		const stack: string = (<any>error).stacktrace || (<any>error).stack;
-		return {
-			$isError: true,
-			name,
-			message,
-			stack,
-			noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error),
-			cause: cause ? transformErrorForSerialization(cause) : undefined,
-			code: (<ErrorWithCode>error).code
-		};
-	}
-
-	// return as is
-	return error;
-}
-
-export function transformErrorFromSerialization(data: SerializedError): Error {
-	let error: Error;
-	if (data.noTelemetry) {
-		error = new ErrorNoTelemetry();
-	} else {
-		error = new Error();
-		error.name = data.name;
-	}
-	error.message = data.message;
-	error.stack = data.stack;
-	if (data.code) {
-		(<ErrorWithCode>error).code = data.code;
-	}
-	if (data.cause) {
-		error.cause = transformErrorFromSerialization(data.cause);
-	}
-	return error;
-}
-
-// see https://github.com/v8/v8/wiki/Stack%20Trace%20API#basic-stack-traces
-export interface V8CallSite {
-	getThis(): unknown;
-	getTypeName(): string | null;
-	getFunction(): Function | undefined;
-	getFunctionName(): string | null;
-	getMethodName(): string | null;
-	getFileName(): string | null;
-	getLineNumber(): number | null;
-	getColumnNumber(): number | null;
-	getEvalOrigin(): string | undefined;
-	isToplevel(): boolean;
-	isEval(): boolean;
-	isNative(): boolean;
-	isConstructor(): boolean;
-	toString(): string;
-}
-
-export const canceledName = 'Canceled';
-
-/**
- * Checks if the given error is a promise in canceled state
- */
-export function isCancellationError(error: any): boolean {
-	if (error instanceof CancellationError) {
-		return true;
-	}
-	return error instanceof Error && error.name === canceledName && error.message === canceledName;
-}
-
-// !!!IMPORTANT!!!
-// Do NOT change this class because it is also used as an API-type.
-export class CancellationError extends Error {
-	constructor() {
-		super(canceledName);
-		this.name = this.message;
-	}
-}
-
-export class PendingMigrationError extends Error {
-
-	private static readonly _name = 'PendingMigrationError';
-
-	static is(error: unknown): error is PendingMigrationError {
-		return error instanceof PendingMigrationError || (error instanceof Error && error.name === PendingMigrationError._name);
-	}
-
-	constructor(message: string) {
-		super(message);
-		this.name = PendingMigrationError._name;
-	}
-}
-
-/**
- * @deprecated use {@link CancellationError `new CancellationError()`} instead
- */
-export function canceled(): Error {
-	const error = new Error(canceledName);
-	error.name = error.message;
-	return error;
-}
-
-export function illegalArgument(name?: string): Error {
-	if (name) {
-		return new Error(`Illegal argument: ${name}`);
-	} else {
-		return new Error('Illegal argument');
-	}
-}
-
-export function illegalState(name?: string): Error {
-	if (name) {
-		return new Error(`Illegal state: ${name}`);
-	} else {
-		return new Error('Illegal state');
-	}
-}
-
-export class ReadonlyError extends TypeError {
-	constructor(name?: string) {
-		super(name ? `${name} is read-only and cannot be changed` : 'Cannot change read-only property');
-	}
-}
-
-export function getErrorMessage(err: any): string {
-	if (!err) {
-		return 'Error';
-	}
-
-	if (err.message) {
-		return err.message;
-	}
-
-	if (err.stack) {
-		return err.stack.split('\n')[0];
-	}
-
-	return String(err);
-}
-
-export class NotImplementedError extends Error {
-	constructor(message?: string) {
-		super('NotImplemented');
-		if (message) {
-			this.message = message;
-		}
-	}
-}
-
-export class NotSupportedError extends Error {
-	constructor(message?: string) {
-		super('NotSupported');
-		if (message) {
-			this.message = message;
-		}
-	}
-}
-
-export class ExpectedError extends Error {
-	readonly isExpected = true;
-}
-
-/**
- * Error that when thrown won't be logged in telemetry as an unhandled error.
- */
-export class ErrorNoTelemetry extends Error {
-	override readonly name: string;
-
-	constructor(msg?: string) {
-		super(msg);
-		this.name = 'CodeExpectedError';
-	}
-
-	public static fromError(err: Error): ErrorNoTelemetry {
-		if (err instanceof ErrorNoTelemetry) {
-			return err;
-		}
-
-		const result = new ErrorNoTelemetry();
-		result.message = err.message;
-		result.stack = err.stack;
-		return result;
-	}
-
-	public static isErrorNoTelemetry(err: Error): err is ErrorNoTelemetry {
-		return err.name === 'CodeExpectedError';
-	}
-}
-
-/**
- * This error indicates a bug.
- * Do not throw this for invalid user input.
- * Only catch this error to recover gracefully from bugs.
- */
-export class BugIndicatingError extends Error {
-	constructor(message?: string) {
-		super(message || 'An unexpected bug occurred.');
-		Object.setPrototypeOf(this, BugIndicatingError.prototype);
-
-		// Because we know for sure only buggy code throws this,
-		// we definitely want to break here and fix the bug.
-		// debugger;
-	}
-}