@xterm/xterm 6.1.0-beta.19 → 6.1.0-beta.190

package/src/vs/base/common/observableInternal/logging.ts

@@ -1,328 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { AutorunObserver } from 'vs/base/common/observableInternal/autorun';
-import { IObservable, ObservableValue, TransactionImpl } from 'vs/base/common/observableInternal/base';
-import { Derived } from 'vs/base/common/observableInternal/derived';
-import { FromEventObservable } from 'vs/base/common/observableInternal/utils';
-
-let globalObservableLogger: IObservableLogger | undefined;
-
-export function setLogger(logger: IObservableLogger): void {
-	globalObservableLogger = logger;
-}
-
-export function getLogger(): IObservableLogger | undefined {
-	return globalObservableLogger;
-}
-
-interface IChangeInformation {
-	oldValue: unknown;
-	newValue: unknown;
-	change: unknown;
-	didChange: boolean;
-	hadValue: boolean;
-}
-
-export interface IObservableLogger {
-	handleObservableChanged(observable: ObservableValue<any, any>, info: IChangeInformation): void;
-	handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void;
-
-	handleAutorunCreated(autorun: AutorunObserver): void;
-	handleAutorunTriggered(autorun: AutorunObserver): void;
-	handleAutorunFinished(autorun: AutorunObserver): void;
-
-	handleDerivedCreated(observable: Derived<any>): void;
-	handleDerivedRecomputed(observable: Derived<any>, info: IChangeInformation): void;
-
-	handleBeginTransaction(transaction: TransactionImpl): void;
-	handleEndTransaction(): void;
-}
-
-export class ConsoleObservableLogger implements IObservableLogger {
-	private indentation = 0;
-
-	private textToConsoleArgs(text: ConsoleText): unknown[] {
-		return consoleTextToArgs([
-			normalText(repeat('|  ', this.indentation)),
-			text,
-		]);
-	}
-
-	private formatInfo(info: IChangeInformation): ConsoleText[] {
-		if (!info.hadValue) {
-			return [
-				normalText(` `),
-				styled(formatValue(info.newValue, 60), {
-					color: 'green',
-				}),
-				normalText(` (initial)`),
-			];
-		}
-		return info.didChange
-			? [
-				normalText(` `),
-				styled(formatValue(info.oldValue, 70), {
-					color: 'red',
-					strikeThrough: true,
-				}),
-				normalText(` `),
-				styled(formatValue(info.newValue, 60), {
-					color: 'green',
-				}),
-			]
-			: [normalText(` (unchanged)`)];
-	}
-
-	handleObservableChanged(observable: IObservable<unknown, unknown>, info: IChangeInformation): void {
-		console.log(...this.textToConsoleArgs([
-			formatKind('observable value changed'),
-			styled(observable.debugName, { color: 'BlueViolet' }),
-			...this.formatInfo(info),
-		]));
-	}
-
-	private readonly changedObservablesSets = new WeakMap<object, Set<IObservable<any, any>>>();
-
-	formatChanges(changes: Set<IObservable<any, any>>): ConsoleText | undefined {
-		if (changes.size === 0) {
-			return undefined;
-		}
-		return styled(
-			' (changed deps: ' +
-			[...changes].map((o) => o.debugName).join(', ') +
-			')',
-			{ color: 'gray' }
-		);
-	}
-
-	handleDerivedCreated(derived: Derived<unknown>): void {
-		const existingHandleChange = derived.handleChange;
-		this.changedObservablesSets.set(derived, new Set());
-		derived.handleChange = (observable, change) => {
-			this.changedObservablesSets.get(derived)!.add(observable);
-			return existingHandleChange.apply(derived, [observable, change]);
-		};
-	}
-
-	handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void {
-		const changedObservables = this.changedObservablesSets.get(derived)!;
-		console.log(...this.textToConsoleArgs([
-			formatKind('derived recomputed'),
-			styled(derived.debugName, { color: 'BlueViolet' }),
-			...this.formatInfo(info),
-			this.formatChanges(changedObservables),
-			{ data: [{ fn: derived._debugNameData.referenceFn ?? derived._computeFn }] }
-		]));
-		changedObservables.clear();
-	}
-
-	handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void {
-		console.log(...this.textToConsoleArgs([
-			formatKind('observable from event triggered'),
-			styled(observable.debugName, { color: 'BlueViolet' }),
-			...this.formatInfo(info),
-			{ data: [{ fn: observable._getValue }] }
-		]));
-	}
-
-	handleAutorunCreated(autorun: AutorunObserver): void {
-		const existingHandleChange = autorun.handleChange;
-		this.changedObservablesSets.set(autorun, new Set());
-		autorun.handleChange = (observable, change) => {
-			this.changedObservablesSets.get(autorun)!.add(observable);
-			return existingHandleChange.apply(autorun, [observable, change]);
-		};
-	}
-
-	handleAutorunTriggered(autorun: AutorunObserver): void {
-		const changedObservables = this.changedObservablesSets.get(autorun)!;
-		console.log(...this.textToConsoleArgs([
-			formatKind('autorun'),
-			styled(autorun.debugName, { color: 'BlueViolet' }),
-			this.formatChanges(changedObservables),
-			{ data: [{ fn: autorun._debugNameData.referenceFn ?? autorun._runFn }] }
-		]));
-		changedObservables.clear();
-		this.indentation++;
-	}
-
-	handleAutorunFinished(autorun: AutorunObserver): void {
-		this.indentation--;
-	}
-
-	handleBeginTransaction(transaction: TransactionImpl): void {
-		let transactionName = transaction.getDebugName();
-		if (transactionName === undefined) {
-			transactionName = '';
-		}
-		console.log(...this.textToConsoleArgs([
-			formatKind('transaction'),
-			styled(transactionName, { color: 'BlueViolet' }),
-			{ data: [{ fn: transaction._fn }] }
-		]));
-		this.indentation++;
-	}
-
-	handleEndTransaction(): void {
-		this.indentation--;
-	}
-}
-
-type ConsoleText =
-	| (ConsoleText | undefined)[]
-	| { text: string; style: string; data?: unknown[] }
-	| { data: unknown[] };
-
-function consoleTextToArgs(text: ConsoleText): unknown[] {
-	const styles = new Array<any>();
-	const data: unknown[] = [];
-	let firstArg = '';
-
-	function process(t: ConsoleText): void {
-		if ('length' in t) {
-			for (const item of t) {
-				if (item) {
-					process(item);
-				}
-			}
-		} else if ('text' in t) {
-			firstArg += `%c${t.text}`;
-			styles.push(t.style);
-			if (t.data) {
-				data.push(...t.data);
-			}
-		} else if ('data' in t) {
-			data.push(...t.data);
-		}
-	}
-
-	process(text);
-
-	const result = [firstArg, ...styles];
-	result.push(...data);
-	return result;
-}
-
-function normalText(text: string): ConsoleText {
-	return styled(text, { color: 'black' });
-}
-
-function formatKind(kind: string): ConsoleText {
-	return styled(padStr(`${kind}: `, 10), { color: 'black', bold: true });
-}
-
-function styled(
-	text: string,
-	options: { color: string; strikeThrough?: boolean; bold?: boolean } = {
-		color: 'black',
-	}
-): ConsoleText {
-	function objToCss(styleObj: Record<string, string>): string {
-		return Object.entries(styleObj).reduce(
-			(styleString, [propName, propValue]) => {
-				return `${styleString}${propName}:${propValue};`;
-			},
-			''
-		);
-	}
-
-	const style: Record<string, string> = {
-		color: options.color,
-	};
-	if (options.strikeThrough) {
-		style['text-decoration'] = 'line-through';
-	}
-	if (options.bold) {
-		style['font-weight'] = 'bold';
-	}
-
-	return {
-		text,
-		style: objToCss(style),
-	};
-}
-
-function formatValue(value: unknown, availableLen: number): string {
-	switch (typeof value) {
-		case 'number':
-			return '' + value;
-		case 'string':
-			if (value.length + 2 <= availableLen) {
-				return `"${value}"`;
-			}
-			return `"${value.substr(0, availableLen - 7)}"+...`;
-
-		case 'boolean':
-			return value ? 'true' : 'false';
-		case 'undefined':
-			return 'undefined';
-		case 'object':
-			if (value === null) {
-				return 'null';
-			}
-			if (Array.isArray(value)) {
-				return formatArray(value, availableLen);
-			}
-			return formatObject(value, availableLen);
-		case 'symbol':
-			return value.toString();
-		case 'function':
-			return `[[Function${value.name ? ' ' + value.name : ''}]]`;
-		default:
-			return '' + value;
-	}
-}
-
-function formatArray(value: unknown[], availableLen: number): string {
-	let result = '[ ';
-	let first = true;
-	for (const val of value) {
-		if (!first) {
-			result += ', ';
-		}
-		if (result.length - 5 > availableLen) {
-			result += '...';
-			break;
-		}
-		first = false;
-		result += `${formatValue(val, availableLen - result.length)}`;
-	}
-	result += ' ]';
-	return result;
-}
-
-function formatObject(value: object, availableLen: number): string {
-	let result = '{ ';
-	let first = true;
-	for (const [key, val] of Object.entries(value)) {
-		if (!first) {
-			result += ', ';
-		}
-		if (result.length - 5 > availableLen) {
-			result += '...';
-			break;
-		}
-		first = false;
-		result += `${key}: ${formatValue(val, availableLen - result.length)}`;
-	}
-	result += ' }';
-	return result;
-}
-
-function repeat(str: string, count: number): string {
-	let result = '';
-	for (let i = 1; i <= count; i++) {
-		result += str;
-	}
-	return result;
-}
-
-function padStr(str: string, length: number): string {
-	while (str.length < length) {
-		str += ' ';
-	}
-	return str;
-}

