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

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

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Comparator } from './arrays';
+
+export function findLast<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {
+	const idx = findLastIdx(array, predicate);
+	if (idx === -1) {
+		return undefined;
+	}
+	return array[idx];
+}
+
+export function findLastIdx<T>(array: readonly T[], predicate: (item: T) => boolean, fromIndex = array.length - 1): number {
+	for (let i = fromIndex; i >= 0; i--) {
+		const element = array[i];
+
+		if (predicate(element)) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+/**
+ * Finds the last item where predicate is true using binary search.
+ * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
+ *
+ * @returns `undefined` if no item matches, otherwise the last item that matches the predicate.
+ */
+export function findLastMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {
+	const idx = findLastIdxMonotonous(array, predicate);
+	return idx === -1 ? undefined : array[idx];
+}
+
+/**
+ * Finds the last item where predicate is true using binary search.
+ * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
+ *
+ * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate.
+ */
+export function findLastIdxMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {
+	let i = startIdx;
+	let j = endIdxEx;
+	while (i < j) {
+		const k = Math.floor((i + j) / 2);
+		if (predicate(array[k])) {
+			i = k + 1;
+		} else {
+			j = k;
+		}
+	}
+	return i - 1;
+}
+
+/**
+ * Finds the first item where predicate is true using binary search.
+ * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!
+ *
+ * @returns `undefined` if no item matches, otherwise the first item that matches the predicate.
+ */
+export function findFirstMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {
+	const idx = findFirstIdxMonotonousOrArrLen(array, predicate);
+	return idx === array.length ? undefined : array[idx];
+}
+
+/**
+ * Finds the first item where predicate is true using binary search.
+ * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!
+ *
+ * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate.
+ */
+export function findFirstIdxMonotonousOrArrLen<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {
+	let i = startIdx;
+	let j = endIdxEx;
+	while (i < j) {
+		const k = Math.floor((i + j) / 2);
+		if (predicate(array[k])) {
+			j = k;
+		} else {
+			i = k + 1;
+		}
+	}
+	return i;
+}
+
+export function findFirstIdxMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {
+	const idx = findFirstIdxMonotonousOrArrLen(array, predicate, startIdx, endIdxEx);
+	return idx === array.length ? -1 : idx;
+}
+
+/**
+ * Use this when
+ * * You have a sorted array
+ * * You query this array with a monotonous predicate to find the last item that has a certain property.
+ * * You query this array multiple times with monotonous predicates that get weaker and weaker.
+ */
+export class MonotonousArray<T> {
+	public static assertInvariants = false;
+
+	private _findLastMonotonousLastIdx = 0;
+	private _prevFindLastPredicate: ((item: T) => boolean) | undefined;
+
+	constructor(private readonly _array: readonly T[]) {
+	}
+
+	/**
+	 * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
+	 * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`.
+	 */
+	findLastMonotonous(predicate: (item: T) => boolean): T | undefined {
+		if (MonotonousArray.assertInvariants) {
+			if (this._prevFindLastPredicate) {
+				for (const item of this._array) {
+					if (this._prevFindLastPredicate(item) && !predicate(item)) {
+						throw new Error('MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.');
+					}
+				}
+			}
+			this._prevFindLastPredicate = predicate;
+		}
+
+		const idx = findLastIdxMonotonous(this._array, predicate, this._findLastMonotonousLastIdx);
+		this._findLastMonotonousLastIdx = idx + 1;
+		return idx === -1 ? undefined : this._array[idx];
+	}
+}
+
+/**
+ * Returns the first item that is equal to or greater than every other item.
+*/
+export function findFirstMax<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {
+	if (array.length === 0) {
+		return undefined;
+	}
+
+	let max = array[0];
+	for (let i = 1; i < array.length; i++) {
+		const item = array[i];
+		if (comparator(item, max) > 0) {
+			max = item;
+		}
+	}
+	return max;
+}
+
+/**
+ * Returns the last item that is equal to or greater than every other item.
+*/
+export function findLastMax<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {
+	if (array.length === 0) {
+		return undefined;
+	}
+
+	let max = array[0];
+	for (let i = 1; i < array.length; i++) {
+		const item = array[i];
+		if (comparator(item, max) >= 0) {
+			max = item;
+		}
+	}
+	return max;
+}
+
+/**
+ * Returns the first item that is equal to or less than every other item.
+*/
+export function findFirstMin<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {
+	return findFirstMax(array, (a, b) => -comparator(a, b));
+}
+
+export function findMaxIdx<T>(array: readonly T[], comparator: Comparator<T>): number {
+	if (array.length === 0) {
+		return -1;
+	}
+
+	let maxIdx = 0;
+	for (let i = 1; i < array.length; i++) {
+		const item = array[i];
+		if (comparator(item, array[maxIdx]) > 0) {
+			maxIdx = i;
+		}
+	}
+	return maxIdx;
+}
+
+/**
+ * Returns the first mapped value of the array which is not undefined.
+ */
+export function mapFindFirst<T, R>(items: Iterable<T>, mapFn: (value: T) => R | undefined): R | undefined {
+	for (const value of items) {
+		const mapped = mapFn(value);
+		if (mapped !== undefined) {
+			return mapped;
+		}
+	}
+
+	return undefined;
+}

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

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { BugIndicatingError, onUnexpectedError } from 'vs/base/common/errors';
+
+/**
+ * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value.
+ *
+ * @deprecated Use `assert(...)` instead.
+ * This method is usually used like this:
+ * ```ts
+ * import * as assert from 'vs/base/common/assert';
+ * assert.ok(...);
+ * ```
+ *
+ * However, `assert` in that example is a user chosen name.
+ * There is no tooling for generating such an import statement.
+ * Thus, the `assert(...)` function should be used instead.
+ */
+export function ok(value?: unknown, message?: string) {
+	if (!value) {
+		throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed');
+	}
+}
+
+export function assertNever(value: never, message = 'Unreachable'): never {
+	throw new Error(message);
+}
+
+export function assert(condition: boolean, message = 'unexpected state'): asserts condition {
+	if (!condition) {
+		throw new BugIndicatingError(`Assertion Failed: ${message}`);
+	}
+}
+
+/**
+ * Like assert, but doesn't throw.
+ */
+export function softAssert(condition: boolean): void {
+	if (!condition) {
+		onUnexpectedError(new BugIndicatingError('Soft Assertion Failed'));
+	}
+}
+
+/**
+ * condition must be side-effect free!
+ */
+export function assertFn(condition: () => boolean): void {
+	if (!condition()) {
+		// eslint-disable-next-line no-debugger
+		debugger;
+		// Reevaluate `condition` again to make debugging easier
+		condition();
+		onUnexpectedError(new BugIndicatingError('Assertion Failed'));
+	}
+}
+
+export function checkAdjacentItems<T>(items: readonly T[], predicate: (item1: T, item2: T) => boolean): boolean {
+	let i = 0;
+	while (i < items.length - 1) {
+		const a = items[i];
+		const b = items[i + 1];
+		if (!predicate(a, b)) {
+			return false;
+		}
+		i++;
+	}
+	return true;
+}