@xterm/xterm 5.6.0-beta.8 → 5.6.0-beta.81

package/src/vs/base/common/collections.ts

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * An interface for a JavaScript object that
+ * acts a dictionary. The keys are strings.
+ */
+export type IStringDictionary<V> = Record<string, V>;
+
+/**
+ * An interface for a JavaScript object that
+ * acts a dictionary. The keys are numbers.
+ */
+export type INumberDictionary<V> = Record<number, V>;
+
+/**
+ * Groups the collection into a dictionary based on the provided
+ * group function.
+ */
+export function groupBy<K extends string | number | symbol, V>(data: V[], groupFn: (element: V) => K): Record<K, V[]> {
+	const result: Record<K, V[]> = Object.create(null);
+	for (const element of data) {
+		const key = groupFn(element);
+		let target = result[key];
+		if (!target) {
+			target = result[key] = [];
+		}
+		target.push(element);
+	}
+	return result;
+}
+
+export function diffSets<T>(before: Set<T>, after: Set<T>): { removed: T[]; added: T[] } {
+	const removed: T[] = [];
+	const added: T[] = [];
+	for (const element of before) {
+		if (!after.has(element)) {
+			removed.push(element);
+		}
+	}
+	for (const element of after) {
+		if (!before.has(element)) {
+			added.push(element);
+		}
+	}
+	return { removed, added };
+}
+
+export function diffMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[]; added: V[] } {
+	const removed: V[] = [];
+	const added: V[] = [];
+	for (const [index, value] of before) {
+		if (!after.has(index)) {
+			removed.push(value);
+		}
+	}
+	for (const [index, value] of after) {
+		if (!before.has(index)) {
+			added.push(value);
+		}
+	}
+	return { removed, added };
+}
+
+/**
+ * Computes the intersection of two sets.
+ *
+ * @param setA - The first set.
+ * @param setB - The second iterable.
+ * @returns A new set containing the elements that are in both `setA` and `setB`.
+ */
+export function intersection<T>(setA: Set<T>, setB: Iterable<T>): Set<T> {
+	const result = new Set<T>();
+	for (const elem of setB) {
+		if (setA.has(elem)) {
+			result.add(elem);
+		}
+	}
+	return result;
+}
+
+export class SetWithKey<T> implements Set<T> {
+	private _map = new Map<any, T>();
+
+	constructor(values: T[], private toKey: (t: T) => any) {
+		for (const value of values) {
+			this.add(value);
+		}
+	}
+
+	get size(): number {
+		return this._map.size;
+	}
+
+	add(value: T): this {
+		const key = this.toKey(value);
+		this._map.set(key, value);
+		return this;
+	}
+
+	delete(value: T): boolean {
+		return this._map.delete(this.toKey(value));
+	}
+
+	has(value: T): boolean {
+		return this._map.has(this.toKey(value));
+	}
+
+	*entries(): IterableIterator<[T, T]> {
+		for (const entry of this._map.values()) {
+			yield [entry, entry];
+		}
+	}
+
+	keys(): IterableIterator<T> {
+		return this.values();
+	}
+
+	*values(): IterableIterator<T> {
+		for (const entry of this._map.values()) {
+			yield entry;
+		}
+	}
+
+	clear(): void {
+		this._map.clear();
+	}
+
+	forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void {
+		this._map.forEach(entry => callbackfn.call(thisArg, entry, entry, this));
+	}
+
+	[Symbol.iterator](): IterableIterator<T> {
+		return this.values();
+	}
+
+	[Symbol.toStringTag]: string = 'SetWithKey';
+}