package/src/vs/base/common/observableInternal/promise.ts

@@ -1,209 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { autorun } from 'vs/base/common/observableInternal/autorun';
-import { IObservable, IReader, observableValue, transaction } from './base';
-import { Derived, derived } from 'vs/base/common/observableInternal/derived';
-import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
-import { DebugNameData, DebugOwner } from 'vs/base/common/observableInternal/debugName';
-import { strictEquals } from 'vs/base/common/equals';
-import { CancellationError } from 'vs/base/common/errors';
-
-export class ObservableLazy<T> {
-	private readonly _value = observableValue<T | undefined>(this, undefined);
-
-	/**
-	 * The cached value.
-	 * Does not force a computation of the value.
-	 */
-	public get cachedValue(): IObservable<T | undefined> { return this._value; }
-
-	constructor(private readonly _computeValue: () => T) {
-	}
-
-	/**
-	 * Returns the cached value.
-	 * Computes the value if the value has not been cached yet.
-	 */
-	public getValue() {
-		let v = this._value.get();
-		if (!v) {
-			v = this._computeValue();
-			this._value.set(v, undefined);
-		}
-		return v;
-	}
-}
-
-/**
- * A promise whose state is observable.
- */
-export class ObservablePromise<T> {
-	public static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T> {
-		return new ObservablePromise(fn());
-	}
-
-	private readonly _value = observableValue<PromiseResult<T> | undefined>(this, undefined);
-
-	/**
-	 * The promise that this object wraps.
-	 */
-	public readonly promise: Promise<T>;
-
-	/**
-	 * The current state of the promise.
-	 * Is `undefined` if the promise didn't resolve yet.
-	 */
-	public readonly promiseResult: IObservable<PromiseResult<T> | undefined> = this._value;
-
-	constructor(promise: Promise<T>) {
-		this.promise = promise.then(value => {
-			transaction(tx => {
-				/** @description onPromiseResolved */
-				this._value.set(new PromiseResult(value, undefined), tx);
-			});
-			return value;
-		}, error => {
-			transaction(tx => {
-				/** @description onPromiseRejected */
-				this._value.set(new PromiseResult<T>(undefined, error), tx);
-			});
-			throw error;
-		});
-	}
-}
-
-export class PromiseResult<T> {
-	constructor(
-		/**
-		 * The value of the resolved promise.
-		 * Undefined if the promise rejected.
-		 */
-		public readonly data: T | undefined,
-
-		/**
-		 * The error in case of a rejected promise.
-		 * Undefined if the promise resolved.
-		 */
-		public readonly error: unknown | undefined,
-	) {
-	}
-
-	/**
-	 * Returns the value if the promise resolved, otherwise throws the error.
-	 */
-	public getDataOrThrow(): T {
-		if (this.error) {
-			throw this.error;
-		}
-		return this.data!;
-	}
-}
-
-/**
- * A lazy promise whose state is observable.
- */
-export class ObservableLazyPromise<T> {
-	private readonly _lazyValue = new ObservableLazy(() => new ObservablePromise(this._computePromise()));
-
-	/**
-	 * Does not enforce evaluation of the promise compute function.
-	 * Is undefined if the promise has not been computed yet.
-	 */
-	public readonly cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
-
-	constructor(private readonly _computePromise: () => Promise<T>) {
-	}
-
-	public getPromise(): Promise<T> {
-		return this._lazyValue.getValue().promise;
-	}
-}
-
-/**
- * Resolves the promise when the observables state matches the predicate.
- */
-export function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;
-export function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;
-export function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;
-export function waitForState<T>(observable: IObservable<T>, predicate?: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T> {
-	if (!predicate) {
-		predicate = state => state !== null && state !== undefined;
-	}
-	return new Promise((resolve, reject) => {
-		let isImmediateRun = true;
-		let shouldDispose = false;
-		const stateObs = observable.map(state => {
-			/** @description waitForState.state */
-			return {
-				isFinished: predicate(state),
-				error: isError ? isError(state) : false,
-				state
-			};
-		});
-		const d = autorun(reader => {
-			/** @description waitForState */
-			const { isFinished, error, state } = stateObs.read(reader);
-			if (isFinished || error) {
-				if (isImmediateRun) {
-					// The variable `d` is not initialized yet
-					shouldDispose = true;
-				} else {
-					d.dispose();
-				}
-				if (error) {
-					reject(error === true ? state : error);
-				} else {
-					resolve(state);
-				}
-			}
-		});
-		if (cancellationToken) {
-			const dc = cancellationToken.onCancellationRequested(() => {
-				d.dispose();
-				dc.dispose();
-				reject(new CancellationError());
-			});
-			if (cancellationToken.isCancellationRequested) {
-				d.dispose();
-				dc.dispose();
-				reject(new CancellationError());
-				return;
-			}
-		}
-		isImmediateRun = false;
-		if (shouldDispose) {
-			d.dispose();
-		}
-	});
-}
-
-export function derivedWithCancellationToken<T>(computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
-export function derivedWithCancellationToken<T>(owner: object, computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
-export function derivedWithCancellationToken<T>(computeFnOrOwner: ((reader: IReader, cancellationToken: CancellationToken) => T) | object, computeFnOrUndefined?: ((reader: IReader, cancellationToken: CancellationToken) => T)): IObservable<T> {
-	let computeFn: (reader: IReader, store: CancellationToken) => T;
-	let owner: DebugOwner;
-	if (computeFnOrUndefined === undefined) {
-		computeFn = computeFnOrOwner as any;
-		owner = undefined;
-	} else {
-		owner = computeFnOrOwner;
-		computeFn = computeFnOrUndefined as any;
-	}
-
-	let cancellationTokenSource: CancellationTokenSource | undefined = undefined;
-	return new Derived(
-		new DebugNameData(owner, undefined, computeFn),
-		r => {
-			if (cancellationTokenSource) {
-				cancellationTokenSource.dispose(true);
-			}
-			cancellationTokenSource = new CancellationTokenSource();
-			return computeFn(r, cancellationTokenSource.token);
-		}, undefined,
-		undefined,
-		() => cancellationTokenSource?.dispose(),
-		strictEquals,
-	);
-}