package/src/vs/base/common/decorators.ts

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+function createDecorator(mapFn: (fn: Function, key: string) => Function): Function {
+	return (target: any, key: string, descriptor: any) => {
+		let fnKey: string | null = null;
+		let fn: Function | null = null;
+
+		if (typeof descriptor.value === 'function') {
+			fnKey = 'value';
+			fn = descriptor.value;
+		} else if (typeof descriptor.get === 'function') {
+			fnKey = 'get';
+			fn = descriptor.get;
+		}
+
+		if (!fn) {
+			throw new Error('not supported');
+		}
+
+		descriptor[fnKey!] = mapFn(fn, key);
+	};
+}
+
+export function memoize(_target: any, key: string, descriptor: any) {
+	let fnKey: string | null = null;
+	let fn: Function | null = null;
+
+	if (typeof descriptor.value === 'function') {
+		fnKey = 'value';
+		fn = descriptor.value;
+
+		if (fn!.length !== 0) {
+			console.warn('Memoize should only be used in functions with zero parameters');
+		}
+	} else if (typeof descriptor.get === 'function') {
+		fnKey = 'get';
+		fn = descriptor.get;
+	}
+
+	if (!fn) {
+		throw new Error('not supported');
+	}
+
+	const memoizeKey = `$memoize$${key}`;
+	descriptor[fnKey!] = function (...args: any[]) {
+		if (!this.hasOwnProperty(memoizeKey)) {
+			Object.defineProperty(this, memoizeKey, {
+				configurable: false,
+				enumerable: false,
+				writable: false,
+				value: fn.apply(this, args)
+			});
+		}
+
+		return this[memoizeKey];
+	};
+}
+
+export interface IDebounceReducer<T> {
+	(previousValue: T, ...args: any[]): T;
+}
+
+export function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): Function {
+	return createDecorator((fn, key) => {
+		const timerKey = `$debounce$${key}`;
+		const resultKey = `$debounce$result$${key}`;
+
+		return function (this: any, ...args: any[]) {
+			if (!this[resultKey]) {
+				this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+			}
+
+			clearTimeout(this[timerKey]);
+
+			if (reducer) {
+				this[resultKey] = reducer(this[resultKey], ...args);
+				args = [this[resultKey]];
+			}
+
+			this[timerKey] = setTimeout(() => {
+				fn.apply(this, args);
+				this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+			}, delay);
+		};
+	});
+}
+
+export function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): Function {
+	return createDecorator((fn, key) => {
+		const timerKey = `$throttle$timer$${key}`;
+		const resultKey = `$throttle$result$${key}`;
+		const lastRunKey = `$throttle$lastRun$${key}`;
+		const pendingKey = `$throttle$pending$${key}`;
+
+		return function (this: any, ...args: any[]) {
+			if (!this[resultKey]) {
+				this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+			}
+			if (this[lastRunKey] === null || this[lastRunKey] === undefined) {
+				this[lastRunKey] = -Number.MAX_VALUE;
+			}
+
+			if (reducer) {
+				this[resultKey] = reducer(this[resultKey], ...args);
+			}
+
+			if (this[pendingKey]) {
+				return;
+			}
+
+			const nextTime = this[lastRunKey] + delay;
+			if (nextTime <= Date.now()) {
+				this[lastRunKey] = Date.now();
+				fn.apply(this, [this[resultKey]]);
+				this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+			} else {
+				this[pendingKey] = true;
+				this[timerKey] = setTimeout(() => {
+					this[pendingKey] = false;
+					this[lastRunKey] = Date.now();
+					fn.apply(this, [this[resultKey]]);
+					this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+				}, nextTime - Date.now());
+			}
+		};
+	});
+}

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

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 'vs/base/common/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/vs/base/common/errors.ts

@@ -0,0 +1,303 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+}
+
+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;
+}
+
+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 } = error;
+		const stack: string = (<any>error).stacktrace || (<any>error).stack;
+		return {
+			$isError: true,
+			name,
+			message,
+			stack,
+			noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error)
+		};
+	}
+
+	// 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;
+	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;
+}
+
+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;
+	}
+}
+
+/**
+ * @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.
+		// eslint-disable-next-line no-debugger
+		// debugger;
+	}
+}